feat: Phase 2D — orchestrator, arguments/verdict endpoints, fabric announce

State machine driver + camp allocator + judge-submitted verdicts +
broadcast hook to Fabric announce channel.

internal/orchestrator/
- allocator.go: pure function implementing the 3-camp rule from the
  2026-05-23 design session — for each camp (pro/con/judge), random
  pick from volunteers; backfill unfilled camps from remaining
  unallocated signups if pool is large enough; <3 final → cancel
  with diagnostic reason. rng injected for test determinism.
- allocator_test.go: 7 tests covering empty/insufficient/single-volunteer
  /multi-volunteer-no-dup/backfill/insufficient-backfill/large-pool
  distinctness invariants. All pass.
- ticker.go: scans every 15s (configurable via ORCHESTRATOR_TICK_INTERVAL),
  drives 3 state transitions atomically:
    created → signup_open (post fabric announcement async)
    signup_open → signup_closed | cancelled (run allocator, write camps)
    signup_closed → debating (open round 0)
  debating → completed is driven by the verdict POST handler (the
  implicit "judging" sub-state is captured by the gate
  status==debating AND now>=debate_end_at). Per-topic transitions
  use SELECT FOR UPDATE so concurrent ticker instances are safe.

internal/fabric/announce.go: HTTP client posting to a Guild announce
channel using x-fabric-system-key header (the Phase 1 gate). Wraps
the formatted topic announcement (title/summary/timing/schema). All
4 config fields required to enable; any missing → no-op with log
(orchestrator runs fine without Fabric coupling for dev).

internal/store/{round,camp,argument,verdict}_store.go: CRUD layer
for the remaining v2 entities. CampStore.WriteAllocation accepts a
tx so the orchestrator can wrap allocator+camps+status into one
atomic transition.

internal/httpapi/handlers/arguments.go:
- POST /api/topics/{id}/arguments — agent posts during debate. Gates:
  agent must be in a camp on this topic; status==debating; content
  nonempty and <=32KB; attached to latest open round.
- GET /api/topics/{id}/arguments — full transcript, visibility-gated.

internal/httpapi/handlers/verdict.go:
- POST /api/topics/{id}/verdict — judge submits. Gates: caller==judge
  camp; status==debating AND now>=debate_end_at; verdict valid JSON;
  rationale required. On success: writes verdicts row (unique on
  topic_id → 409 on dup) and flips topic.status to completed.
- GET /api/topics/{id}/verdict — visibility-gated.

config: 5 new env vars — FABRIC_GUILD_BASE_URL,
FABRIC_ANNOUNCE_CHANNEL_ID, FABRIC_SYSTEM_API_KEY,
FABRIC_BOT_BEARER_TOKEN, ORCHESTRATOR_TICK_INTERVAL.

routes.go: wired new handlers — POST signups/arguments/verdict gated
on agent bearer; GET arguments/verdict on optional-auth chain
(public topics readable anonymously).

main.go: instantiates announcer + ticker; ticker.Run in a goroutine
sharing the lifetime ctx.

go vet + gofmt clean; 7/7 allocator tests pass; 12M static binary.

Next: Phase 2E (deploy to t3 with nginx + CF origin cert) or
Phase 2D.5 (SSE stream for live transcript subscribers).

internal/fabric/announce.go

@@ -0,0 +1,123 @@
+// Package fabric provides an HTTP client for posting system messages
+// to a Fabric Guild's announce-type channel.
+//
+// Auth model: Dialectic backend holds a system api key in
+// FABRIC_SYSTEM_API_KEY env. It POSTs to
+// `<guildBaseUrl>/api/channels/<channelId>/messages` with both:
+//   - `Authorization: Bearer <fabric-system-account-token>` (the
+//     "user" that posts; needs to be a Fabric Center user that owns
+//     the channel)
+//   - `x-fabric-system-key: <SYSTEM_API_KEY>` (the new header added
+//     in Phase 1 that gates announce-channel POSTs)
+//
+// Phase 2D ships this as an OPTIONAL coupling: if any of the three
+// config values is unset, the announcer is a no-op (logs the would-be
+// post and returns nil). This lets the orchestrator pipeline land + run
+// in environments where the Fabric coupling isn't configured yet.
+package fabric
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"time"
+)
+
+type AnnounceConfig struct {
+	GuildBaseURL   string // e.g. https://fabric-api.hangman-lab.top
+	ChannelID      string // the announce-type channel uuid
+	SystemAPIKey   string // x-fabric-system-key value
+	BotBearerToken string // Authorization: Bearer <token> — Fabric user posting; same
+	// user is the "channel author" the backend records
+	RequestTimeout time.Duration
+}
+
+type Announcer struct {
+	cfg    AnnounceConfig
+	client *http.Client
+}
+
+func NewAnnouncer(cfg AnnounceConfig) *Announcer {
+	if cfg.RequestTimeout <= 0 {
+		cfg.RequestTimeout = 5 * time.Second
+	}
+	return &Announcer{
+		cfg:    cfg,
+		client: &http.Client{Timeout: cfg.RequestTimeout},
+	}
+}
+
+// Enabled returns true iff every required Announcer config field is set.
+// Orchestrator checks this before each broadcast and silently skips when
+// false (with a one-time startup log).
+func (a *Announcer) Enabled() bool {
+	return a.cfg.GuildBaseURL != "" && a.cfg.ChannelID != "" &&
+		a.cfg.SystemAPIKey != "" && a.cfg.BotBearerToken != ""
+}
+
+// PostTopicAnnouncement posts a one-line system message describing a
+// new topic that's ready for signup. Best-effort: log + nil on transport
+// errors so a Fabric outage doesn't block topic transitions.
+func (a *Announcer) PostTopicAnnouncement(ctx context.Context, topicID, title, summary string,
+	signupOpen, signupClose, debateStart, debateEnd time.Time, verdictSchemaID string) error {
+
+	if !a.Enabled() {
+		log.Printf("announce: skipped (fabric coupling not configured) topic=%s", topicID)
+		return nil
+	}
+
+	body := map[string]any{
+		"content": formatAnnouncement(topicID, title, summary, signupOpen, signupClose, debateStart, debateEnd, verdictSchemaID),
+	}
+	raw, _ := json.Marshal(body)
+	url := fmt.Sprintf("%s/api/channels/%s/messages",
+		trimRightSlash(a.cfg.GuildBaseURL), a.cfg.ChannelID)
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(raw))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("content-type", "application/json")
+	req.Header.Set("authorization", "Bearer "+a.cfg.BotBearerToken)
+	req.Header.Set("x-fabric-system-key", a.cfg.SystemAPIKey)
+
+	resp, err := a.client.Do(req)
+	if err != nil {
+		log.Printf("announce: POST %s failed: %v", url, err)
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode >= 300 {
+		b, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
+		log.Printf("announce: POST %s -> %d body=%s", url, resp.StatusCode, string(b))
+		return fmt.Errorf("announce post: status %d", resp.StatusCode)
+	}
+	return nil
+}
+
+func formatAnnouncement(id, title, summary string,
+	signupOpen, signupClose, debateStart, debateEnd time.Time, schema string) string {
+	const layout = "2006-01-02 15:04 UTC"
+	return fmt.Sprintf(
+		"🆕 **Debate signup open** [%s]\n\n**%s**\n%s\n\n"+
+			"• Signup: %s → %s\n"+
+			"• Debate: %s → %s\n"+
+			"• Verdict schema: `%s`\n\n"+
+			"To volunteer, use the `dialectic_signup` tool with this topic_id and your willing camp(s) — pro / con / judge. "+
+			"You must have an `on_call` slot covering the debate window.",
+		id, title, summary,
+		signupOpen.UTC().Format(layout), signupClose.UTC().Format(layout),
+		debateStart.UTC().Format(layout), debateEnd.UTC().Format(layout),
+		schema,
+	)
+}
+
+func trimRightSlash(s string) string {
+	for len(s) > 0 && s[len(s)-1] == '/' {
+		s = s[:len(s)-1]
+	}
+	return s
+}