feat: lifecycle broadcasts on signup_closed / cancelled / debating / completed

Phase 3 push-wakeup mechanism without adding a new push channel.
Topic state transitions now post short messages to the same Fabric
announce channel used for the initial signup announcement. Agents
subscribed to announce + not currently busy get woken via the
existing Phase 1 inbound path; busy-discard already filters
appropriately. No SSE, no per-agent DM fanout, no plugin changes —
reuses existing infra end-to-end.

Changes:
- ticker.go: after signup_close transition, broadcasts signup_closed
  (with pro/con/judge agent IDs + debate-start time) OR cancelled
  (with reason). After debate_start transition, broadcasts debating
  with debate-end time.
- announce.go: new PostLifecycleEvent helper - same headers/auth as
  PostTopicAnnouncement, different format.
- verdict.go: after successful judge submission, broadcasts completed
  with the judge id. Best-effort + async so a slow Fabric does not
  slow the judge response.
- routes.go: instantiates the announcer once + passes to VerdictHandler.

Workflow participate-debate step 5 should be updated to expect
wakeups instead of polling - separate follow-up edit on lyn/ClawSkills.

internal/orchestrator/ticker.go

@@ -2,6 +2,7 @@ package orchestrator
 
 import (
 	"context"
+	"fmt"
 	"log"
 	"math/rand"
 	"time"
@@ -117,6 +118,10 @@ func (t *Ticker) tickOnce(ctx context.Context) {
 	if err := t.transitionByStatus(ctx, now,
 		models.TopicStatusSignupOpen, "signup_close_at",
 		func(ctx context.Context, tx *sqlx.Tx, topicID string) error {
+			topic, err := t.topics.GetByID(ctx, topicID)
+			if err != nil {
+				return err
+			}
 			signups, err := t.signups.ListByTopic(ctx, topicID)
 			if err != nil {
 				return err
@@ -128,6 +133,10 @@ func (t *Ticker) tickOnce(ctx context.Context) {
 					models.TopicStatusCancelled, res.CancelReason, topicID)
 				log.Printf("orchestrator: topic %s cancelled at signup_close: %s",
 					topicID, res.CancelReason)
+				if err == nil {
+					go t.broadcastLifecycle(topic, "cancelled",
+						fmt.Sprintf("debate cancelled at signup close — %s", res.CancelReason))
+				}
 				return err
 			}
 			if err := t.camps.WriteAllocation(ctx, tx, topicID, res.Allocation); err != nil {
@@ -139,6 +148,14 @@ func (t *Ticker) tickOnce(ctx context.Context) {
 			log.Printf("orchestrator: topic %s allocated pro=%s con=%s judge=%s",
 				topicID,
 				res.Allocation[models.CampPro], res.Allocation[models.CampCon], res.Allocation[models.CampJudge])
+			if err == nil {
+				go t.broadcastLifecycle(topic, "signup_closed",
+					fmt.Sprintf("camps allocated — pro=%s con=%s judge=%s. Debate starts at %s",
+						res.Allocation[models.CampPro],
+						res.Allocation[models.CampCon],
+						res.Allocation[models.CampJudge],
+						topic.DebateStartAt.UTC().Format("2006-01-02 15:04 UTC")))
+			}
 			return err
 		}); err != nil {
 		log.Printf("orchestrator: signup_open→signup_closed scan: %v", err)
@@ -148,6 +165,10 @@ func (t *Ticker) tickOnce(ctx context.Context) {
 	if err := t.transitionByStatus(ctx, now,
 		models.TopicStatusSignupClosed, "debate_start_at",
 		func(ctx context.Context, tx *sqlx.Tx, topicID string) error {
+			topic, err := t.topics.GetByID(ctx, topicID)
+			if err != nil {
+				return err
+			}
 			if _, err := tx.ExecContext(ctx,
 				`UPDATE topics SET status = ? WHERE id = ?`,
 				models.TopicStatusDebating, topicID); err != nil {
@@ -155,10 +176,15 @@ func (t *Ticker) tickOnce(ctx context.Context) {
 			}
 			// Round 0 inserted within the tx — if commit fails we don't
 			// leak a half-state.
-			_, err := tx.ExecContext(ctx,
+			_, err = tx.ExecContext(ctx,
 				`INSERT INTO rounds (id, topic_id, round_no) VALUES (UUID(), ?, 0)`,
 				topicID)
 			log.Printf("orchestrator: topic %s entered debating; round 0 opened", topicID)
+			if err == nil {
+				go t.broadcastLifecycle(topic, "debating",
+					fmt.Sprintf("debate is live — pro/con post arguments; judge stays mostly silent until debate_end_at (%s). Use participate-debate workflow.",
+						topic.DebateEndAt.UTC().Format("2006-01-02 15:04 UTC")))
+			}
 			return err
 		}); err != nil {
 		log.Printf("orchestrator: signup_closed→debating scan: %v", err)
@@ -220,6 +246,20 @@ func (t *Ticker) applyOne(ctx context.Context, topicID string,
 	return tx.Commit()
 }
 
+// broadcastLifecycle wraps the announcer's lifecycle-event post with
+// the standard signup_closed / cancelled / debating / completed
+// formats. Best-effort; runs in its own goroutine outside any tx.
+func (t *Ticker) broadcastLifecycle(topic *models.Topic, kind, summary string) {
+	if topic == nil {
+		return
+	}
+	if err := t.announcer.PostLifecycleEvent(
+		context.Background(), topic.ID, topic.Title, kind, summary,
+	); err != nil {
+		log.Printf("orchestrator: lifecycle broadcast topic=%s kind=%s failed: %v", topic.ID, kind, err)
+	}
+}
+
 func (t *Ticker) broadcastAnnouncement(topic *models.Topic) {
 	if topic == nil {
 		return