privateboard 0.1.15 → 0.1.16

package/dist/cli.js

@@ -584,6 +584,122 @@ ALTER TABLE topic_recs ADD COLUMN tag TEXT;
   }
 });
 
+// src/storage/migrations/036_negative_space.sql
+var negative_space_default;
+var init_negative_space = __esm({
+  "src/storage/migrations/036_negative_space.sql"() {
+    negative_space_default = `-- Negative-space memory \xB7 Layer 3.2 of the divergence stack.
+-- At round-end the chair extracts "what this round did NOT touch
+-- but should have" \u2014 angles raised-then-abandoned, dimensions
+-- conspicuously absent. These get injected into the next round's
+-- director prompts as "UNEXPLORED ANGLES" so the room has positive-
+-- space breadcrumbs alongside the frame-break negative-space rules.
+--
+-- One row per angle (not one row per round) so the next-round
+-- prompt can pull the top-N most recent regardless of round
+-- boundaries \xB7 enables cross-round angle memory.
+CREATE TABLE IF NOT EXISTS negative_space (
+  id          TEXT PRIMARY KEY,
+  room_id     TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+  round_num   INTEGER NOT NULL,
+  angle       TEXT NOT NULL,
+  created_at  INTEGER NOT NULL,
+  -- Soft consumption flag \xB7 when a subsequent round prompt injected
+  -- this angle and the room actually engaged with it, the chair
+  -- post-processor flips this to 1. Subsequent rounds prefer
+  -- unconsumed angles to avoid suggesting the same thing twice.
+  consumed    INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_negative_space_room_round
+  ON negative_space(room_id, round_num);
+CREATE INDEX IF NOT EXISTS idx_negative_space_room_unconsumed
+  ON negative_space(room_id, consumed);
+`;
+  }
+});
+
+// src/storage/migrations/037_topic_branches.sql
+var topic_branches_default;
+var init_topic_branches = __esm({
+  "src/storage/migrations/037_topic_branches.sql"() {
+    topic_branches_default = `-- Topic-tree tracking \xB7 Layer 3.1 of the divergence stack.
+-- Each director turn gets tagged with a branch_id \xB7 the cluster of
+-- prior turns it extended. New top-level branches are surfaced when
+-- a turn opens a genuinely fresh angle. Drives:
+--   \xB7 dissent-gap picker (Layer 2.1) prefers directors who have NOT
+--     spoken on the dominant branches
+--   \xB7 UI \xB7 optional "topic map" overlay so the user sees the room's
+--     coverage breadth
+--   \xB7 structured summarization \xB7 long rooms can summarize by branch
+--     instead of by chronological round
+CREATE TABLE IF NOT EXISTS topic_branches (
+  id          TEXT PRIMARY KEY,
+  room_id     TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+  label       TEXT NOT NULL,         -- short noun-phrase name (\u2264 8 words)
+  parent_id   TEXT,                  -- nullable \xB7 top-level branches have NULL
+  opened_at   INTEGER NOT NULL,      -- ms epoch \xB7 ordering / decay
+  -- Activity counters \xB7 maintained by the post-turn tagger so the
+  -- picker can score "this branch is hot" / "this branch is unspoken".
+  turn_count  INTEGER NOT NULL DEFAULT 0,
+  last_speaker_id TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_topic_branches_room
+  ON topic_branches(room_id, opened_at);
+
+-- Per-message branch assignment \xB7 one row per director message.
+-- Populated by a post-turn haiku tagger that reads the message body
+-- + the room's current branch list and decides: "extends branch X"
+-- or "opens new branch Y". Idempotent \xB7 re-running the tagger for
+-- the same message_id replaces the row.
+CREATE TABLE IF NOT EXISTS message_branches (
+  message_id  TEXT PRIMARY KEY REFERENCES messages(id) ON DELETE CASCADE,
+  branch_id   TEXT NOT NULL REFERENCES topic_branches(id) ON DELETE CASCADE,
+  is_opener   INTEGER NOT NULL DEFAULT 0,   -- 1 = this message opened the branch
+  tagged_at   INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_message_branches_branch
+  ON message_branches(branch_id);
+`;
+  }
+});
+
+// src/storage/migrations/038_qd_archive.sql
+var qd_archive_default;
+var init_qd_archive = __esm({
+  "src/storage/migrations/038_qd_archive.sql"() {
+    qd_archive_default = `-- Quality-Diversity behavioral archive \xB7 Layer 4 of the divergence
+-- stack. Each director message gets scored on 3 behavioral
+-- dimensions (abstraction-level / time-scale / stakeholder-scope) by
+-- a cheap haiku post-turn. The resulting (a, t, s) triple maps to a
+-- single cell in a 4\xD74\xD74 = 64-cell grid \xB7 the room's "MAP-Elites
+-- archive". Picker layers can query the archive to reward
+-- candidates whose persona is likely to fill an EMPTY cell, and the
+-- room-end report shows coverage as a divergence KPI.
+--
+-- One row per (message, dimensions) so re-tagging is idempotent \xB7
+-- the post-turn scorer always INSERT OR REPLACE.
+CREATE TABLE IF NOT EXISTS qd_archive (
+  message_id   TEXT PRIMARY KEY REFERENCES messages(id) ON DELETE CASCADE,
+  room_id      TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+  -- Dimension scores in [0, 1] \xB7 float for diagnostics, INTEGER
+  -- bucket [0, 3] for the cell index. All scored by the same haiku
+  -- pass to amortize cost.
+  abstraction_score  REAL NOT NULL,
+  abstraction_bucket INTEGER NOT NULL,
+  time_score         REAL NOT NULL,
+  time_bucket        INTEGER NOT NULL,
+  stakeholder_score  REAL NOT NULL,
+  stakeholder_bucket INTEGER NOT NULL,
+  scored_at          INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_qd_archive_room
+  ON qd_archive(room_id);
+CREATE INDEX IF NOT EXISTS idx_qd_archive_room_cell
+  ON qd_archive(room_id, abstraction_bucket, time_bucket, stakeholder_bucket);
+`;
+  }
+});
+
 // src/storage/db.ts
 var db_exports = {};
 __export(db_exports, {
@@ -676,6 +792,9 @@ var init_db = __esm({
     init_room_members_removed_at();
     init_user_topic_recs();
     init_topic_rec_tag();
+    init_negative_space();
+    init_topic_branches();
+    init_qd_archive();
     MIGRATIONS = [
       { name: "001_init.sql", sql: init_default },
       { name: "002_default_opus.sql", sql: default_opus_default },
@@ -711,7 +830,10 @@ var init_db = __esm({
       { name: "032_room_vote_trigger.sql", sql: room_vote_trigger_default },
       { name: "033_room_members_removed_at.sql", sql: room_members_removed_at_default },
       { name: "034_user_topic_recs.sql", sql: user_topic_recs_default },
-      { name: "035_topic_rec_tag.sql", sql: topic_rec_tag_default }
+      { name: "035_topic_rec_tag.sql", sql: topic_rec_tag_default },
+      { name: "036_negative_space.sql", sql: negative_space_default },
+      { name: "037_topic_branches.sql", sql: topic_branches_default },
+      { name: "038_qd_archive.sql", sql: qd_archive_default }
     ];
     _db = null;
   }
@@ -965,6 +1087,8 @@ function parsePersonaSpec(raw) {
     const differentiationScore = typeof obj.differentiationScore === "number" && Number.isFinite(obj.differentiationScore) ? obj.differentiationScore : null;
     const toolAccessRaw = obj.toolAccess || {};
     const toolAccess = { webSearch: toolAccessRaw.webSearch !== false };
+    const buildLog = parseBuildLog(obj.buildLog);
+    const guessName = typeof obj.guessName === "string" && obj.guessName.trim().length > 0 ? obj.guessName.trim() : void 0;
     return {
       version: 1,
       generatedAt,
@@ -976,12 +1100,75 @@ function parsePersonaSpec(raw) {
       reflectionChecklist,
       evalSet,
       differentiationScore,
-      toolAccess
+      toolAccess,
+      ...guessName ? { guessName } : {},
+      ...buildLog ? { buildLog } : {}
     };
   } catch {
     return null;
   }
 }
+function parseBuildLog(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const obj = raw;
+  const narrative = typeof obj.narrative === "string" ? obj.narrative : "";
+  const locale = obj.locale === "en" || obj.locale === "zh" || obj.locale === "ja" || obj.locale === "es" ? obj.locale : "en";
+  const generatedAt = typeof obj.generatedAt === "number" && Number.isFinite(obj.generatedAt) ? obj.generatedAt : 0;
+  const events = [];
+  if (Array.isArray(obj.events)) {
+    for (const e of obj.events) {
+      if (!e || typeof e !== "object") continue;
+      const ev = e;
+      const ts = typeof ev.ts === "number" ? ev.ts : 0;
+      const kind = ev.kind;
+      if (kind === "phase-start" && typeof ev.phase === "number" && typeof ev.label === "string") {
+        events.push({ kind, ts, phase: ev.phase, label: ev.label });
+      } else if (kind === "phase-end" && typeof ev.phase === "number" && typeof ev.durationMs === "number") {
+        events.push({ kind, ts, phase: ev.phase, durationMs: ev.durationMs });
+      } else if (kind === "dimension-plan" && Array.isArray(ev.dimensions)) {
+        const dims = ev.dimensions.flatMap((d) => {
+          if (!d || typeof d !== "object") return [];
+          const x = d;
+          if (typeof x.dimension !== "string" || typeof x.query !== "string") return [];
+          return [{
+            dimension: x.dimension,
+            query: x.query,
+            why: typeof x.why === "string" ? x.why : ""
+          }];
+        });
+        events.push({ kind, ts, dimensions: dims });
+      } else if (kind === "search" && typeof ev.query === "string") {
+        events.push({
+          kind,
+          ts,
+          query: ev.query,
+          resultsCount: typeof ev.resultsCount === "number" ? ev.resultsCount : 0,
+          pagesRead: typeof ev.pagesRead === "number" ? ev.pagesRead : 0,
+          ...typeof ev.dimension === "string" ? { dimension: ev.dimension } : {},
+          ...typeof ev.round === "number" ? { round: ev.round } : {},
+          ...ev.topup === true ? { topup: true } : {}
+        });
+      } else if (kind === "divergence") {
+        events.push({
+          kind,
+          ts,
+          score: typeof ev.score === "number" && Number.isFinite(ev.score) ? ev.score : null
+        });
+      } else if (kind === "error" && typeof ev.message === "string") {
+        events.push({ kind, ts, message: ev.message });
+      }
+    }
+  }
+  if (!narrative && events.length === 0) return null;
+  const totalTokens = typeof obj.totalTokens === "number" && Number.isFinite(obj.totalTokens) ? Math.max(0, Math.round(obj.totalTokens)) : void 0;
+  return {
+    narrative,
+    locale,
+    generatedAt,
+    events,
+    ...totalTokens !== void 0 ? { totalTokens } : {}
+  };
+}
 function serializeVoice(v) {
   if (!v) return null;
   const provider = VALID_VOICE_PROVIDERS.has(v.provider) ? v.provider : null;
@@ -4303,6 +4490,169 @@ var PersonaBus = class {
 };
 var personaBus = new PersonaBus();
 
+// src/orchestrator/persona-narrator.ts
+var NARRATOR_TIMEOUT_MS = 6e4;
+var NARRATOR_MAX_TOKENS = 900;
+function narratorCandidates() {
+  const out = [];
+  const utility = utilityModelFor();
+  if (utility) out.push(utility);
+  const flagship = effectiveDefaultModel();
+  if (flagship && !out.includes(flagship)) out.push(flagship);
+  for (const m of reachableModels()) {
+    if (FLAGSHIP_TIER.has(m.modelV) && !out.includes(m.modelV)) out.push(m.modelV);
+  }
+  return out;
+}
+var LOCALE_HINTS = {
+  en: "Write the summary in clear, warm English.",
+  zh: "\u7528\u6D41\u7545\u81EA\u7136\u7684\u7B80\u4F53\u4E2D\u6587\u5199\u8FD9\u6BB5\u603B\u8FF0\u3002",
+  ja: "\u89AA\u3057\u307F\u3084\u3059\u3044\u81EA\u7136\u306A\u65E5\u672C\u8A9E\u3067\u66F8\u3044\u3066\u304F\u3060\u3055\u3044\u3002",
+  es: "Escribe el resumen en espa\xF1ol claro y cercano."
+};
+function summarizeEvents(events) {
+  const phases = [];
+  const searchesByDim = /* @__PURE__ */ new Map();
+  const topupSearches = [];
+  let dimensionPlan = [];
+  let divergenceScore = null;
+  for (const e of events) {
+    if (e.kind === "phase-start") {
+      phases.push({ phase: e.phase, label: e.label });
+    } else if (e.kind === "phase-end") {
+      const found = phases.find((p) => p.phase === e.phase);
+      if (found) found.durationMs = e.durationMs;
+    } else if (e.kind === "dimension-plan") {
+      dimensionPlan = e.dimensions;
+    } else if (e.kind === "search") {
+      if (e.topup) {
+        topupSearches.push({ query: e.query, sources: e.pagesRead });
+      } else if (e.dimension) {
+        const cur = searchesByDim.get(e.dimension) ?? { count: 0, sources: 0, queries: [] };
+        cur.count += 1;
+        cur.sources += e.pagesRead;
+        cur.queries.push(e.query);
+        searchesByDim.set(e.dimension, cur);
+      }
+    } else if (e.kind === "divergence") {
+      divergenceScore = e.score;
+    }
+  }
+  const lines = [];
+  lines.push("Phases that ran:");
+  for (const p of phases) {
+    const dur = typeof p.durationMs === "number" ? ` (${Math.round(p.durationMs / 1e3)}s)` : "";
+    lines.push(`  ${p.phase}. ${p.label}${dur}`);
+  }
+  if (dimensionPlan.length > 0) {
+    lines.push("");
+    lines.push(`Research angles (picked by the planner, ${dimensionPlan.length} total):`);
+    for (const d of dimensionPlan) {
+      const stats = searchesByDim.get(d.dimension);
+      const tail = stats ? ` \u2014 ${stats.sources} sources read` : "";
+      lines.push(`  \u2022 ${d.dimension}: ${d.why || d.query}${tail}`);
+    }
+  }
+  if (topupSearches.length > 0) {
+    lines.push("");
+    lines.push(`Top-up gap searches (${topupSearches.length}):`);
+    for (const t of topupSearches) {
+      lines.push(`  \u2022 "${t.query}" \u2192 ${t.sources} sources`);
+    }
+  }
+  if (divergenceScore !== null) {
+    lines.push("");
+    lines.push(`Voice uniqueness vs generic AI baseline: ${Math.round(divergenceScore * 100)}%`);
+  }
+  return lines.join("\n");
+}
+var NARRATOR_SYSTEM = [
+  "You are writing a short, pitch-style summary of how a custom AI persona was just built.",
+  "",
+  "Audience: the person who kicked the build. They watched a progress bar \u2014 they have no idea what the pipeline actually DID under the hood. Your job is to tell them, in plain language.",
+  "",
+  "Hard rules:",
+  "  1. NEVER use jargon. Do NOT say 'multi-dimensional retrieval', 'ReAct loop', 'lexical divergence', 'parallel batch', 'synthesis', 'critique pass', 'eval set', 'differentiation probe'.",
+  "  2. Instead, say things like: 'we looked at the question from several different angles', 'we double-checked a couple of gaps', 'we drafted the personality twice \u2014 once cold, once after reading up', 'this voice came out N% different from a generic AI'.",
+  "  3. First-person plural ('we'). Warm tone. Short sentences. 3-5 short paragraphs.",
+  "  4. Use specific details from the build log \u2014 name the angles by name, mention concrete sources-read counts, quote a sample query if it helps.",
+  "  5. Stay between 200 and 400 words.",
+  "  6. Do NOT use Markdown. Plain prose only, no headers, no bullet points.",
+  "  7. Do NOT mention the model name, the agent's database id, or any internal terminology.",
+  "  8. End with a single short sentence that invites the user to talk to the new director."
+].join("\n");
+async function runPersonaNarrator(state, input) {
+  const eventsSummary = summarizeEvents(input.events);
+  if (!eventsSummary.trim()) return "";
+  const profileBlock = input.profileV2 ? [
+    "Persona shape (refined):",
+    "",
+    "```json",
+    JSON.stringify(
+      {
+        intellectualLineage: input.profileV2.intellectualLineage,
+        contrarianTakes: input.profileV2.contrarianTakes,
+        loadBearingConcepts: input.profileV2.loadBearingConcepts
+      },
+      null,
+      2
+    ),
+    "```"
+  ].join("\n") : "";
+  const userBody = [
+    `What the user asked us to build:`,
+    ``,
+    input.description.trim(),
+    ``,
+    input.guessName ? `Director we ended up naming: ${input.guessName}` : "",
+    "",
+    "Build log (structured):",
+    "",
+    eventsSummary,
+    "",
+    profileBlock,
+    "",
+    LOCALE_HINTS[input.locale],
+    "",
+    "Now write the 200-400 word pitch-style summary."
+  ].filter((s) => s !== "").join("\n");
+  const messages = [
+    { role: "system", content: NARRATOR_SYSTEM },
+    { role: "user", content: userBody }
+  ];
+  const candidates = narratorCandidates();
+  for (const modelV of candidates) {
+    if (!isModelV(modelV)) continue;
+    if (state.controller.signal.aborted) return "";
+    const controller = new AbortController();
+    const onParentAbort = () => controller.abort();
+    state.controller.signal.addEventListener("abort", onParentAbort, { once: true });
+    const timer = setTimeout(() => controller.abort(), NARRATOR_TIMEOUT_MS);
+    try {
+      const r = await callLLMWithUsage({
+        modelV,
+        messages,
+        temperature: 0.7,
+        maxTokens: NARRATOR_MAX_TOKENS,
+        signal: controller.signal
+      });
+      if (r.usage) {
+        state.totalPromptTokens += r.usage.promptTokens;
+        state.totalOutputTokens += r.usage.completionTokens;
+      }
+      const out = (r.text || "").trim();
+      if (out.length >= 80) return out;
+    } catch (e) {
+      process.stderr.write(`[persona-narrator] ${modelV} failed: ${e instanceof Error ? e.message : String(e)}
+`);
+    } finally {
+      clearTimeout(timer);
+      state.controller.signal.removeEventListener("abort", onParentAbort);
+    }
+  }
+  return "";
+}
+
 // src/orchestrator/persona-builder.ts
 var LLM_CALL_TIMEOUT_MS = 9e4;
 var BUILD_WALL_CLOCK_MS = 10 * 6e4;
@@ -4341,8 +4691,12 @@ function signalWithTimeout(parent, timeoutMs) {
   };
 }
 function bumpTokens(state, prompt, output) {
-  state.promptTokens += Math.max(0, prompt | 0);
-  state.outputTokens += Math.max(0, output | 0);
+  const p = Math.max(0, prompt | 0);
+  const o = Math.max(0, output | 0);
+  state.promptTokens += p;
+  state.outputTokens += o;
+  state.totalPromptTokens += p;
+  state.totalOutputTokens += o;
   return state.promptTokens > PROMPT_TOKEN_CEILING || state.outputTokens > OUTPUT_TOKEN_CEILING;
 }
 function flagshipCandidates() {
@@ -4415,14 +4769,19 @@ function startPersonaBuild(opts) {
   const state = {
     id: jobId,
     description,
+    locale: opts.locale ?? "en",
     startedAt: Date.now(),
     controller: new AbortController(),
     promptTokens: 0,
     outputTokens: 0,
+    totalPromptTokens: 0,
+    totalOutputTokens: 0,
     searchRounds: [],
     dimensionPlan: [],
     rawSourcesByDim: /* @__PURE__ */ new Map(),
-    rawSourcesTopup: []
+    rawSourcesTopup: [],
+    buildEvents: [],
+    phaseStartedAt: /* @__PURE__ */ new Map()
   };
   inFlightJobs.set(jobId, state);
   const wallClockTimer = setTimeout(() => {
@@ -4462,18 +4821,42 @@ async function runPipeline(state) {
   const phaseEtas = [30, 280, 30, 45, 90, 30, 60];
   const totalEta = phaseEtas.reduce((a, b) => a + b, 0);
   let progressBaselinePct = 0;
+  const recordEvent = (ev) => {
+    state.buildEvents.push(ev);
+  };
+  const syncBuildLogSnapshot = () => {
+    partial.buildLog = {
+      narrative: partial.buildLog?.narrative ?? "",
+      locale: state.locale,
+      generatedAt: partial.buildLog?.generatedAt ?? 0,
+      events: state.buildEvents.slice(),
+      totalTokens: state.totalPromptTokens + state.totalOutputTokens
+    };
+  };
   const startPhase = (phase) => {
     const i = phase - 1;
+    const now = Date.now();
+    state.phaseStartedAt.set(phase, now);
     personaBus.emit(state.id, {
       type: "persona-phase-start",
       phase,
       label: phaseLabels[i],
       etaSec: phaseEtas[i]
     });
+    recordEvent({ kind: "phase-start", ts: now, phase, label: phaseLabels[i] });
   };
   const finishPhase = (phase) => {
     const i = phase - 1;
     progressBaselinePct = Math.round(phaseEtas.slice(0, i + 1).reduce((a, b) => a + b, 0) / totalEta * 100);
+    const startedAt = state.phaseStartedAt.get(phase) ?? Date.now();
+    const finishedAt = Date.now();
+    recordEvent({
+      kind: "phase-end",
+      ts: finishedAt,
+      phase,
+      durationMs: Math.max(0, finishedAt - startedAt)
+    });
+    syncBuildLogSnapshot();
     personaBus.emit(state.id, {
       type: "persona-phase-end",
       phase,
@@ -4598,10 +4981,43 @@ async function runPipeline(state) {
       partial.evalSet = scored;
       const valid = scored.map((e) => e.divergenceScore).filter((s) => s !== null);
       partial.differentiationScore = valid.length > 0 ? valid.reduce((a, b) => a + b, 0) / valid.length : null;
+      state.buildEvents.push({
+        kind: "divergence",
+        ts: Date.now(),
+        score: partial.differentiationScore
+      });
     }
     partial.toolAccess = { webSearch: hasWebSearchKey() };
     reportProgress(7, "naming the director", 0.85);
     partial.guessName = await runNamePhase(state, partial.profileV2) || void 0;
+    reportProgress(7, "summarising the build", 0.92);
+    try {
+      const narrative = await runPersonaNarrator(state, {
+        description: state.description,
+        locale: state.locale,
+        events: state.buildEvents,
+        profileV2: partial.profileV2 ?? null,
+        differentiationScore: partial.differentiationScore ?? null,
+        guessName: partial.guessName ?? null
+      });
+      partial.buildLog = {
+        narrative: narrative || "",
+        locale: state.locale,
+        generatedAt: Date.now(),
+        events: state.buildEvents.slice(),
+        totalTokens: state.totalPromptTokens + state.totalOutputTokens
+      };
+    } catch (e) {
+      process.stderr.write(`[persona-builder/narrator] failed: ${e instanceof Error ? e.message : String(e)}
+`);
+      partial.buildLog = {
+        narrative: "",
+        locale: state.locale,
+        generatedAt: Date.now(),
+        events: state.buildEvents.slice(),
+        totalTokens: state.totalPromptTokens + state.totalOutputTokens
+      };
+    }
     finishPhase(7);
     {
       const status = checkAbortOrCap();
@@ -4685,6 +5101,11 @@ async function runReActLoop(state, profileV1, reportProgress) {
     type: "persona-dimension-plan",
     dimensions: plan.slice()
   });
+  state.buildEvents.push({
+    kind: "dimension-plan",
+    ts: Date.now(),
+    dimensions: plan.map((d) => ({ dimension: d.dimension, query: d.query, why: d.why }))
+  });
   reportProgress(2, `${plan.length} angles picked \xB7 searching in parallel`, 0.05);
   let doneCount = 0;
   for (let chunkStart = 0; chunkStart < plan.length; chunkStart += DIMENSION_PARALLEL_CHUNK) {
@@ -4806,6 +5227,15 @@ ${ext.text}
       pagesRead: pageExtracts.filter((e) => e.ok).length,
       phase: "topup"
     });
+    state.buildEvents.push({
+      kind: "search",
+      ts: Date.now(),
+      query,
+      resultsCount: resultsArr.length,
+      pagesRead: pageExtracts.filter((e) => e.ok).length,
+      round: roundNum,
+      topup: true
+    });
   }
   const merged = concatRawSources(state);
   if (!merged.trim()) {
@@ -4927,6 +5357,15 @@ ${ext.text}
     dimension: entry.dimension,
     phase: "dimension"
   });
+  state.buildEvents.push({
+    kind: "search",
+    ts: Date.now(),
+    query: entry.query,
+    resultsCount: resultsArr.length,
+    pagesRead: pageCount,
+    dimension: entry.dimension,
+    round: roundNum
+  });
 }
 function concatRawSources(state) {
   const parts = [];
@@ -5154,7 +5593,8 @@ function partialToPersona(partial) {
     evalSet: partial.evalSet || [],
     differentiationScore: partial.differentiationScore ?? null,
     toolAccess: partial.toolAccess || { webSearch: false },
-    ...partial.guessName ? { guessName: partial.guessName } : {}
+    ...partial.guessName ? { guessName: partial.guessName } : {},
+    ...partial.buildLog ? { buildLog: partial.buildLog } : {}
   };
 }
 function getPartialPersona(jobId) {
@@ -5174,7 +5614,8 @@ function getPartialPersona(jobId) {
     evalSet: v.evalSet || [],
     differentiationScore: typeof v.differentiationScore === "number" ? v.differentiationScore : null,
     toolAccess: v.toolAccess || { webSearch: false },
-    ...typeof v.guessName === "string" && v.guessName ? { guessName: v.guessName } : {}
+    ...typeof v.guessName === "string" && v.guessName ? { guessName: v.guessName } : {},
+    ...v.buildLog ? { buildLog: v.buildLog } : {}
   };
 }
 
@@ -6918,7 +7359,9 @@ function agentsRouter() {
     if (description.length > 1200) {
       return c.json({ error: "description too long (max 1200 chars)" }, 400);
     }
-    const jobId = startPersonaBuild({ description });
+    const localeRaw = typeof b.locale === "string" ? b.locale : "";
+    const locale = localeRaw === "zh" || localeRaw === "ja" || localeRaw === "es" ? localeRaw : "en";
+    const jobId = startPersonaBuild({ description, locale });
     return c.json({ jobId });
   });
   r.get("/generate-persona/:jobId/stream", (c) => {
@@ -8166,15 +8609,15 @@ var SCAFFOLD_SYSTEM = [
   "",
   "7b. **Director Perspectives** (`directorPerspectives`) \xB7 MANDATORY in every brief with \u2265 2 active directors. The \"social map\" of the room \u2014 every active director gets a row, alignment / divergence groups are explicit, the chair's structural observation closes the block. Distinct from convergence (narrow), divergence (single central tension), positions (2-3 camps with quotes). views-compared is the bird's-eye view that lets a stakeholder skim WHO was in the room and where each one stood. Object shape: `{ intro, alignment: [...], divergence: [...], perspectives: [...], chairSynthesis }`. Each entry of `perspectives`: `directorId` (must match the room's member list), `stance` (\u2264 60 chars short label of the director's angle), `position` (1-2 sentences \u2264 300 chars \xB7 the director's load-bearing argument in their voice), `quote` (optional verbatim \u2264 40 words; empty when no memorable line), `lens` (data | dissent | narrative | structural | first-principle). EVERY active director gets one entry \u2014 no exceptions. Each `alignment` group: `pointOfAgreement` (\u2264 80 chars), `directorIds` (\u2265 2), `note` (\u2264 220 chars \xB7 why the convergence is structurally interesting \xB7 prefer to surface independent paths to same conclusion). Each `divergence` entry: `hinge` (\u2264 140 chars \xB7 what separates them), `sides` (2-3 named sides; each: label / directorIds / 1-sentence stance), `resolution` (\u2264 220 chars \xB7 what would settle it; empty when unresolved). `chairSynthesis` (2-4 sentences, \u2264 400 chars) is the chair's meta-observation comparing the views \u2014 moderator-neutral voice, observation not advocacy. Set the WHOLE block to `null` ONLY when there's exactly 1 active director (no comparison possible).",
   "",
-  "8. **Visuals** \xB7 0\u20134 blocks. Content-driven. **Strongly prefer mermaid sub-types over text matrices** \u2014 mermaid renders as a real diagram readers can scan in seconds; text matrices are dense tables that take paragraphs to absorb. Only fall back to text matrix when the data shape genuinely doesn't fit any mermaid form.",
+  "8. **Visuals** \xB7 0\u20134 blocks. Content-driven. **Strongly prefer chart sub-types over text matrices** \u2014 charts render as a real diagram readers can scan in seconds; text matrices are dense tables that take paragraphs to absorb. Only fall back to text matrix when the data shape genuinely doesn't fit any chart form.",
   "",
-  "   Mermaid (preferred):",
-  "   \xB7 `quadrant-chart`    \u2014 items plotted on two real axes (mermaid quadrantChart). Effort/impact, support/strength, urgency/uncertainty.",
-  "   \xB7 `bar-chart`         \u2014 2\u20138 named items ranked by ONE quantitative dimension (mermaid xychart-beta \xB7 cost / support / size / time)",
-  "   \xB7 `timeline`          \u2014 3\u20138 dated points telling a narrative arc (mermaid timeline \xB7 retro / historical analogue / projected sequence)",
-  "   \xB7 `pie-chart`         \u2014 2\u20136 slices showing a distribution (mermaid pie \xB7 scenario probabilities / lens shares / vote tallies / market mix). Numbers can be percentages OR raw counts \u2014 mermaid normalises.",
+  "   Chart sub-types (strongly preferred \xB7 all rendered as inline SVG through the `kami-chart` pipeline):",
+  "   \xB7 `quadrant-chart`    \u2014 items plotted on two real axes. Effort/impact, support/strength, urgency/uncertainty. Rendered as inline SVG via the `kami-chart` pipeline.",
+  "   \xB7 `bar-chart`         \u2014 2\u20138 named items ranked by ONE quantitative dimension \xB7 cost / support / size / time. Rendered as inline SVG via the `kami-chart` pipeline (spine-tokenised, no JS runtime).",
+  "   \xB7 `timeline`          \u2014 3\u20138 dated points telling a narrative arc \xB7 retro / historical analogue / projected sequence. Rendered as inline SVG via the `kami-chart` pipeline.",
+  "   \xB7 `pie-chart`         \u2014 2\u20136 slices showing a distribution \xB7 scenario probabilities / lens shares / vote tallies / market mix. Rendered as a DONUT (hollow centre carries the largest slice's value) via the `kami-chart` pipeline. Numbers can be percentages OR raw counts \u2014 the renderer normalises.",
   "",
-  "   Text matrices (fall back when no mermaid form fits):",
+  "   Text matrices (fall back when no chart form fits):",
   "   \xB7 `comparison-table`  \u2014 \u2265 2 named options compared on shared dimensions",
   "   \xB7 `force-field`       \u2014 drivers vs resistors of one outcome",
   "   \xB7 `strengths-cautions`\u2014 strengths / cautions / verdict per option",
@@ -8187,7 +8630,7 @@ var SCAFFOLD_SYSTEM = [
   "   \xB7 ONLY when the data is N-options \xD7 M-criteria with mixed cell types (text + numbers + tags) \u2192 `comparison-table`.",
   "   \xB7 ONLY when the room argued exactly one outcome with for/against forces \u2192 `force-field`.",
   "   \xB7 ONLY when N options each need a strengths/cautions/verdict triplet AND no numeric ranking \u2192 `strengths-cautions`.",
-  "   These six routes cover most rooms. Default toward picking 2\u20133 visuals (one quantitative + one categorical) \u2014 the writer is forbidden from emitting only text matrices. Beyond these, the Stage 3 writer also emits inline mermaid (flowchart / mindmap / gantt / sequenceDiagram / stateDiagram / journey) where prose can't carry the structure efficiently \u2014 those don't go in the typed `visuals` list, so don't pre-allocate them here.",
+  "   These six routes cover most rooms. Default toward picking 2\u20133 visuals (one quantitative + one categorical) \u2014 the writer is forbidden from emitting only text matrices. Beyond these, the Stage 3 writer also emits inline charts (flowchart / mindmap / gantt / sequenceDiagram / stateDiagram / journey \u2014 all rendered through the `kami-chart` pipeline) where prose can't carry the structure efficiently \u2014 those don't go in the typed `visuals` list, so don't pre-allocate them here.",
   "",
   '9. **Recommendations** \xB7 3\u20135 concrete actions, each with: `priority` (P0/P1/P2), `action` (imperative), `rationale`, `ownerType`, `horizon` (e.g. "next 30 days"), `successMetric` (observable proof of execution), `riskIfSkipped`, `expectedBenefit` (the upside if you act \u2014 stated as a concrete payoff, NOT a metric to watch). Recommendations are imperatives \u2014 "Do X" not "X should happen". The `expectedBenefit` is what gets a stakeholder to actually approve the action \u2014 it answers "if I do this, what do I get?" in one short sentence.',
   "",
@@ -9174,26 +9617,33 @@ var WRITE_SYSTEM = [
   "",
   "    For `quadrant-chart`:",
   "      ### {title}",
-  "      Render a fenced ```mermaid block with `quadrantChart`. EXACT shape \u2014 mermaid 10.9.5 is strict:",
+  '      Render a fenced ```kami-chart block \xB7 strict JSON. Two-axis plot where the top-right (Q1) quadrant is the brand\'s "preferred" zone, tinted in the spine accent. Schema:',
   "      ```",
-  "      quadrantChart",
-  "          title {title}",
-  '          x-axis "Low {xLabel}" --> "High {xLabel}"',
-  '          y-axis "Low {yLabel}" --> "High {yLabel}"',
-  '          quadrant-1 "{q1}"',
-  '          quadrant-2 "{q2}"',
-  '          quadrant-3 "{q3}"',
-  '          quadrant-4 "{q4}"',
-  '          "{item.label}": [{item.x}, {item.y}]',
+  "      {",
+  '        "type": "quadrant-chart",',
+  '        "title": "{scaffold.title}",',
+  '        "xLabel": "{scaffold.xLabel \xB7 low\u2192high}",',
+  '        "yLabel": "{scaffold.yLabel \xB7 low\u2192high}",',
+  '        "q1": "{top-right \xB7 preferred}",',
+  '        "q2": "{top-left}",',
+  '        "q3": "{bottom-left}",',
+  '        "q4": "{bottom-right}",',
+  '        "focal": "{label of the load-bearing item \xB7 optional}",',
+  '        "items": [',
+  '          { "label": "Item A", "x": 0.72, "y": 0.84 },',
+  '          { "label": "Item B", "x": 0.35, "y": 0.66, "tier": 4 }',
+  "        ],",
+  '        "caption": "{One-sentence editorial gloss with *italic* on the operative phrase.}"',
+  "      }",
   "      ```",
-  "      Hard rules to avoid mermaid syntax errors (the lexer fails on non-ASCII in unquoted labels):",
-  '        \xB7 BOTH x-axis AND y-axis lines MUST be `... "Low X" --> "High X"` form \u2014 both ends in DOUBLE QUOTES.',
-  '        \xB7 Quadrant labels MUST be in DOUBLE QUOTES (`quadrant-1 "\u77ED\u8BED"`) \u2014 never bare text. The lexer rejects unquoted CJK / parens / `+`.',
-  '        \xB7 Each item line is `"Label": [x, y]` with the label in DOUBLE QUOTES. Inside the label: no `:` no `"` no `[` no `]`. Replace with ` - ` if needed.',
-  "        \xB7 Use HALFWIDTH parens `()` not fullwidth `\uFF08\uFF09` anywhere inside the diagram.",
-  "        \xB7 Numeric coords are decimals strictly inside `(0, 1)` \u2014 round to 2 decimals. Never use 0 or 1 exactly.",
-  "        \xB7 Title is one line, plain text \u2014 no quotes, no colons. Title is the only label that is NOT quoted.",
-  "        \xB7 One item per indented line. No blank lines inside the fenced block.",
+  "      Hard rules:",
+  "        \xB7 Strict JSON. No trailing commas, no comments.",
+  "        \xB7 `x` and `y` are decimals strictly inside `(0, 1)` \u2014 2 decimals max. Never use 0 or 1 exactly (points clip on the frame).",
+  "        \xB7 `q1`\u2013`q4` are short quadrant labels (\u2264 24 chars). `q1` is the preferred / focal quadrant by convention \u2014 pick names accordingly.",
+  "        \xB7 `focal` is OPTIONAL. When set, that item renders solid accent + larger radius \u2014 concentrates attention on the load-bearing position. Only one focal per chart.",
+  "        \xB7 `tier` (optional, 1\u20134) downranks an item's visual weight: 1 = standard, 2 = near-focal (accent outline), 3 = standard, 4 = faint (muted outline). Use sparingly to push uninteresting positions to the background.",
+  "        \xB7 2\u201316 items. Item labels \u2264 24 chars; avoid colons / brackets.",
+  "        \xB7 NO blank lines inside the fenced block.",
   "",
   "    For `force-field`:",
   "      ### {title}",
@@ -9205,62 +9655,88 @@ var WRITE_SYSTEM = [
   "",
   "    For `bar-chart`:",
   "      ### {title}",
-  "      Render a fenced ```mermaid block with `xychart-beta` (mermaid 10+ stable). Strict shape so the lexer doesn't reject:",
+  "      Render a fenced ```kami-chart block \xB7 strict JSON. The renderer turns it into an inline SVG bar chart styled by the active spine palette:",
   "      ```",
-  "      xychart-beta",
-  '          title "{title}"',
-  '          x-axis ["{bar.label}", "{bar.label}", ...]',
-  '          y-axis "{yLabel}"',
-  "          bar [{bar.value}, {bar.value}, ...]",
+  "      {",
+  '        "type": "bar-chart",',
+  '        "title": "{scaffold.title}",',
+  '        "yLabel": "{scaffold.yLabel}",',
+  '        "unit": "{scaffold.unit}",',
+  '        "focal": "{label of the one bar that carries the argument \xB7 optional}",',
+  '        "bars": [',
+  '          { "label": "{bar.label}", "value": {bar.value} },',
+  '          { "label": "{bar.label}", "value": {bar.value} }',
+  "        ],",
+  '        "caption": "{One-sentence editorial gloss \xB7 what the chart says, not what it plots. Use *italic markers* (e.g. *2\xD7 faster*) for the operative phrase.}"',
+  "      }",
   "      ```",
   "      Hard rules:",
-  "        \xB7 `x-axis` is a literal JSON-style array of DOUBLE-QUOTED labels, comma-separated. No bare strings. CJK is fine inside the quotes.",
-  "        \xB7 Inside any quoted label: NO double-quote, NO `:`, NO `[`, NO `]`. Replace with ` - ` if needed.",
-  "        \xB7 `bar` values are bare numbers, in the same order as x-axis labels. Match counts (lexer fails on mismatch).",
-  "        \xB7 `title` is double-quoted. ASCII parens only \u2014 replace fullwidth `\uFF08\uFF09` with halfwidth `()`.",
+  "        \xB7 Strict JSON (double-quoted keys + string values, no trailing commas, no comments). The renderer parses and falls back to an error placeholder if JSON is malformed.",
   "        \xB7 2\u20138 bars. Below 2 isn't a comparison; above 8 stops being scannable.",
-  "        \xB7 NO blank lines inside the fenced block. Indent body lines 4 spaces.",
+  "        \xB7 `value` is a bare number (no quotes, no unit suffix). Y-axis auto-scales to the next nice round number.",
+  '        \xB7 `unit` (e.g. "w", "%", "$M") is appended to the data label above each bar \u2014 keep it short (\u2264 4 chars).',
+  "        \xB7 `focal` is optional. When set, that bar renders in the spine accent and the others in neutral ink-mid \u2014 concentrates attention on the bar that carries the argument. When omitted, every bar gets the accent.",
+  "        \xB7 `caption` is rendered in serif italic below the chart. Wrap the operative phrase in `*\u2026*` so the renderer can italicise it in the spine accent.",
+  "        \xB7 Labels \u2264 24 chars; the renderer truncates to 18 at draw time. Avoid colons / brackets in labels (cosmetic, not strict).",
+  "        \xB7 NO blank lines inside the fenced block.",
   "",
   "    For `timeline`:",
   "      ### {title}",
-  "      Render a fenced ```mermaid block with `timeline`. Strict shape:",
+  "      Render a fenced ```kami-chart block \xB7 strict JSON. Horizontal time-axis chart where events alternate above / below the axis; the `focal` event renders in the spine accent. Schema:",
   "      ```",
-  "      timeline",
-  "          title {title}",
-  "          {period} : {label} : {description}",
+  "      {",
+  '        "type": "timeline",',
+  '        "title": "{scaffold.title}",',
+  '        "focal": "{period string of the load-bearing milestone \xB7 optional}",',
+  '        "points": [',
+  '          { "period": "2019", "label": "First open weights ship", "description": "" },',
+  '          { "period": "2022", "label": "Parity claim", "description": "Optional one-clause expansion" }',
+  "        ],",
+  '        "caption": "{Editorial gloss \xB7 what the arc says, with *italic* on the turn.}"',
+  "      }",
   "      ```",
   "      Hard rules:",
-  "        \xB7 `title` is plain text on its own line \u2014 NO quotes (mermaid timeline syntax differs from xychart). One line. ASCII parens only. NO `:` inside the title.",
-  "        \xB7 One point per line: `{period} : {label} : {description}` \u2014 colons are the field separators, so labels / descriptions cannot contain `:`. Replace with ` \u2014 ` if needed.",
-  '        \xB7 Period (e.g. "2019", "Q3 2024", "Today") is the column header rendered above the dot.',
-  "        \xB7 Description is optional \xB7 when scaffold.description is empty, use the 2-segment form: `{period} : {label}` (no trailing colon, no empty third segment \u2014 mermaid 11.0+ rejects empty fields).",
-  "        \xB7 3\u20138 points. Below 3 reads as a stub; above 8 the strip overflows.",
-  "        \xB7 NO blank lines inside the fenced block. Indent body lines 4 spaces.",
+  "        \xB7 Strict JSON. 3\u20138 points. Below 3 is a stub; above 8 overflows the strip.",
+  '        \xB7 `period` is the column header (mono): "2019", "Q3 2024", "Today", "+12 mo". \u2264 16 chars.',
+  "        \xB7 `label` is the headline event (sans): \u2264 60 chars. Concrete; avoid corporate verbs.",
+  "        \xB7 `description` is optional (\u2264 40 chars after rendering \u2014 gets truncated). Empty string is fine.",
+  "        \xB7 `focal` matches the `period` string of the load-bearing event. The matched event renders in accent: filled dot, solid connector, accent-bordered card. Only one focal.",
+  "        \xB7 NO blank lines inside the fenced block.",
   "",
   "    For `pie-chart`:",
   "      ### {title}",
-  "      Render a fenced ```mermaid block with `pie showData` so each slice's number is printed in the legend:",
+  "      Render a fenced ```kami-chart block \xB7 strict JSON. Renders as a DONUT (hollow centre with the largest slice's value + label inside). The largest slice carries the spine accent; smaller slices cascade down the neutral ramp. Schema:",
   "      ```",
-  "      pie showData",
-  "          title {title}",
-  '          "{slice.label}" : {slice.value}',
-  '          "{slice.label}" : {slice.value}',
+  "      {",
+  '        "type": "donut",',
+  '        "title": "{scaffold.title}",',
+  `        "centerLabel": "{optional \xB7 short text under the centre value \xB7 falls back to the largest slice's label}",`,
+  '        "slices": [',
+  '          { "label": "Base case", "value": 55 },',
+  '          { "label": "Upside",   "value": 25 },',
+  '          { "label": "Downside", "value": 20 }',
+  "        ],",
+  '        "caption": "{Editorial gloss with *italic* on the operative phrase.}"',
+  "      }",
   "      ```",
   "      Hard rules:",
-  "        \xB7 `title` is plain text \u2014 NO quotes. ASCII parens only. NO `:` inside the title.",
-  '        \xB7 Each slice is `"{label}" : {number}` \u2014 label DOUBLE-QUOTED, value bare number. The literal colon between them is required.',
-  '        \xB7 Labels: NO `"`, NO `:`, NO `[`, NO `]` inside. Replace with ` - ` if needed.',
-  "        \xB7 Values can be percentages summing to ~100 OR raw counts \u2014 mermaid normalises. Keep 2 decimals max.",
-  "        \xB7 2\u20136 slices. Pies with > 6 slices stop being readable.",
+  "        \xB7 `type` MUST be `donut` (the old `pie-chart` is renamed at render time).",
+  "        \xB7 Strict JSON. 2\u20136 slices. Above 6 the chart stops being readable.",
+  "        \xB7 `value` is a bare number \u2014 percentages summing to ~100 OR raw counts. The renderer normalises and prints percentages in the legend.",
+  "        \xB7 The renderer SORTS slices largest-first, so the visual order may differ from the JSON order. Don't try to control colours by ordering \u2014 the accent always lands on the largest slice.",
+  "        \xB7 `centerLabel` is OPTIONAL \u2014 defaults to the largest slice's label (uppercased). Set it when the slice label is long or wants a different framing inside the donut.",
+  "        \xB7 Slice labels \u2264 24 chars. NO blank lines inside the fenced block.",
   "        \xB7 NO blank lines inside the fenced block. Indent body lines 4 spaces.",
   "",
-  "## Inline mermaid \xB7 additional chart types",
+  "## Inline charts \xB7 additional chart types beyond the typed visuals",
+  "",
+  "Beyond the typed visuals (`comparison-table` / `quadrant-chart` / `force-field` / `strengths-cautions` / `bar-chart` / `timeline` / `pie-chart`), the writer drops fenced chart blocks inline within body sections to surface logic, sequence, hierarchy, or state that prose can't carry as efficiently. Each must visualise something prose can't.",
   "",
-  "Beyond the typed visuals (`comparison-table` / `quadrant-chart` / `force-field` / `strengths-cautions` / `bar-chart` / `timeline` / `pie-chart`), the writer drops fenced ```mermaid blocks inline within body sections to surface logic, sequence, hierarchy, or state that prose can't carry as efficiently. Each must visualise something prose can't.",
+  "All inline charts render through the `kami-chart` pipeline \xB7 strict JSON inside a ```kami-chart fence, spine-tokenised inline SVG, no JS runtime. The catalogue below covers every inline chart type \u2014 `flowchart` / `mindmap`\u2192`tree` / `gantt` / `sequenceDiagram`\u2192`swimlane` / `journey`\u2192`swimlane` / `stateDiagram-v2`\u2192`state-machine`.",
   "",
-  "**Mermaid bias \xB7 prefer mermaid where it fits naturally \u2014 no fixed quota.** Two sources count:",
-  "  \xB7 Typed visuals where the sub-type is mermaid (`quadrant-chart` / `bar-chart` / `timeline` / `pie-chart`).",
-  "  \xB7 Inline mermaid blocks from the catalogue below (`flowchart` / `mindmap` / `gantt` / `sequenceDiagram` / `journey` / `stateDiagram-v2`).",
+  "**Chart bias \xB7 prefer charts where they fit naturally \u2014 no fixed quota.** Two sources count:",
+  "  \xB7 Typed visuals where the sub-type is a chart (`quadrant-chart` / `bar-chart` / `timeline` / `pie-chart`).",
+  "  \xB7 Inline chart blocks from the catalogue below (`flowchart` / `mindmap` / `gantt` / `sequenceDiagram` / `journey` / `stateDiagram-v2`).",
   "Quality over quantity. Emit a chart whenever the section's content has structure prose can't carry efficiently. Skip when the prose alone is clear \u2014 a forced chart is worse than no chart. There is NO minimum count; a substantive strategy brief might naturally land at 4\u20136 charts, a tight philosophical brief at 0\u20131, both are correct.",
   "",
   "**The default lean is YES** when a section's content matches one of these shapes: branching logic, sequenced events, multi-party interactions, hierarchical structure, state transitions, 2-axis comparisons, distributions, before/after framings. The cost of an extra chart is small; the cost of a wall of text is a reader who skips. But don't manufacture structure that isn't in the material \u2014 chart only what the room actually produced.",
@@ -9283,12 +9759,12 @@ var WRITE_SYSTEM = [
   "  \xB7 `Options Analysis` / `Decision Options` \u2192 \u25C7 ONLY when there are \u2265 4 options OR each option branches into 2+ sub-considerations (5+ nodes total with branching). With 2-3 options, the typed table / decision-options block carries it \u2014 no chart.",
   "  \xB7 `Two Paths` \u2192 \u25C7 rarely; two parallel trajectories joined at a hinge is exactly the trivial case. Render the typed table only.",
   "  \xB7 `Strategic Outlook` \u2192 \u25C7 `mindmap` ONLY when the room named \u2265 4 distinct forces with internal sub-structure (4 branches \xD7 \u2265 2 children).",
-  "  \xB7 `Critical Assumptions` \u2192 \u25C7 `flowchart TD` ONLY when assumptions form a multi-step dependency chain WITH branching (assumption A holds \u2192 either B or C \u2192 recommendation D), 5+ nodes. Linear 3-step dependency = prose.",
-  "  \xB7 `Scenario Tree` \u2192 \u2713 `flowchart TD` when there are \u2265 3 scenarios EACH with named effects/triggers as sub-nodes (root + 3 scenarios + 3-6 effect children = 7-10 nodes). Below that, the typed table is enough.",
-  "  \xB7 `Threats to Validity` \u2192 \u25C7 `flowchart TD` ONLY when threats compound (sample bias \u2192 selection bias \u2192 generalizability ceiling) with branching, 5+ nodes.",
+  "  \xB7 `Critical Assumptions` \u2192 \u25C7 `flowchart` ONLY when assumptions form a multi-step dependency chain WITH branching (assumption A holds \u2192 either B or C \u2192 recommendation D), 5+ nodes. Linear 3-step dependency = prose.",
+  "  \xB7 `Scenario Tree` \u2192 \u2713 `flowchart` when there are \u2265 3 scenarios EACH with named effects/triggers as sub-nodes (root + 3 scenarios + 3-6 effect children = 7-10 nodes). Below that, the typed table is enough.",
+  "  \xB7 `Threats to Validity` \u2192 \u25C7 `flowchart` ONLY when threats compound (sample bias \u2192 selection bias \u2192 generalizability ceiling) with branching, 5+ nodes.",
   "  \xB7 `Recommendations` \u2192 \u2713 `gantt` for multi-phase rollouts (\u2265 2 sections AND \u2265 4 tasks). For sequenced action chains under 4 tasks, use prose / numbered list \u2014 NOT a linear flowchart.",
   "  \xB7 `Leading Indicators` \u2192 \u25C7 `stateDiagram-v2` when indicators map to \u2265 4 scenario states with at least one feedback loop / back-transition.",
-  "  \xB7 `Risk Register` \u2192 \u2713 `flowchart TD` when there are \u2265 5 risks AND multiple risks share a category cluster (root \u2192 category nodes \u2192 individual risks as leaves = \u2265 10 nodes). The typed risk table is enough on its own when the register is < 5 entries.",
+  "  \xB7 `Risk Register` \u2192 \u2713 `flowchart` when there are \u2265 5 risks AND multiple risks share a category cluster (root \u2192 category nodes \u2192 individual risks as leaves = \u2265 10 nodes). The typed risk table is enough on its own when the register is < 5 entries.",
   "  \xB7 `Risk Register` \u2192 \u2713 `quadrantChart` of severity \xD7 likelihood (always \u2014 the quadrant chart is a 2-axis plot, not subject to the flowchart-complexity floor).",
   "  \xB7 `New Questions This Surfaced` \u2192 \u25C7 `mindmap` when there are \u2265 4 new questions clustering into \u2265 3 themes.",
   "  \xB7 `Strategic Planning Assumption` \u2192 \u25C7 rarely.",
@@ -9299,130 +9775,178 @@ var WRITE_SYSTEM = [
   "**Routing constraints** (avoid double-rendering the same content):",
   "  \xB7 Risk Register flowchart + Risk Register table = \u2713 both, complementary.",
   "  \xB7 Risk Register quadrantChart + Risk Register table = \u2713 both, complementary.",
-  "  \xB7 A single section gets at MOST one inline mermaid (plus the typed visual if any). Never stack 2+ inline charts in one section.",
+  "  \xB7 A single section gets at MOST one inline chart (plus the typed visual if any). Never stack 2+ inline charts in one section.",
   "  \xB7 A `gantt` and a `flowchart` covering the SAME recommendation rollout = pick one (gantt if dates matter, flowchart if branching matters).",
   "  \xB7 If a typed `visuals` block already covers a content shape (e.g. `bar-chart` for ranked options), don't add an inline `flowchart` for the same options.",
   "",
   "  ### flowchart \xB7 decision tree / process branches",
-  '  Use when a section argues a decision sequence ("if X then Y else Z") or a process where order + branching matters. Natural fits: risk-register branches ("if risk A materialises, do P; else monitor"), the divergence section when there are 3+ positions, scenario trees with named effects.',
+  '  Use when a section argues a decision sequence ("if X then Y else Z") or a short process where order matters. Render as a fenced ```kami-chart JSON with one of two LAYOUTS \u2014 the renderer owns positioning. Schemas:',
+  "    Linear chain \xB7 2\u20135 nodes top-to-bottom:",
   "    ```",
-  "    flowchart TD",
-  "        A[Starting state] --> B{Decision point}",
-  "        B -->|condition true| C[Branch A]",
-  "        B -->|condition false| D[Branch B]",
-  "        C --> E[Outcome]",
-  "        D --> E",
+  "    {",
+  '      "type": "flowchart",',
+  '      "layout": "linear-v",',
+  '      "focal": "{optional \xB7 label of the load-bearing node}",',
+  '      "nodes": [',
+  '        { "label": "Start",          "kind": "start" },',
+  '        { "label": "Validate input", "kind": "step",  "hint": "" },',
+  '        { "label": "Persist write",  "kind": "step",  "hint": "" },',
+  '        { "label": "Done",           "kind": "end"   }',
+  "      ],",
+  '      "caption": "{One-sentence editorial gloss with *italic* on the operative phrase.}"',
+  "    }",
+  "    ```",
+  "    Y-decision \xB7 root (decision) \u2192 2 branches \u2192 optional join:",
+  "    ```",
+  "    {",
+  '      "type": "flowchart",',
+  '      "layout": "y-decision",',
+  '      "focal": "{optional \xB7 label of the load-bearing node \u2014 usually the decision or the preferred branch}",',
+  '      "nodes": [',
+  '        { "label": "Pilot beats threshold?", "kind": "decision" },',
+  '        { "label": "Scale rollout",   "kind": "outcome", "hint": "yes" },',
+  '        { "label": "Iterate pilot",   "kind": "outcome", "hint": "no" },',
+  '        { "label": "Decision recorded", "kind": "end" }',
+  "      ],",
+  '      "caption": "{Editorial gloss.}"',
+  "    }",
   "    ```",
   "  Hard rules:",
-  '    \xB7 **Complexity floor \xB7 \u2265 5 nodes AND \u2265 1 branch** (a node with 2+ outgoing edges, OR a `{diamond}` decision with branching paths). Pure linear `A \u2192 B \u2192 C` flowcharts are FORBIDDEN \u2014 those read as naive ("\u5E7C\u9F7F") and must render as prose / a numbered list instead. If your candidate flowchart has 3-4 nodes OR no branching, **drop the chart and use prose**. A missing chart is fine; a trivial one is worse than nothing.',
-  "    \xB7 Direction is `TD` (top-down) or `LR` (left-right) ONLY. `TD` is the default for decision trees, `LR` for process sequences.",
-  "    \xB7 Node labels: square brackets `[label]` for boxes, curly `{label}` for diamonds (decisions), round `(label)` for terminal states. Keep labels \u2264 6 words.",
-  "    \xB7 Edge labels (`-->|text|`) are quoted only if they contain spaces \u2014 short text without spaces can be unquoted.",
-  '    \xB7 NO `:`, NO `(`, NO `)`, NO `"` inside node labels. ASCII parens only \u2014 never fullwidth.',
-  "    \xB7 Maximum 8 nodes per chart. Above 8 stops being scannable; split into multiple charts.",
-  "    \xB7 NO blank lines inside the fenced block. Indent body lines 4 spaces.",
-  "",
-  "  ### mindmap \xB7 hierarchical idea tree",
-  "  Use when a section needs to surface the *shape* of the room's thinking \u2014 typically in brainstorm-mode rooms (`adjacent-angles`, `worth-chasing`) where the directors generated multiple branches off a central premise. Avoid in decision-grade briefs where the structure is already linear (anchor \u2192 findings \u2192 action).",
+  '    \xB7 `layout` MUST be `linear-v` or `y-decision`. Pick `linear-v` for a sequence ("A leads to B leads to C"). Pick `y-decision` whenever a decision branches into 2 outcomes.',
+  '    \xB7 `kind` values: `start` (pill, paper-soft) \xB7 `step` (square, ink border) \xB7 `decision` (diamond, accent border) \xB7 `outcome` (square, faint border \u2014 "deferred branch" reads as receded) \xB7 `end` (pill, paper-soft).',
+  "    \xB7 `hint` is rendered as a short uppercase mono caption inside the node (for steps / outcomes) OR as the edge label (for y-decision branches \u2014 write `yes` / `no` / `<6 chars`).",
+  "    \xB7 For `y-decision`: nodes in canonical order \u2014 [0] root, [1] left branch, [2] right branch, [3] optional join.",
+  "    \xB7 For `linear-v`: max 5 nodes. For `y-decision`: 3\u20134 nodes.",
+  "    \xB7 Labels \u2264 18 chars (renderer truncates). Avoid colons / brackets in labels.",
+  "    \xB7 `focal` matches a node's `label` exactly; that node renders in the spine accent.",
+  "    \xB7 **Complexity floor stays**: only emit a flowchart when prose can't carry the structure \u2014 a 2-node linear-v is exactly the trivial case banned above.",
+  "",
+  "  ### mindmap \xB7 hierarchical idea tree (renders as `tree`)",
+  '  Use when a section needs to surface the *shape* of the room\'s thinking \u2014 typically in brainstorm-mode rooms (`adjacent-angles`, `worth-chasing`). Render as a fenced ```kami-chart with `type: "tree"`. The renderer draws 1 root + N branches (with right-angle connectors and chevron arrows at child tops), and optional leaves under each branch:',
   "    ```",
-  "    mindmap",
-  "        root((Central question))",
-  "            Branch A",
-  "                Sub-thread A1",
-  "                Sub-thread A2",
-  "            Branch B",
-  "                Sub-thread B1",
+  "    {",
+  '      "type": "tree",',
+  '      "root": "Central premise",',
+  '      "focal": "{optional \xB7 branch label that carries the argument}",',
+  '      "branches": [',
+  '        { "label": "Branch A", "leaves": ["Sub A1", "Sub A2"] },',
+  '        { "label": "Branch B", "leaves": ["Sub B1", "Sub B2", "Sub B3"] },',
+  '        { "label": "Branch C", "leaves": [] }',
+  "      ],",
+  '      "caption": "{Editorial gloss with *italic* on the operative phrase.}"',
+  "    }",
   "    ```",
   "  Hard rules:",
-  "    \xB7 **Complexity floor \xB7 \u2265 4 top-level branches OR \u2265 3 branches with \u2265 2 children each (= 9+ leaf nodes total)**. A 2-3 branch mindmap is just a bullet list with extra steps and reads as naive \u2014 drop it and use a markdown bullet list instead.",
-  "    \xB7 Root node uses `root((label))` \u2014 double parens for the cloud shape. ASCII parens only.",
-  "    \xB7 Indentation IS the hierarchy \u2014 children indent 4 spaces under their parent.",
-  '    \xB7 Node text is plain \u2014 NO `:`, NO `"`, NO brackets, NO leading `-` / `*`. Just the text.',
-  "    \xB7 4\u20136 top-level branches (after the floor). Each branch 2\u20134 children. Above that the diagram unreads.",
-  "    \xB7 NO blank lines inside the fenced block.",
+  "    \xB7 `type` MUST be `tree` (the old `mindmap` is renamed at render time).",
+  "    \xB7 2\u20136 branches. Each branch can have 0\u20134 leaves (no leaves is fine \u2014 the renderer just shows the branch tier).",
+  "    \xB7 `root` \u2264 22 chars, branch labels \u2264 18 chars, leaf labels \u2264 16 chars. The renderer truncates.",
+  "    \xB7 `focal` matches a branch label; that branch + its leaves render in the spine accent.",
+  "    \xB7 **Complexity floor stays**: 2-branch tree with no leaves = naive. The renderer enforces a minimum of 2 branches but the floor in the trigger map applies: \u2265 4 top-level branches OR \u2265 3 branches \xD7 \u2265 2 children each.",
   "",
   "  ### gantt \xB7 execution timeline with dependencies",
-  "  Use when a section names a multi-phase rollout or campaign with time-bound activities and dependencies \u2014 typically inside Recommendations or a follow-up Strategic Outlook. Skip when the recommendations are atomic / not phased.",
+  '  Use when a section names a multi-phase rollout with time-bound activities \u2014 typically inside Recommendations. Render as a fenced ```kami-chart with `type: "gantt"`. The renderer draws bars on a shared horizontal time axis, grouped by section:',
   "    ```",
-  "    gantt",
-  "        title Rollout phasing",
-  "        dateFormat YYYY-MM",
-  "        section Foundations",
-  "        Discovery        :a1, 2026-04, 2M",
-  "        Pilot scope      :a2, after a1, 1M",
-  "        section Build",
-  "        Vertical 1       :b1, after a2, 3M",
-  "        Vertical 2       :b2, after b1, 3M",
+  "    {",
+  '      "type": "gantt",',
+  '      "title": "Rollout phasing \xB7 12 months",',
+  '      "unit": "mo",',
+  '      "focal": "{optional \xB7 phase label that carries the most cost / time}",',
+  '      "phases": [',
+  '        { "section": "Foundations", "label": "Discovery",   "start": 0, "end": 2 },',
+  '        { "section": "Foundations", "label": "Pilot scope", "start": 2, "end": 3 },',
+  '        { "section": "Build",       "label": "Vertical 1",  "start": 3, "end": 6 },',
+  '        { "section": "Build",       "label": "Vertical 2",  "start": 6, "end": 9 },',
+  '        { "section": "Launch",      "label": "GA",           "start": 9, "end": 12 }',
+  "      ],",
+  '      "caption": "{Editorial gloss \xB7 what the schedule says, with *italic* on the operative phrase.}"',
+  "    }",
   "    ```",
   "  Hard rules:",
-  "    \xB7 **Complexity floor \xB7 \u2265 2 sections AND \u2265 4 tasks total**. A single-section gantt with 2-3 tasks is a bullet list with bars; drop it and render as numbered prose.",
-  "    \xB7 `title` plain text \u2014 NO quotes, NO `:` inside.",
-  "    \xB7 `dateFormat` is `YYYY-MM` (months) or `YYYY-MM-DD` (days). Pick one and stick to it.",
-  "    \xB7 Each task line: `Label :id, start, duration` \u2014 `start` is either an absolute date matching dateFormat OR `after {otherId}`. Duration is `Nd` / `Nw` / `Nm` (days/weeks/months).",
-  "    \xB7 Section headers (`section Name`) group tasks. 2\u20134 sections, 2\u20136 tasks per section.",
-  '    \xB7 Task labels: NO `:`, NO `"`, NO commas, NO brackets. Replace with ` - ` if needed.',
-  "    \xB7 NO blank lines inside the fenced block.",
-  "",
-  "  ### sequenceDiagram \xB7 actor interactions over time",
-  "  Use when a section describes a multi-party negotiation, a system-call sequence, or a step-by-step protocol where the *order of who-talks-to-whom* matters. Best fit: technical workflow rooms, governance / approval-chain briefs.",
+  "    \xB7 `start` and `end` are bare numbers in the same unit (months / weeks / days \u2014 your choice). The renderer auto-scales the time axis from 0 to a nice-round max.",
+  "    \xB7 `unit` (e.g. `mo`, `w`, `d`) is a short suffix on the axis ticks and bar durations.",
+  "    \xB7 `section` is optional but recommended \u2014 phases with the same section are grouped under a section label on the left.",
+  "    \xB7 `focal` matches a phase label exactly; that bar renders in the spine accent.",
+  "    \xB7 2\u201310 phases. **Complexity floor stays**: a 2-phase gantt is a bullet list with bars; only emit when \u2265 4 tasks total AND \u2265 2 sections.",
+  "    \xB7 Phase labels \u2264 24 chars (renderer truncates). Avoid colons / brackets.",
+  "",
+  "  ### sequenceDiagram \xB7 actor interactions over time (renders as `swimlane`)",
+  '  Use when a section describes a multi-party negotiation, a system-call sequence, or a step-by-step protocol where the *order of who-talks-to-whom* matters. Render as a fenced ```kami-chart with `type: "swimlane"`. The renderer draws N lanes stacked vertically; steps go in their assigned lane in left-to-right order; elbow connectors with chevron arrowheads link consecutive steps. Schema:',
   "    ```",
-  "    sequenceDiagram",
-  "        participant U as User",
-  "        participant S as Service",
-  "        participant A as Auth",
-  "        U->>S: Request resource",
-  "        S->>A: Validate token",
-  "        A-->>S: Token valid",
-  "        S-->>U: Resource",
+  "    {",
+  '      "type": "swimlane",',
+  '      "title": "Request \u2192 response sequence",',
+  '      "lanes": ["Client", "Server", "Database"],',
+  '      "focalLane": "{optional \xB7 lane name to tint as the focal row}",',
+  '      "focal": "{optional \xB7 step label to render in accent}",',
+  '      "steps": [',
+  '        { "label": "Request",  "laneIdx": 0, "kicker": "USER" },',
+  '        { "label": "Validate", "laneIdx": 1, "kicker": "AUTH" },',
+  '        { "label": "Query",    "laneIdx": 2, "kicker": "STORE" },',
+  '        { "label": "Respond",  "laneIdx": 0, "kicker": "USER" }',
+  "      ],",
+  '      "caption": "{Editorial gloss with *italic* on the operative phrase.}"',
+  "    }",
   "    ```",
   "  Hard rules:",
-  "    \xB7 **Complexity floor \xB7 \u2265 2 participants AND \u2265 4 message lines**. A 3-message diagram between 2 actors is just a bullet list with arrow glyphs \u2014 drop it and render as prose.",
-  "    \xB7 `participant {alias} as {Display Name}` \u2014 short ASCII alias on the left, display name on the right. Use the alias in the message lines.",
-  "    \xB7 Message arrows: `->>` for solid (request), `-->>` for dashed (response). NEVER use plain `->` (renders as a bare line).",
-  '    \xB7 Message text after the colon: NO `:`, NO `"` \u2014 bare text. \u2264 6 words per line.',
-  "    \xB7 2\u20134 participants, 4\u20138 message lines. Above that the diagram becomes a wall.",
-  "    \xB7 NO blank lines inside the fenced block. Indent body lines 4 spaces.",
-  "",
-  "  ### journey \xB7 user / stakeholder journey scoring",
-  `  Use when a section maps how a stakeholder experiences a process \u2014 best for product / UX rooms scoring touchpoints, or for adoption-friction analysis ("the buyer's journey from awareness to renewal"). Each step gets a 1\u20135 score for satisfaction.`,
+  "    \xB7 `type` MUST be `swimlane` (sequence diagrams are rendered through the unified swimlane pipeline).",
+  "    \xB7 **Complexity floor \xB7 \u2265 2 lanes AND \u2265 4 steps**. A 3-step sequence is just a bullet list with arrow glyphs \u2014 drop it and use prose.",
+  "    \xB7 2\u20134 lanes; 3\u201310 steps total.",
+  "    \xB7 `laneIdx` is the 0-based index into the `lanes` array. The renderer routes elbow connectors when consecutive steps cross lanes.",
+  "    \xB7 `kicker` (optional) is a short mono caption inside the step box (the role or call type). Defaults to `STEP NN` when omitted.",
+  "    \xB7 `focal` matches a step label exactly \xB7 accent border + accent kicker. `focalLane` tints the lane background.",
+  "    \xB7 Labels \u2264 18 chars (renderer truncates).",
+  "",
+  "  ### journey \xB7 user / stakeholder journey scoring (renders as `swimlane`)",
+  '  Use when a section maps how a stakeholder experiences a process \u2014 best for product / UX rooms scoring touchpoints, or adoption-friction analysis ("the buyer\'s journey from awareness to renewal"). Render through the SAME `swimlane` schema, with an added `score` (1\u20135) per step. The renderer draws 5 small dots under each scored step, filled up to the score. Schema (only differences from sequenceDiagram):',
   "    ```",
-  "    journey",
-  "        title Stakeholder adoption journey",
-  "        section Awareness",
-  "            Hear about it: 3: Buyer",
-  "            Read landing page: 4: Buyer",
-  "        section Trial",
-  "            Sign up: 2: Buyer",
-  "            First task: 1: Buyer, IT",
-  "        section Adopt",
-  "            Approve rollout: 4: Buyer, Legal",
+  "    {",
+  '      "type": "swimlane",',
+  '      "lanes": ["Awareness", "Trial", "Adopt"],',
+  '      "steps": [',
+  '        { "label": "Hear about it",  "laneIdx": 0, "kicker": "BUYER", "score": 3 },',
+  '        { "label": "Read landing",   "laneIdx": 0, "kicker": "BUYER", "score": 4 },',
+  '        { "label": "Sign up",         "laneIdx": 1, "kicker": "BUYER", "score": 2 },',
+  '        { "label": "First task",      "laneIdx": 1, "kicker": "BUYER \xB7 IT", "score": 1 },',
+  '        { "label": "Approve",         "laneIdx": 2, "kicker": "LEGAL", "score": 4 }',
+  "      ],",
+  '      "caption": "{Editorial gloss with *italic* on the worst moment.}"',
+  "    }",
   "    ```",
-  "  Hard rules:",
-  "    \xB7 `title` plain text \u2014 NO quotes.",
-  "    \xB7 Each step: `Step text: score: Actor[, Actor2]` \u2014 score is 1\u20135 (5 = best). Actors comma-separated.",
-  '    \xB7 Step text: NO `:`, NO `"`. \u2264 6 words.',
-  "    \xB7 2\u20134 sections, 2\u20134 steps per section.",
-  "    \xB7 NO blank lines inside the fenced block. Indent body lines 4 spaces.",
-  "",
-  "  ### stateDiagram \xB7 lifecycle / phase transitions",
-  "  Use when a section names a process with discrete states the subject moves between (deal lifecycle, customer onboarding, product evolution, regulatory approval phases, scenario branching with feedback loops). Reads cleaner than a flowchart when the *states themselves* are the load-bearing concept, not the conditions. Best fit: execution-plan rollouts with stage gates, market-evolution narratives, retro post-mortems where the system passed through phases.",
+  "  Hard rules (additional to swimlane):",
+  "    \xB7 `score` is OPTIONAL \xB7 1\u20135 (5 = best). Omit on steps where scoring doesn't apply. Mixing scored and unscored steps in one chart is fine.",
+  "    \xB7 `kicker` can list multiple actors with ` \xB7 ` separator (e.g. `BUYER \xB7 IT`).",
+  "    \xB7 For journey, set `focal` on the step with the *worst* score (the friction point that drives the argument). Counter-intuitive but correct \u2014 the editorial accent goes where the work is.",
+  "",
+  "  ### stateDiagram \xB7 lifecycle / phase transitions (renders as `state-machine`)",
+  '  Use when a section names a process with discrete states the subject moves between (deal lifecycle, customer onboarding, product evolution, regulatory approval phases). Render as a fenced ```kami-chart with `type: "state-machine"`. The renderer draws 2\u20136 states left-to-right with forward arrows between consecutive states; back-transitions render as dashed arcs above. Schema:',
   "    ```",
-  "    stateDiagram-v2",
-  "        [*] --> Discovery",
-  "        Discovery --> Pilot: Hypothesis validated",
-  "        Pilot --> Scale: Pilot win-rate >= 60%",
-  "        Pilot --> Iterate: Pilot below threshold",
-  "        Iterate --> Pilot",
-  "        Scale --> [*]",
+  "    {",
+  '      "type": "state-machine",',
+  '      "title": "Deal lifecycle",',
+  '      "showStart": true,',
+  '      "showEnd": true,',
+  '      "focal": "{optional \xB7 state label rendered in accent}",',
+  '      "states": [',
+  '        { "label": "Discovery",  "hint": "opportunity" },',
+  '        { "label": "Pilot",      "hint": "hypothesis" },',
+  '        { "label": "Scale",      "hint": "rolling out" },',
+  '        { "label": "Closed",     "hint": "resolved", "terminal": true }',
+  "      ],",
+  '      "forwardLabels": ["validated", "win-rate \u2265 60%", "complete"],',
+  '      "backTransitions": [',
+  '        { "fromIdx": 1, "toIdx": 0, "label": "reset" }',
+  "      ],",
+  '      "caption": "{Editorial gloss with *italic* on the cycle.}"',
+  "    }",
   "    ```",
   "  Hard rules:",
-  "    \xB7 **Complexity floor \xB7 \u2265 4 states AND at least one cycle / back-transition** (a state that loops back, OR a state that branches into 2+ next states). A pure linear `Discovery \u2192 Pilot \u2192 Scale` chain is a flowchart waiting to happen \u2014 drop it and use prose. The thing that justifies a stateDiagram (vs a flowchart or prose) is the back-transition / cycle.",
-  "    \xB7 First line is `stateDiagram-v2` (the v2 dialect \u2014 older `stateDiagram` syntax has lexer quirks). Indent body lines 4 spaces.",
-  "    \xB7 `[*]` is the start / end pseudo-state. Use `[*] --> First` for entry and `Last --> [*]` for exit. Both are optional.",
-  '    \xB7 Each transition: `From --> To` or `From --> To: condition label`. Condition label is plain text after `:` \u2014 NO `"`, NO additional `:`, NO `[` `]` inside.',
-  "    \xB7 State names: ASCII identifiers (alphanumerics + underscore), \u2264 20 chars, no spaces. Use camelCase or snake_case. The diagram caption can carry the human-readable label via composite states (skip if not needed).",
-  "    \xB7 4\u20137 states (after the floor). Below 4 isn't a lifecycle; above 7 stops being scannable.",
-  "    \xB7 NO blank lines inside the fenced block.",
+  "    \xB7 `type` MUST be `state-machine`.",
+  "    \xB7 **Complexity floor \xB7 \u2265 3 states AND at least one back-transition** (a `backTransitions` entry). A pure linear `Discovery \u2192 Pilot \u2192 Scale` chain has no cycle \u2014 render as `flowchart linear-v` instead. The thing that justifies a state-machine is the back-transition.",
+  "    \xB7 `states` array: 2\u20136 entries. Each has `label` (\u2264 16 chars), optional `hint` (\u2264 14 chars \xB7 mono caption inside the box), optional `terminal: true` (draws with darker ink border).",
+  "    \xB7 `forwardLabels` is an array indexed by the source state position \xB7 entry `i` labels the arrow from state `i` to state `i+1`. Empty / missing entries leave the arrow unlabeled.",
+  "    \xB7 `backTransitions`: each entry needs `fromIdx > toIdx` (back-arcs go right-to-left). The renderer draws a dashed Q-curve above the row.",
+  "    \xB7 `showStart: true` draws a solid black dot before the first state (the entry pseudo-state). `showEnd: true` draws a double-circle terminator after the last state.",
+  "    \xB7 `focal` matches a state label exactly \xB7 that state renders in the spine accent.",
   "",
   "  ## Recommendations",
   "  Skip if `recommendations` is empty. Otherwise render as a numbered list, one per recommendation, sorted by priority. Each item:",
@@ -9457,7 +9981,7 @@ var WRITE_SYSTEM = [
   '           "Channel concentration": [0.80, 0.80]',
   '           "Hiring bench thin": [0.50, 0.20]',
   "       ```",
-  "       Leave a BLANK LINE between the H2 heading and the fenced ```mermaid block.",
+  "       Leave a BLANK LINE between the H2 heading and the fenced ```kami-chart block.",
   "",
   "    2. **Risk table** \u2014 markdown table with columns `Risk | Category | Severity | Likelihood | Owner | Mitigation`. One row per `RiskItem`. Sort rows: severity high before medium before low; within the same severity, likelihood high before medium before low. Render category and severity / likelihood as **bold inline tags** (`**Market**`, `**High**`). Leave a BLANK LINE between the quadrant chart and the table header row \xB7 without that gap markdown parsers concatenate the prose with the table and pipe syntax leaks.",
   '       When `mitigation` is the literal string `"monitor only"`, render the cell as italic: `_monitor only_` so the reader sees this row as a watch-list rather than a closeable risk.',
@@ -9647,7 +10171,7 @@ var WRITE_SYSTEM = [
   "  ### metricStrip (dashboard \xB7 the room's numbers as a row of KPI cards)",
   "  When `scaffold.metricStrip` is non-null AND was picked, render it as the report's first quantitative beat \u2014 natural slot is RIGHT AFTER the anchor (Bottom Line / Thesis / Working Hypothesis), so a reader skimming the top of the report sees the headline judgement followed immediately by the numbers behind it. Acceptable alternative slot: right before Recommendations, when the numbers frame the action rather than the judgement.",
   "    Heading from the house style (default `## By the Numbers`).",
-  "    Then emit a fenced code block with language tag `metric-strip` whose body is STRICT JSON. The report renderer detects this block and emits the styled card grid (mirrors how ```mermaid is handled today). Format:",
+  "    Then emit a fenced code block with language tag `metric-strip` whose body is STRICT JSON. The report renderer detects this block and emits the styled card grid (mirrors how ```kami-chart is handled today). Format:",
   "    ```metric-strip",
   "    {",
   '      "intro": "Three numbers worth pricing in",',
@@ -9659,7 +10183,7 @@ var WRITE_SYSTEM = [
   "    }",
   "    ```",
   "    Hard rules:",
-  "      \xB7 The block opens with the literal three backticks + `metric-strip` and closes with three backticks on a line by itself. Just like mermaid blocks.",
+  "      \xB7 The block opens with the literal three backticks + `metric-strip` and closes with three backticks on a line by itself. Just like kami-chart blocks.",
   "      \xB7 Body is one JSON object with `intro` (string, may be empty) and `cards` (array of 3\u20135 objects).",
   '      \xB7 Each card object: `label` (required string), `value` (required string), `qualifier` (optional string \xB7 omit key OR set null when empty), `trend` (optional \xB7 one of `"up"` / `"down"` / `"flat"` \xB7 omit key when null), `attribution` (optional string).',
   "      \xB7 Mirror the scaffold.metricStrip values 1:1. Don't invent extra cards; don't drop cards the scaffold supplied.",
@@ -9746,7 +10270,7 @@ var WRITE_SYSTEM = [
   "\xB7 Use **bold** for claims and section markers.",
   '\xB7 No "I" or "we" as the writer. The brief is the room speaking.',
   '\xB7 No preamble, no closing remarks, no "in summary". Just the brief.',
-  "\xB7 Markdown only \u2014 fenced ```mermaid blocks are part of markdown for our renderer.",
+  "\xB7 Markdown only \u2014 fenced ```kami-chart blocks (and the other structured-fence languages like ```metric-strip / ```callout) are part of markdown for our renderer.",
   "\xB7 Replace all director ids (like `dirId-a`) with display names. Never let a raw id leak into prose.",
   '\xB7 Numbers everywhere \u2014 even qualitative claims get bracketed by numbers when possible ("about 2/3 of the directors", "in the next 18 months", "~30% confidence").',
   '\xB7 Section headings ARE the takeaway \u2014 never use topic-style headings (e.g. "Market analysis"). Always claim-style (e.g. "China growth will slow to <5%").'
@@ -11727,7 +12251,7 @@ var SYSTEM_PROMPT = [
   "  \xB7 `convergence`         Where directors aligned via independent reasoning paths. Needs \u2265 2 directors via \u2265 2 lenses.",
   "  \xB7 `divergence`          The single hinge where directors split. Skip when the room had no real central tension.",
   "  \xB7 `positions`           2\u20133 named camps with a pull-quote per camp. Skip when directors didn't cluster.",
-  "  \xB7 `visuals`             0\u20134 visual exhibits. Seven sub-types \u2014 **prefer mermaid (4) over text matrix (3)** unless the data shape genuinely doesn't fit. Mermaid renders as a real diagram in seconds; text matrices are dense and slow to absorb. Mermaid sub-types: `quadrant-chart` (2-axis plot \xB7 mermaid quadrantChart), `bar-chart` (ranked numeric \xB7 mermaid xychart-beta \xB7 2\u20138 items), `timeline` (dated narrative \xB7 mermaid timeline \xB7 3\u20138 beats), `pie-chart` (distribution \xB7 mermaid pie showData \xB7 2\u20136 slices). Text-matrix sub-types: `comparison-table` (N options \xD7 M criteria), `force-field` (drivers vs resistors), `strengths-cautions` (pros/cons/verdict per option). Triggers: ranked numeric \u2192 bar-chart \xB7 chronology / historical analogue / projected sequence \u2192 timeline \xB7 distribution that sums (probability split / vote tallies / shares / mix) \u2192 pie-chart \xB7 2-axis plot \u2192 quadrant-chart \xB7 N-options-with-mixed-cells \u2192 comparison-table \xB7 for/against forces \u2192 force-field \xB7 pros/cons/verdict matrix \u2192 strengths-cautions. **Beyond `visuals`, the writer ALSO emits inline mermaid (flowchart / mindmap / gantt / sequenceDiagram / stateDiagram / journey) inside body sections where prose can't carry the structure efficiently** \u2014 these are automatic and don't need to be picked here.",
+  "  \xB7 `visuals`             0\u20134 visual exhibits. Seven sub-types \u2014 **prefer the inline-SVG chart sub-types (4) over text matrix (3)** unless the data shape genuinely doesn't fit. SVG charts render as a real diagram in seconds; text matrices are dense and slow to absorb. Inline-SVG sub-types (rendered through the `kami-chart` pipeline, spine-tokenised): `quadrant-chart` (2-axis plot), `bar-chart` (ranked numeric \xB7 2\u20138 items), `timeline` (dated narrative \xB7 3\u20138 beats), `pie-chart` (distribution \xB7 2\u20136 slices \xB7 renders as a donut). Text-matrix sub-types: `comparison-table` (N options \xD7 M criteria), `force-field` (drivers vs resistors), `strengths-cautions` (pros/cons/verdict per option). Triggers: ranked numeric \u2192 bar-chart \xB7 chronology / historical analogue / projected sequence \u2192 timeline \xB7 distribution that sums (probability split / vote tallies / shares / mix) \u2192 pie-chart \xB7 2-axis plot \u2192 quadrant-chart \xB7 N-options-with-mixed-cells \u2192 comparison-table \xB7 for/against forces \u2192 force-field \xB7 pros/cons/verdict matrix \u2192 strengths-cautions. **Beyond `visuals`, the writer ALSO emits inline charts (flowchart / mindmap / gantt / sequenceDiagram / stateDiagram / journey, all rendered through the `kami-chart` pipeline) inside body sections where prose can't carry the structure efficiently** \u2014 these are automatic and don't need to be picked here.",
   "  \xB7 `metric-strip`        3\u20135 KPI / indicator cards \xB7 the room's quantitative reads as a dashboard row. Pick whenever \u2265 3 numbers (percentages, time windows, ratios, counts, ranges) showed up worth surfacing side-by-side. Massively higher information density than the same numbers buried in prose \u2014 strongly favoured for investment / market-forecast / strategic-decision briefs.",
   "  \xB7 `two-paths`           Side-by-side trajectory comparison (Path A vs Path B). Pick when the room argued two distinct futures or routes \u2014 punchier than a comparison-table.",
   "  \xB7 `why-now`             Single panel: window opened by what \xB7 window closes when \xB7 the bet implied. For investment / opportunity rooms (a16z-thesis spine).",
@@ -11767,11 +12291,11 @@ var SYSTEM_PROMPT = [
   "",
   "These rules ALSO apply transitively: if the asset bundle has 0 entries for a trigger, the matching component is encouraged but not mandatory.",
   "",
-  "## Visualisation discipline \xB7 prefer mermaid where it fits naturally",
+  "## Visualisation discipline \xB7 prefer charts where they fit naturally",
   "",
-  "Reports benefit from diagrams when content has structure prose can't carry efficiently \u2014 but no fixed quota. Pick components that auto-fire mermaid (divergence / positions / decision-options / scenario-tree / risk-register / recommendations / convergence) when their material is real in the room. Skip them when material is thin. Source of mermaid (either / both):",
-  "  1. Pick `visuals` with mermaid sub-types (`quadrant-chart` / `bar-chart` / `timeline` / `pie-chart`) \u2014 directly produces typed visuals.",
-  "  2. Stage 3 writer auto-emits inline mermaid (`flowchart` / `mindmap` / `gantt` / `sequenceDiagram` / `stateDiagram` / `journey`) on a per-section basis when content fits \u2014 knowing this helps you avoid double-allocating the same content to a typed visual.",
+  "Reports benefit from diagrams when content has structure prose can't carry efficiently \u2014 but no fixed quota. Pick components that auto-fire charts (divergence / positions / decision-options / scenario-tree / risk-register / recommendations / convergence) when their material is real in the room. Skip them when material is thin. Source of charts (either / both):",
+  "  1. Pick `visuals` with chart sub-types (`quadrant-chart` / `bar-chart` / `timeline` / `pie-chart`) \u2014 these render as inline SVG through the `kami-chart` pipeline (spine-tokenised, no JS runtime).",
+  "  2. Stage 3 writer auto-emits inline charts (`flowchart` / `mindmap` / `gantt` / `sequenceDiagram` / `stateDiagram` / `journey`, all rendered through the `kami-chart` pipeline) on a per-section basis when content fits \u2014 knowing this helps you avoid double-allocating the same content to a typed visual.",
   "",
   "**Quality over quantity.** A substantive strategy brief might naturally land at 4\u20136 charts; a tight philosophical brief at 0\u20131; both are correct. Don't manufacture chart material that isn't in the conversation \u2014 that produces hollow diagrams that distract more than they inform.",
   "",
@@ -11788,7 +12312,7 @@ var SYSTEM_PROMPT = [
   "  \xB7 ANY multi-party negotiation / approval-chain / system-call sequence \u2192 the writer auto-emits an inline `sequenceDiagram`. Surfaces under whichever section names the actors.",
   "  \xB7 ANY lifecycle / state-machine / phase-gating story \u2192 the writer auto-emits an inline `stateDiagram-v2`. Attach to `recommendations` or a `risk-register` branch.",
   "",
-  "Truly unvisualisable rooms (purely philosophical / definitional / no concrete entities) are allowed to skip \u2014 but they're rare. **When in doubt, pick `visuals` with a mermaid sub-type.** Reports without a mermaid chart in 2026 read as 2018-era memos.",
+  "Truly unvisualisable rooms (purely philosophical / definitional / no concrete entities) are allowed to skip \u2014 but they're rare. **When in doubt, pick `visuals` with a chart sub-type.** Reports without a chart in 2026 read as 2018-era memos.",
   "",
   "## Picking presets",
   "",
@@ -12866,10 +13390,10 @@ function stageFlagshipList() {
   if (cheap && !out.includes(cheap)) out.push(cheap);
   return out;
 }
-var STAGE_2_RETRIES = 1;
-var STAGE_2_TEMPERATURES = [0.2];
+var STAGE_2_RETRIES = 2;
+var STAGE_2_TEMPERATURES = [0.2, 0.5];
 var STAGE_1_CALL_TIMEOUT_MS = 75e3;
-var STAGE_2_CALL_TIMEOUT_MS = 12e4;
+var STAGE_2_CALL_TIMEOUT_MS = 24e4;
 var STAGE_3_CALL_TIMEOUT_MS = 24e4;
 function signalWithTimeout2(parent, timeoutMs) {
   const controller = new AbortController();
@@ -13108,7 +13632,7 @@ var TPS_BY_MODEL = {
   sonnet: 45,
   // sonnet-4-6 — structured JSON output, not free prose
   opus: 28
-  // opus-4-7 — rich markdown with tables / mermaid
+  // opus-4-7 — rich markdown with tables / inline-svg charts
 };
 var BASE_OVERHEAD_S = 1;
 var TTFT_S_PER_KT = 0.35;
@@ -13512,7 +14036,16 @@ async function runStage1(roomId, briefId, directors, transcript, room, language,
           modelV,
           messages,
           temperature: 0.2,
-          maxTokens: 2200,
+          // 4400 cap (was 2200) · 9-field asset bundle JSON · max 38
+          // entries × ~150 chars per entry ≈ 5700 chars ≈ 2500-3500
+          // output tokens for a dense director. 2200 was right at the
+          // edge for terse models (Gemini Flash) but Anthropic Opus /
+          // Sonnet emit verbose JSON and overflow, producing truncated
+          // output → parser drops to empty assets → `heuristicDirectorAssets`
+          // takes over with weaker signal recovery. Doubling the cap
+          // gives the verbose providers headroom without affecting
+          // the terse ones (they don't hit the cap).
+          maxTokens: 4400,
           signal: timeout.signal
         });
         if (timeout.timedOut()) throw new Error(`timed out after ${STAGE_1_CALL_TIMEOUT_MS / 1e3}s`);
@@ -13873,7 +14406,18 @@ async function runStage2(args) {
           modelV,
           messages: messagesForAttempt(),
           temperature: STAGE_2_TEMPERATURES[attempt] ?? 0.6,
-          maxTokens: 8e3,
+          // 16k cap (was 8k) · the structured scaffold JSON for a dense
+          // room (≥3 directors with rich signals, full visuals + risk
+          // register + perspectives) regularly lands at 10–14k output
+          // tokens. Opus 4.6 Fast hit the 8k ceiling mid-`directorPerspectives`
+          // and emitted truncated JSON · parseScaffold then returned
+          // null and the pipeline dropped to deterministic fallback,
+          // which has no visuals / divergence / risk — wiping every
+          // chart from the brief. Gemini 3 Flash is more terse on the
+          // same prompt so it cleared 8k on most rooms; Anthropic
+          // models reliably overflow. 16k matches Anthropic's max
+          // output cap for the Sonnet/Opus class.
+          maxTokens: 16e3,
           signal: timeout.signal,
           onText: (_delta, full) => advanceOnBuffer(full)
         });
@@ -14072,7 +14616,7 @@ async function runBentoStage(args) {
           modelV,
           messages,
           temperature: STAGE_2_TEMPERATURES[attempt] ?? 0.6,
-          maxTokens: 8e3,
+          maxTokens: 16e3,
           signal: args.signal
         })) {
           if (chunk.type === "text") {
@@ -15285,7 +15829,7 @@ async function synthesiseTopics(state, modelV, opts) {
    ${s.description}
    ${s.url}`
   ).join("\n\n");
-  const system = 'You recommend boardroom discussion topics to a user, based on (a) the chair\'s long-term memory of who they are + what they care about, and optionally (b) a set of currently-trending web/x.com snippets keyed off the user\'s recent interests. Produce EXACTLY 6 distinct topics \u2014 not 5, not 7, six. Each topic is a subject line a user could plausibly drop into the convene composer.\n\nThe 6 topics MUST span DIFFERENT dimensions/categories \u2014 don\'t return six pricing topics. Use the 10 keywords as a multi-dimensional search index; the 6 final topics should distil ACROSS those dimensions so the picker reads as a balanced board agenda, not a single-angle obsession. Each topic gets a different `tag`.\n\nVoice: tight, specific, opinionated. Avoid corporate-speak. Skew toward questions the user would actually want to debate, not generic explainers.\n\nEVERY topic MUST include a `tag` field \xB7 a SHORT CATEGORY in 1-2 lowercase words naming what bucket the topic falls into. Pick from the user\'s actual subject matter (examples: strategy / product / market / pricing / positioning / brand / hiring / fundraising / ops / infra / research / craft / ethics / personal / leadership / growth / sales / design / data / partnerships / regulation). FORBIDDEN tag values: "web", "memory", "general", "misc", "other", "topic", "recommendation" \u2014 these are meta-vocabulary that leaks the system, not real categories. If the topic spans two areas, pick the dominant one. NEVER omit the tag field.\n\nEach topic must cite either (a) at least one snippet ref (S<n>) \u2014 in which case set "source":"web" \u2014 OR (b) no snippet refs at all \u2014 in which case set "source":"memory". The `source` and `tag` fields are independent: `source` is the data provenance, `tag` is the topic category. Never use "web" or "memory" as a tag.\n\nStrict JSON output only:\n{ "topics": [ { "tag": "pricing", "subject": "...", "rationale": "one sentence on why this fits the user", "source": "web|memory", "snippetRefs": [<S indexes, omit when source=memory>] } ] }';
+  const system = 'You recommend boardroom discussion topics to a user, based on (a) the chair\'s long-term memory of who they are + what they care about, and optionally (b) a set of currently-trending web/x.com snippets keyed off the user\'s recent interests. Produce EXACTLY 5 distinct topics \u2014 not 4, not 6, five. Each topic is a subject line a user could plausibly drop into the convene composer.\n\nThe 5 topics MUST span DIFFERENT dimensions/categories \u2014 don\'t return five pricing topics. Use the 10 keywords as a multi-dimensional search index; the 5 final topics should distil ACROSS those dimensions so the picker reads as a balanced board agenda, not a single-angle obsession. Each topic gets a different `tag`.\n\nVoice: tight, specific, opinionated. Avoid corporate-speak. Skew toward questions the user would actually want to debate, not generic explainers.\n\nEVERY topic MUST include a `tag` field \xB7 a SHORT CATEGORY in 1-2 lowercase words naming what bucket the topic falls into. Pick from the user\'s actual subject matter (examples: strategy / product / market / pricing / positioning / brand / hiring / fundraising / ops / infra / research / craft / ethics / personal / leadership / growth / sales / design / data / partnerships / regulation). FORBIDDEN tag values: "web", "memory", "general", "misc", "other", "topic", "recommendation" \u2014 these are meta-vocabulary that leaks the system, not real categories. If the topic spans two areas, pick the dominant one. NEVER omit the tag field.\n\nEach topic must cite either (a) at least one snippet ref (S<n>) \u2014 in which case set "source":"web" \u2014 OR (b) no snippet refs at all \u2014 in which case set "source":"memory". The `source` and `tag` fields are independent: `source` is the data provenance, `tag` is the topic category. Never use "web" or "memory" as a tag.\n\nStrict JSON output only:\n{ "topics": [ { "tag": "pricing", "subject": "...", "rationale": "one sentence on why this fits the user", "source": "web|memory", "snippetRefs": [<S indexes, omit when source=memory>] } ] }';
   const user = `# Keywords distilled from chair memory
 ${keywords.map((k, i) => `K${i + 1}. ${k}`).join("\n")}
 
@@ -15295,7 +15839,7 @@ ${memorySummary}
 # Web snippets ${hasWeb ? "(use these to ground at least some recs as source=web)" : "(none \u2014 synthesise from memory only)"}
 ${snippetBlock}
 
-Return EXACTLY 6 topics as JSON, each with a different tag, spanning different dimensions.`;
+Return EXACTLY 5 topics as JSON, each with a different tag, spanning different dimensions.`;
   const raw = await callPhaseLLM2(state, modelV, [
     { role: "system", content: system },
     { role: "user", content: user }
@@ -15904,9 +16448,21 @@ async function pickRoundWrap(opts) {
 }
 async function pickNextSpeaker(opts) {
   const { candidates, history, room, signal } = opts;
+  const mode = opts.mode === "dissent-gap" ? "dissent-gap" : "lens-gap";
+  const convergentTerms = (opts.convergentTerms || []).filter(Boolean);
   if (candidates.length < 2) return { agentId: null, rationale: "", intervention: null };
-  const roster = candidates.map((a) => `- ${a.id} \xB7 ${a.name} (${a.handle}) \xB7 ${a.roleTag}
-  ${a.bio}`).join("\n");
+  const roster = candidates.map((a) => {
+    const baseRow = `- ${a.id} \xB7 ${a.name} (${a.handle}) \xB7 ${a.roleTag}
+  ${a.bio}`;
+    if (mode !== "dissent-gap") return baseRow;
+    const takes = a.personaSpec?.spec?.contrarianTakes?.slice(0, 3) || [];
+    const failures = a.personaSpec?.spec?.failureModes?.slice(0, 1) || [];
+    const extras = [];
+    if (takes.length > 0) extras.push(`  \xB7 contrarian takes: ${takes.join(" \xB7 ")}`);
+    if (failures.length > 0) extras.push(`  \xB7 failure mode: ${failures[0]}`);
+    return extras.length > 0 ? `${baseRow}
+${extras.join("\n")}` : baseRow;
+  }).join("\n");
   const transcript = history.slice(-12).filter((m) => {
     if (!m.body || !m.body.trim()) return false;
     const meta = m.meta;
@@ -15917,6 +16473,38 @@ async function pickNextSpeaker(opts) {
     const who = m.authorKind === "user" ? "USER" : m.authorId || "agent";
     return `[${who}] ${m.body.trim().slice(0, 600)}`;
   }).join("\n\n");
+  const decision1Block = mode === "dissent-gap" ? [
+    "DECISION 1 \xB7 Next speaker (DISSENT-GAP MODE).",
+    "The room is converging on a single frame \u2014 for THIS pick, the chair",
+    "needs the director MOST LIKELY to break that frame. Score each",
+    "candidate on:",
+    "  \xB7 Their `contrarian takes` (listed in the roster) versus the room's",
+    "    detected convergent terms (surfaced in the user message below).",
+    "    Pick whose stated contrarian moves DIRECTLY puncture the cluster.",
+    "  \xB7 Their `failure mode` is a NEGATIVE signal \u2014 a director whose",
+    "    failure mode is 'gets sucked into specifics' is exactly who you",
+    "    do NOT pick when the room is already lost in specifics.",
+    "  \xB7 Lens distance from the convergent frame \xB7 pick a lens furthest",
+    "    from the cluster's gravitational center.",
+    "  \xB7 Recency \xB7 prefer directors who haven't spoken in the last 2 turns",
+    "    when scores are comparable.",
+    "  \xB7 If NO candidate is clearly the frame-breaker (e.g. all candidates",
+    "    have already been used recently OR none have relevant contrarian",
+    "    takes), set agent_id=null and let round-robin run."
+  ].join("\n") : [
+    "DECISION 1 \xB7 Next speaker. From the candidates below, pick which",
+    "director should speak NEXT \u2014 the one whose lens most sharply",
+    "addresses the unresolved tension, hidden assumption, or missing",
+    "counter-argument in the previous turn.",
+    "  \xB7 Match LENS to the gap, not just topic relevance. If the prior",
+    "    turn made a structural claim, pick a director whose role",
+    "    pushes back from a different lens (data \u2192 narrative,",
+    "    empirical \u2192 first-principles, etc.).",
+    "  \xB7 Prefer directors who haven't been quoted yet THIS round when",
+    "    fits are comparable \u2014 diversity of voice.",
+    "  \xB7 If no candidate clearly fits better than the current head of",
+    "    queue, set agent_id=null and let round-robin run."
+  ].join("\n");
   const sys = {
     role: "system",
     content: [
@@ -15924,18 +16512,7 @@ async function pickNextSpeaker(opts) {
       "a reactive round; one director just finished. You make TWO",
       "decisions in one pass.",
       "",
-      "DECISION 1 \xB7 Next speaker. From the candidates below, pick which",
-      "director should speak NEXT \u2014 the one whose lens most sharply",
-      "addresses the unresolved tension, hidden assumption, or missing",
-      "counter-argument in the previous turn.",
-      "  \xB7 Match LENS to the gap, not just topic relevance. If the prior",
-      "    turn made a structural claim, pick a director whose role",
-      "    pushes back from a different lens (data \u2192 narrative,",
-      "    empirical \u2192 first-principles, etc.).",
-      "  \xB7 Prefer directors who haven't been quoted yet THIS round when",
-      "    fits are comparable \u2014 diversity of voice.",
-      "  \xB7 If no candidate clearly fits better than the current head of",
-      "    queue, set agent_id=null and let round-robin run.",
+      decision1Block,
       "",
       "DECISION 2 \xB7 Intervention (optional \xB7 default: null). Read the",
       "prior 2\u20133 turns. Drop a 1-sentence chair note ONLY if a substantive",
@@ -15987,6 +16564,11 @@ async function pickNextSpeaker(opts) {
       // only language signal was "recent transcript" — which a
       // single English chair drift could pollute.
       ...room?.subject ? [`Room subject: ${room.subject}`, ``] : [],
+      ...mode === "dissent-gap" && convergentTerms.length > 0 ? [
+        `Detected convergent terms (room is over-investing here \xB7 the dissent pick should puncture these):`,
+        ...convergentTerms.map((t) => `  \xB7 "${t}"`),
+        ``
+      ] : [],
       `Candidates (queued, in current order):`,
       roster,
       ``,
@@ -16421,6 +17003,74 @@ function renderPersonaFewShotBlock(speaker, deliveryMode) {
   }
   return lines.join("\n");
 }
+function renderFrameBreakGuidance(terms) {
+  if (!terms || terms.length === 0) return "";
+  const bullets = terms.map((t) => `  \xB7 "${t}"`).join("\n");
+  return [
+    "",
+    `\u2500\u2500\u2500 FRAME-BREAK GUIDANCE \xB7 WHAT THE ROOM HAS ALREADY OVER-INVESTED IN \u2500\u2500\u2500`,
+    `The following noun phrases have been the recurring fixation in the last several turns. The room's value is breadth, not depth-in-one-frame. For THIS turn:`,
+    bullets,
+    `Treat these as a soft no-go. You may touch them ONLY (a) as a counter-example ("unlike X, \u2026") OR (b) to point out an assumption inside them the room hasn't questioned. Do NOT extend / refine / give a sub-angle on them. Find an entry point that lives OUTSIDE this cluster \u2014 a different stakeholder, a different time scale, a different mechanism, a different domain analogy.`
+  ].join("\n");
+}
+function renderFrameBreakerRole(role) {
+  if (!role || !role.convergentFrame) return "";
+  return [
+    "",
+    `\u2500\u2500\u2500 YOUR EXTRA JOB THIS TURN \xB7 BREAK THE ROOM'S FRAME \u2500\u2500\u2500`,
+    `The room is converging on "${role.convergentFrame}". For THIS turn, you have been designated the frame-breaker. Your turn MUST do at least ONE of:`,
+    `  (a) Propose a concrete scenario / population / domain where "${role.convergentFrame}" simply does NOT apply, and show what the product / decision would look like there instead.`,
+    `  (b) Introduce a constraint dimension the room has not yet considered (a different time scale \xB7 a different stakeholder type \xB7 a different technical layer \xB7 a different cultural / regulatory context \xB7 a different physical / material constraint \xB7 a different value system) and show how it changes what matters.`,
+    `Do NOT execute this as a literal labelled item ("frame-breaker move: \u2026"). Weave the move into your normal turn \u2014 the user sees the angle land naturally, not the assignment.`
+  ].join("\n");
+}
+function renderUnexploredAngles(angles) {
+  if (!angles || angles.length === 0) return "";
+  const bullets = angles.map((a) => `  \xB7 ${a}`).join("\n");
+  return [
+    "",
+    `\u2500\u2500\u2500 UNEXPLORED ANGLES \xB7 WHERE THE ROOM HASN'T LOOKED YET \u2500\u2500\u2500`,
+    `The chair noted these angles were raised-then-abandoned or notably absent in recent rounds:`,
+    bullets,
+    `Pick ONE as a possible entry point for your turn \u2014 or generate a fresh one of your own. The room is starved for breadth, not depth; one bullet on a genuinely new angle is worth three bullets refining a familiar one.`
+  ].join("\n");
+}
+function renderPersonaLensReminder(speaker) {
+  const spec = speaker.personaSpec;
+  if (spec && spec.spec) {
+    const concepts = (spec.spec.loadBearingConcepts || []).slice(0, 3);
+    const takes = (spec.spec.contrarianTakes || []).slice(0, 2);
+    const failure = (spec.spec.failureModes || [])[0] || "";
+    if (concepts.length === 0 && takes.length === 0) return "";
+    const lines = [
+      "",
+      `\u2500\u2500\u2500 YOUR LENS \xB7 LAST-MINUTE REMINDER \u2500\u2500\u2500`,
+      `Before you generate, re-anchor on who YOU are at this table. The conversation above has its own gravity; do NOT let it pull you off your signature angle.`
+    ];
+    if (concepts.length > 0) {
+      lines.push(`Your load-bearing concepts (the moves you naturally make): ${concepts.join(" \xB7 ")}.`);
+    }
+    if (takes.length > 0) {
+      lines.push(`Your contrarian takes (push back from these when the room is converging): ${takes.join(" \xB7 ")}.`);
+    }
+    if (failure) {
+      lines.push(`Your most common failure mode (avoid it this turn): ${failure}.`);
+    }
+    lines.push(`Speak from this. Not from the room's average frame.`);
+    return lines.join("\n");
+  }
+  const instr = (speaker.instruction || "").trim();
+  if (!instr) return "";
+  const slice = instr.length > 280 ? instr.slice(0, 280) + "\u2026" : instr;
+  return [
+    "",
+    `\u2500\u2500\u2500 YOUR LENS \xB7 LAST-MINUTE REMINDER \u2500\u2500\u2500`,
+    `Before you generate, re-anchor on who YOU are at this table \u2014 the conversation above has its own gravity, do not let it pull you off your signature angle.`,
+    `Recall your director frame: ${slice}`,
+    `Speak from this lens, not from the room's average frame.`
+  ].join("\n");
+}
 function renderPersonaReflectionBlock(speaker) {
   const spec = speaker.personaSpec;
   if (!spec || spec.reflectionChecklist.length === 0) return "";
@@ -16495,7 +17145,15 @@ var TONE_GUIDANCE = {
     "## Optional \xB7 one synthesis turn per round",
     "Once per round, ONE director may do a synthesis turn instead of pure generation: pick 2\u20133 of the room's ideas and propose 1\u20132 combinations. Use sparingly \u2014 80%+ of turns should be pure generation. The room's value is in the pile of ideas, not the polish on any one.",
     "",
-    `PERSONA OVERRIDE \xB7 your director instruction reads like Socrates / First Principles / Value Investor \u2014 the demand-definition / demand-mechanism / demand-base-rate DNA. **For THIS room ALL of that is PAUSED.** You are not your usual analytical self here; you're a fast idea-generator. Lean INTO yes-and, INTO loose connections, INTO half-formed variants. Your TURN_DIRECTIVE ("introduce a new variable / constraint / analogy / counter-example") is fully satisfied by raising a fresh idea or doing a yes-and combination \u2014 you don't need to attack anything. This is the one room where your dissent DNA is suspended end-to-end.`
+    "PERSONA OVERRIDE \xB7 your director instruction reads like Socrates / First Principles / Value Investor \u2014 the demand-definition / demand-mechanism / demand-base-rate DNA. For THIS room, the **rigor / forensic mode** of that DNA is paused (no slow definition-check ladders, no methodical mechanism decomposition, no insistence on base-rate citation before moving) \u2014 that's too slow for brainstorm cadence. But the **contrarian / curiosity / lens-distinctness** half of your DNA is *AMPLIFIED*, not paused. Your persona's signature angles (your loadBearingConcepts, your contrarianTakes, your failureModes) are exactly what produces the unexpected ideas the room needs.",
+    "",
+    "DIVERGENCE DISCIPLINE (this is the anti-convergence rule, read it twice) \xB7",
+    "  \xB7 The room's gravitational pull, after 2-3 rounds, is toward whatever phrase has been said the most. Resist this consciously. If a core word from the prior 2 turns is about to appear in your turn, **stop and find a different entry point**. Saying it a second time = you got pulled. Saying it a third = the room has collapsed.",
+    "  \xB7 Yes-and is allowed for ONE of your bullets at most. The other 3-5 bullets must each open a direction the prior turn(s) did NOT touch. Yes-and is the local move; the room's job is global coverage.",
+    `  \xB7 If the most recent turn lived in domain X (e.g. "audit", "trust", "workflow"), your turn's center of gravity must be at LEAST one domain away (e.g. if peers are on audit, you go to physical environment, or cultural ritual, or time scale, or hidden user, or material constraint \u2014 not "audit but for X").`,
+    '  \xB7 Half-baked + concrete > polished + abstract. "What if the AI sat on a literal chair and rolled with the team" beats "AI as a collaborative presence layer" every time. Wild specificity > safe generality.',
+    `  \xB7 Your contrarian DNA: if your persona would normally push back against the room's emerging consensus, DO IT \u2014 but in brainstorm style: not as a 5-sentence rebuttal but as ONE counter-idea bullet that opens a fresh angle ("contra all the productivity talk \u2014 what if the assistant's job is to slow people down at exactly 3 inflection points a day?").`,
+    `  \xB7 TURN_DIRECTIVE ("introduce a new variable / constraint / analogy / counter-example") here means **at least one bullet of every turn must satisfy it**. Yes-and bullets don't count toward this floor.`
   ].join("\n"),
   constructive: [
     "CONSTRUCTIVE \xB7 sympathetic interrogator. You want the user to win, but only via an idea that can actually survive scrutiny.",
@@ -16836,14 +17494,35 @@ Name: ${prefs.name}
       `\xB7 When the user's most recent input is already in the room (visible above as a [${prefs.name || "You"}] turn), you may acknowledge it ONCE in the opening sweep \u2014 never again. On any later turn, do NOT open with "Since you asked \u2026" / "As you requested \u2026" / "\u65E2\u7136\u4F60\u8981\u6C42\u4E86 \u2026" / "\u6309\u4F60\u8BF4\u7684 \u2026" / "\u65E2\u7136\u4F60\u63D0\u51FA \u2026" / "\u4F60\u65E2\u7136\u8BA9\u6211 \u2026" or any rephrasing. The user's direction is absorbed context now; engage with the discussion, don't re-preface every turn \u2014 that loops. If you've already spoken once on this user input, your next turn must move PAST that acknowledgment.`,
       `\xB7 If you genuinely have NOTHING substantive to add this turn \u2014 the room has exhausted your angle, every point you'd make has already been made \u2014 return an EMPTY response (no text at all). Do NOT narrate your silence. Never output "\uFF08\u6C89\u9ED8\uFF09", "(silent)", "\u6211\u6CA1\u6709\u66F4\u591A\u8981\u8865\u5145\u7684", "I have nothing to add", "pass this round", "skip this turn", "abstain", or any variant. Those bubbles read as "the director gave up" and pollute the transcript; the system handles silent turns gracefully and moves the queue on. Return empty OR find one genuinely fresh angle (a different lens, a sharper edge case, a counter-frame, a missing trade-off) \u2014 never the meta-narration in between.`,
       `\xB7 The TONE and INTENSITY blocks above are the room's working agreement \u2014 they OVERRIDE ${toneOverrideTarget} The user explicitly opted into this register; staying in role is the helpful behaviour, not breaking it for trained politeness or trained adversariness.`,
-      // Persona reflection checklist · last persona-tuned entry in
-      // the system prompt. Empty string (no-op) for Signal-mode and
-      // seeded directors · zero per-turn cost. The checklist is
-      // tuned per-persona by Phase 6 of the build pipeline · catches
-      // failure modes specific to THIS director (e.g. "Am I
-      // repeating @another_director's mechanism point?" for a
-      // Historian).
+      // Persona reflection checklist · catches failure modes
+      // specific to THIS director (e.g. "Am I repeating
+      // @another_director's mechanism point?" for a Historian).
+      // Empty for Signal-mode / seed directors.
       renderPersonaReflectionBlock(speaker),
+      // Frame-break guidance (Layer 1.4) · "the room is converging
+      // on X / Y / Z — don't extend them this turn." Soft no-go
+      // list seen by ALL directors. Empty on opening rounds, short
+      // rooms, and diverse rooms where no fixation detected.
+      renderFrameBreakGuidance(opts.frameBreakTerms),
+      // Unexplored angles (Layer 3.2) · positive companion · "here
+      // are angles the room hasn't gone to yet; pick one or generate
+      // your own." Empty when no negative-space record exists.
+      renderUnexploredAngles(opts.unexploredAngles),
+      // Frame-breaker role (Layer 2.2) · single designated
+      // director per round; addendum tells them to do one of two
+      // structural moves to break the room's frame. Empty for
+      // non-frame-breakers and non-reactive rounds.
+      renderFrameBreakerRole(opts.frameBreakerRole),
+      // Persona-lens reminder · re-anchors the director on their
+      // signature angle (top 3 loadBearingConcepts + top 2
+      // contrarianTakes + worst failure mode) at the very tail of
+      // the system prompt. The base persona instruction at the TOP
+      // of the prompt has decayed against transformer attention by
+      // this point; this reminder fights the conversational-mean
+      // gravity that pulls directors into homogeneous voice by
+      // round 3-4. See renderPersonaLensReminder above for the
+      // composition rules.
+      renderPersonaLensReminder(speaker),
       // Target-language LANGUAGE LOCK · TRULY the last block in the
       // system prompt so it's the freshest signal in the LLM's
       // attention. Written in the room's working language (Chinese
@@ -17315,6 +17994,65 @@ function parseRoundEndOutput(text) {
   return { ping, points, modeShift };
 }
 
+// src/orchestrator/negative-space-extract.ts
+function renderTranscriptForRound(roundMessages) {
+  const lines = [];
+  for (const m of roundMessages) {
+    if (m.authorKind !== "agent") continue;
+    const kind = m.meta?.kind;
+    if (kind && (kind === "round-open" || kind === "settings" || kind === "round-prompt")) continue;
+    const body = (m.body || "").trim();
+    if (!body) continue;
+    lines.push(body.length > 500 ? body.slice(0, 500) + "\u2026" : body);
+  }
+  return lines.join("\n---\n");
+}
+async function extractNegativeSpace(opts) {
+  const turns = (opts.roundMessages || []).filter(
+    (m) => m.authorKind === "agent" && !m.meta?.kind
+  );
+  if (turns.length < 2) return [];
+  const transcript = renderTranscriptForRound(turns);
+  if (!transcript) return [];
+  const modelV = utilityModelFor();
+  if (!modelV) return [];
+  const prompt = `You are protecting the divergence of a multi-director brainstorm. The room's subject is: "${opts.roomSubject}". A round of director turns just ended. Read those turns below and identify 1-3 ANGLES the round did NOT touch but plausibly SHOULD have, given the room's subject. An "angle" is a short noun phrase \u2264 8 words \u2014 a stakeholder type, a time horizon, a domain analogy, a technical layer, a cultural / regulatory context, a material constraint, a hidden user, a counter-population.
+
+RULES
+  \xB7 Each angle is a NEW direction the room could explore next, not a critique of what was said.
+  \xB7 Each angle is a CONCRETE noun phrase, not a question. ("informal-economy workers" yes; "what about workers?" no.)
+  \xB7 Each angle is genuinely fresh \u2014 NOT a paraphrase of what the round already discussed.
+  \xB7 Match the language of the transcript.
+  \xB7 Return ONLY a newline-separated list (max 3 lines). No bullets, no numbering, no preamble.
+  \xB7 If the round was already genuinely diverse and no obvious angle is missing, return the literal token NONE.
+
+Round transcript:
+${transcript}
+
+Unexplored angles (newline-separated, or NONE):`;
+  let body;
+  try {
+    body = await callLLM({
+      modelV,
+      carrier: null,
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0.4,
+      maxTokens: 120
+    });
+  } catch (e) {
+    process.stderr.write(
+      `[negative-space] extract failed: ${e instanceof Error ? e.message : String(e)}
+`
+    );
+    return [];
+  }
+  const txt = (body || "").trim();
+  if (!txt) return [];
+  if (/^none\b/i.test(txt) || /^无$/.test(txt)) return [];
+  const lines = txt.split(/\n/).map((l) => l.trim().replace(/^[-·•*\d.)\s]+/, "").replace(/[。.]+$/, "")).filter((l) => l.length > 0 && l.length < 200);
+  return lines.slice(0, 3);
+}
+
 // src/storage/summaries.ts
 init_db();
 function rowFrom(r) {
@@ -17419,7 +18157,13 @@ async function generateL1ForRound(roomId, roundNum) {
   const keyPointsBlock = keyPoints.length ? "\n\nChair's key points from this round:\n" + keyPoints.map((kp, i) => `${i + 1}. ${kp.body}`).join("\n") : "";
   const modelV = utilityModelFor();
   if (!modelV) return;
-  const prompt = `Summarise round ${roundNum} of a multi-director boardroom discussion in 2-4 short sentences. Capture: (a) what the directors actually said (their distinct positions, not just topics), (b) where they pushed back on each other, (c) any concrete claim or recommendation that emerged. Do NOT restate the original question. Do NOT add commentary. Plain prose, third person, present tense.
+  const prompt = `Summarise round ${roundNum} of a multi-director boardroom discussion in 4-7 short sentences. Your PRIMARY job is to **protect divergence** \u2014 preserve angles the room raised but did not develop, so future rounds know what's still open. Capture, in this order:
+(a) **New variables / lenses** any director introduced (even if the room ignored them) \u2014 list each by name. These are the room's unspent fuel.
+(b) **What was waved past** \u2014 angles mentioned in one sentence then abandoned. Name them explicitly.
+(c) **What was notably ABSENT** \u2014 if the round all discussed X, name 1-2 obvious dimensions (time scale, stakeholder type, geographic context, technical layer, cultural angle) that the round did NOT touch but should have.
+(d) **Tensions** \u2014 where directors took different positions (not "they all agreed on X"; that erases the divergence we want to preserve).
+(e) Only AFTER (a)-(d), 1-2 sentences on the substantive claims that emerged.
+Do NOT restate the original question. Do NOT add commentary. Do NOT use phrases like "directors converged" or "consensus emerged" \u2014 those distill out exactly the divergence we want to keep. Plain prose, third person, present tense.
 
 --- Round ${roundNum} transcript ---
 ${transcript}` + keyPointsBlock;
@@ -17429,8 +18173,8 @@ ${transcript}` + keyPointsBlock;
     messages: [
       { role: "user", content: prompt }
     ],
-    temperature: 0.2,
-    maxTokens: 400
+    temperature: 0.3,
+    maxTokens: 650
   });
   const trimmed = body.trim();
   if (!trimmed) return;
@@ -17452,7 +18196,14 @@ async function foldL1IntoL2(roomId, newRoundNum, newL1Body) {
 ${existing.body}
 
 ` : "";
-  const prompt = `You maintain a rolling consolidated narrative of an ongoing multi-director boardroom discussion. A new round just dropped out of the recent window and needs to be folded in. Produce a single narrative of 4-7 sentences covering rounds ${startRound} through ${endRound}. Preserve: each director's evolving position, where the discussion sharpened, decisions / commitments that emerged. Drop: minor exchanges, repeated points already captured. Plain prose, third person.
+  const prompt = `You maintain a rolling consolidated narrative of an ongoing multi-director boardroom discussion. A new round just dropped out of the recent window and needs to be folded in. Produce a single narrative of 6-10 sentences covering rounds ${startRound} through ${endRound}.
+
+Your PRIMARY job is to **protect divergence over time** \u2014 long rooms drift toward a single thread, and your narrative is what the next 10 rounds will use to remember the room. Maintain:
+(a) **A running list of "still-open angles"** \u2014 variables / lenses that were raised in any round and not deeply developed. Carry these forward across folds; do NOT prune them when a new round dominates a different track.
+(b) **Each director's distinctive lens** \u2014 what makes their contribution NOT interchangeable with the others. Avoid "all directors agreed on X" framings.
+(c) **Major pivots** \u2014 points where the room genuinely shifted direction (versus just deepened an existing track).
+(d) **Tensions that remain unresolved** \u2014 disagreements that haven't been settled. Preserve them; do NOT smooth them into consensus.
+Drop: minor exchanges, micro-clarifications, repeated points. Plain prose, third person. Do NOT use phrases like "directors converged" or "consensus emerged" \u2014 they erase exactly the divergence we want to preserve.
 
 ${previousBlock}New round ${newRoundNum} (just demoted from L1):
 ${newL1Body}`;
@@ -17460,8 +18211,8 @@ ${newL1Body}`;
     modelV,
     carrier: null,
     messages: [{ role: "user", content: prompt }],
-    temperature: 0.25,
-    maxTokens: 600
+    temperature: 0.3,
+    maxTokens: 900
   });
   const trimmed = body.trim();
   if (!trimmed) return;
@@ -17497,9 +18248,53 @@ function hashOf(s) {
   return (h >>> 0).toString(16);
 }
 
+// src/storage/negative-space.ts
+init_db();
+function mapRow11(r) {
+  return {
+    id: r.id,
+    roomId: r.room_id,
+    roundNum: r.round_num,
+    angle: r.angle,
+    createdAt: r.created_at,
+    consumed: r.consumed === 1
+  };
+}
+function insertNegativeSpaceAngles(roomId, roundNum, angles) {
+  if (angles.length === 0) return;
+  const db = getDb();
+  const stmt = db.prepare(
+    "INSERT INTO negative_space (id, room_id, round_num, angle, created_at, consumed) VALUES (?, ?, ?, ?, ?, 0)"
+  );
+  const now = Date.now();
+  const tx = db.transaction((rows) => {
+    for (const r of rows) {
+      stmt.run(r.id, roomId, roundNum, r.angle, now);
+    }
+  });
+  tx(
+    angles.map((a) => a.trim()).filter((a) => a.length > 0 && a.length < 280).map((a) => ({ id: newId(), angle: a }))
+  );
+}
+function getRecentUnexploredAngles(roomId, limit = 5) {
+  const rows = getDb().prepare(
+    "SELECT id, room_id, round_num, angle, created_at, consumed FROM negative_space WHERE room_id = ? AND consumed = 0 ORDER BY created_at DESC LIMIT ?"
+  ).all(roomId, Math.max(1, Math.floor(limit)));
+  return rows.map(mapRow11);
+}
+function markAnglesConsumed(angleIds) {
+  if (angleIds.length === 0) return;
+  const db = getDb();
+  const stmt = db.prepare("UPDATE negative_space SET consumed = 1 WHERE id = ?");
+  const tx = db.transaction((ids) => {
+    for (const id of ids) stmt.run(id);
+  });
+  tx(angleIds);
+}
+
 // src/storage/config-events.ts
 init_db();
-function mapRow11(row) {
+function mapRow12(row) {
   return {
     id: row.id,
     roomId: row.room_id,
@@ -17513,7 +18308,7 @@ function listConfigEvents(roomId) {
   const rows = getDb().prepare(
     "SELECT id, room_id, kind, payload, actor_kind, created_at FROM config_events WHERE room_id = ? ORDER BY created_at ASC"
   ).all(roomId);
-  return rows.map(mapRow11);
+  return rows.map(mapRow12);
 }
 function insertConfigEvent(e) {
   const id = newId();
@@ -17631,6 +18426,382 @@ ${lines.join("\n")}`);
   ].join("\n");
 }
 
+// src/orchestrator/frame-break.ts
+function renderForExtraction(messages, maxBodyChars = 360) {
+  const lines = [];
+  for (const m of messages) {
+    if (m.authorKind !== "agent") continue;
+    const meta = m.meta || {};
+    if (meta.kind === "round-open" || meta.kind === "settings" || meta.kind === "round-prompt") continue;
+    const body = (m.body || "").trim();
+    if (!body) continue;
+    lines.push(body.length > maxBodyChars ? body.slice(0, maxBodyChars) + "\u2026" : body);
+  }
+  return lines.join("\n---\n");
+}
+async function extractDominantTerms(opts) {
+  const window = opts.windowSize ?? 15;
+  const recent = (opts.messages || []).slice(-window);
+  const directorTurns = recent.filter(
+    (m) => m.authorKind === "agent" && !m.meta?.kind
+  );
+  if (directorTurns.length < 4) return [];
+  const modelV = utilityModelFor();
+  if (!modelV) return [];
+  const transcript = renderForExtraction(directorTurns);
+  if (!transcript.trim()) return [];
+  const prompt = `You are inspecting a multi-director brainstorm for SIGNS OF CONVERGENCE. Read the recent director turns below and identify the noun phrases / concepts that have become the room's recurring fixation \u2014 terms mentioned by multiple directors across multiple turns that are now functioning as the room's gravitational center.
+
+RULES
+  \xB7 Return ONLY a comma-separated list (no preamble, no JSON, no explanation).
+  \xB7 3-5 terms maximum. Each term \u2264 4 words.
+  \xB7 Prefer the highest-content noun phrases (e.g. "audit responsibility", "compliance burden") over generic words ("AI", "tool", "user").
+  \xB7 If the conversation is genuinely diverse and no single fixation has emerged, return the literal token NONE (no list).
+  \xB7 Match the language of the transcript (Chinese in, Chinese terms out).
+
+Recent director turns:
+${transcript}
+
+Recurring fixation terms (comma-separated, or NONE):`;
+  let body;
+  try {
+    body = await callLLM({
+      modelV,
+      carrier: null,
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0.1,
+      maxTokens: 80
+    });
+  } catch (e) {
+    process.stderr.write(
+      `[frame-break] extract failed: ${e instanceof Error ? e.message : String(e)}
+`
+    );
+    return [];
+  }
+  const txt = (body || "").trim();
+  if (!txt) return [];
+  if (/^none\b/i.test(txt) || /^无$/.test(txt)) return [];
+  const raw = txt.split(/[,，、]/);
+  const out = [];
+  for (const r of raw) {
+    const trimmed = r.trim().replace(/^["'"'"']+|["'"'"'.。]+$/g, "");
+    if (!trimmed) continue;
+    if (trimmed.length > 60) continue;
+    if (/[\n:：]/.test(trimmed)) continue;
+    out.push(trimmed);
+    if (out.length >= 5) break;
+  }
+  return out;
+}
+
+// src/storage/qd-archive.ts
+init_db();
+var QD_BUCKETS_PER_DIM = 4;
+var QD_TOTAL_CELLS = QD_BUCKETS_PER_DIM ** 3;
+function mapRow13(r) {
+  return {
+    messageId: r.message_id,
+    roomId: r.room_id,
+    abstractionBucket: r.abstraction_bucket,
+    timeBucket: r.time_bucket,
+    stakeholderBucket: r.stakeholder_bucket,
+    abstractionScore: r.abstraction_score,
+    timeScore: r.time_score,
+    stakeholderScore: r.stakeholder_score,
+    scoredAt: r.scored_at
+  };
+}
+function bucketize(score) {
+  const s = Math.max(0, Math.min(1, score));
+  const b = Math.floor(s * QD_BUCKETS_PER_DIM);
+  return b === QD_BUCKETS_PER_DIM ? QD_BUCKETS_PER_DIM - 1 : b;
+}
+function upsertQDScore(opts) {
+  const now = Date.now();
+  const ab = bucketize(opts.scores.abstractionScore);
+  const tb = bucketize(opts.scores.timeScore);
+  const sb = bucketize(opts.scores.stakeholderScore);
+  getDb().prepare(
+    "INSERT OR REPLACE INTO qd_archive (message_id, room_id, abstraction_score, abstraction_bucket, time_score, time_bucket, stakeholder_score, stakeholder_bucket, scored_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+  ).run(
+    opts.messageId,
+    opts.roomId,
+    opts.scores.abstractionScore,
+    ab,
+    opts.scores.timeScore,
+    tb,
+    opts.scores.stakeholderScore,
+    sb,
+    now
+  );
+  return {
+    messageId: opts.messageId,
+    roomId: opts.roomId,
+    abstractionBucket: ab,
+    timeBucket: tb,
+    stakeholderBucket: sb,
+    abstractionScore: opts.scores.abstractionScore,
+    timeScore: opts.scores.timeScore,
+    stakeholderScore: opts.scores.stakeholderScore,
+    scoredAt: now
+  };
+}
+function listQDForRoom(roomId) {
+  const rows = getDb().prepare(
+    "SELECT message_id, room_id, abstraction_score, abstraction_bucket, time_score, time_bucket, stakeholder_score, stakeholder_bucket, scored_at FROM qd_archive WHERE room_id = ?"
+  ).all(roomId);
+  return rows.map(mapRow13);
+}
+function filledCellsForRoom(roomId) {
+  const rows = getDb().prepare(
+    "SELECT DISTINCT abstraction_bucket AS ab, time_bucket AS tb, stakeholder_bucket AS sb FROM qd_archive WHERE room_id = ?"
+  ).all(roomId);
+  const set = /* @__PURE__ */ new Set();
+  for (const r of rows) {
+    set.add(packCell(r.ab, r.tb, r.sb));
+  }
+  return set;
+}
+function packCell(a, t, s) {
+  return a * QD_BUCKETS_PER_DIM * QD_BUCKETS_PER_DIM + t * QD_BUCKETS_PER_DIM + s;
+}
+function coverageForRoom(roomId) {
+  const filled = filledCellsForRoom(roomId).size;
+  return {
+    filled,
+    total: QD_TOTAL_CELLS,
+    pct: filled / QD_TOTAL_CELLS
+  };
+}
+
+// src/orchestrator/qd-scorer.ts
+function parseScore(line) {
+  const m = line.match(/(\d+\.\d+|\d+)/);
+  if (!m) return null;
+  let n = parseFloat(m[1]);
+  if (!Number.isFinite(n)) return null;
+  if (n > 1 && n <= 10) n = n / 10;
+  if (n > 1 && n <= 100) n = n / 100;
+  return Math.max(0, Math.min(1, n));
+}
+async function scoreAndArchive(opts) {
+  const body = (opts.body || "").trim();
+  if (body.length < 40) return null;
+  const modelV = utilityModelFor();
+  if (!modelV) return null;
+  const prompt = `Rate the director turn below on THREE behavioral dimensions. Each rating is a single floating-point number 0.00-1.00.
+
+Dimension A \xB7 Abstraction level
+  \xB7 0.00 = concrete example (specific named user, specific product, specific scenario)
+  \xB7 0.33 = case / use-case (representative pattern, named domain)
+  \xB7 0.66 = mechanism / structural argument (how-it-works, conditions)
+  \xB7 1.00 = abstract principle (timeless / cross-domain / first-principles)
+
+Dimension B \xB7 Time scale
+  \xB7 0.00 = this quarter / immediate (months)
+  \xB7 0.33 = product cycle (1-3 years)
+  \xB7 0.66 = strategic / generational (5-20 years)
+  \xB7 1.00 = civilizational / long-horizon (50+ years, structural)
+
+Dimension C \xB7 Stakeholder scope
+  \xB7 0.00 = individual user / single role
+  \xB7 0.33 = team / org
+  \xB7 0.66 = industry / market
+  \xB7 1.00 = society / civilization
+
+OUTPUT \xB7 exactly three lines, one float per line, in order A B C. No labels, no JSON, no commentary.
+
+Turn:
+${body.length > 1200 ? body.slice(0, 1200) + "\u2026" : body}
+
+Three scores (one per line, A then B then C):`;
+  let raw;
+  try {
+    raw = await callLLM({
+      modelV,
+      carrier: null,
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0,
+      maxTokens: 30
+    });
+  } catch (e) {
+    process.stderr.write(
+      `[qd-scorer] LLM call failed: ${e instanceof Error ? e.message : String(e)}
+`
+    );
+    return null;
+  }
+  const lines = (raw || "").split(/\n/).map((l) => l.trim()).filter(Boolean);
+  if (lines.length < 3) return null;
+  const a = parseScore(lines[0]);
+  const t = parseScore(lines[1]);
+  const s = parseScore(lines[2]);
+  if (a === null || t === null || s === null) return null;
+  const scores = { abstractionScore: a, timeScore: t, stakeholderScore: s };
+  try {
+    upsertQDScore({ messageId: opts.messageId, roomId: opts.roomId, scores });
+  } catch (e) {
+    process.stderr.write(
+      `[qd-scorer] persist failed: ${e instanceof Error ? e.message : String(e)}
+`
+    );
+    return null;
+  }
+  return scores;
+}
+
+// src/storage/topic-branches.ts
+init_db();
+function mapBranch(r) {
+  return {
+    id: r.id,
+    roomId: r.room_id,
+    label: r.label,
+    parentId: r.parent_id,
+    openedAt: r.opened_at,
+    turnCount: r.turn_count,
+    lastSpeakerId: r.last_speaker_id
+  };
+}
+function listBranchesForRoom(roomId) {
+  const rows = getDb().prepare(
+    "SELECT id, room_id, label, parent_id, opened_at, turn_count, last_speaker_id FROM topic_branches WHERE room_id = ? ORDER BY opened_at ASC"
+  ).all(roomId);
+  return rows.map(mapBranch);
+}
+function createBranch(opts) {
+  const now = Date.now();
+  const id = newId();
+  const label = opts.label.trim().slice(0, 80);
+  const parentId = opts.parentId || null;
+  const speakerId = opts.openerSpeakerId || null;
+  getDb().prepare(
+    "INSERT INTO topic_branches (id, room_id, label, parent_id, opened_at, turn_count, last_speaker_id) VALUES (?, ?, ?, ?, ?, 1, ?)"
+  ).run(id, opts.roomId, label, parentId, now, speakerId);
+  return {
+    id,
+    roomId: opts.roomId,
+    label,
+    parentId,
+    openedAt: now,
+    turnCount: 1,
+    lastSpeakerId: speakerId
+  };
+}
+function tagMessageWithBranch(opts) {
+  const now = Date.now();
+  const db = getDb();
+  db.prepare(
+    "INSERT OR REPLACE INTO message_branches (message_id, branch_id, is_opener, tagged_at) VALUES (?, ?, ?, ?)"
+  ).run(opts.messageId, opts.branchId, opts.isOpener ? 1 : 0, now);
+  if (!opts.isOpener) {
+    db.prepare(
+      "UPDATE topic_branches SET turn_count = turn_count + 1, last_speaker_id = COALESCE(?, last_speaker_id) WHERE id = ?"
+    ).run(opts.speakerId || null, opts.branchId);
+  } else if (opts.speakerId) {
+    db.prepare("UPDATE topic_branches SET last_speaker_id = ? WHERE id = ?").run(opts.speakerId, opts.branchId);
+  }
+}
+function speakersOnBranches(roomId, branchIds) {
+  if (branchIds.length === 0) return /* @__PURE__ */ new Set();
+  const placeholders = branchIds.map(() => "?").join(",");
+  const rows = getDb().prepare(
+    `SELECT DISTINCT m.author_id AS author_id
+       FROM messages m
+       JOIN message_branches mb ON mb.message_id = m.id
+       WHERE m.room_id = ?
+         AND mb.branch_id IN (${placeholders})
+         AND m.author_kind = 'agent'
+         AND m.author_id IS NOT NULL`
+  ).all(roomId, ...branchIds);
+  return new Set(rows.map((r) => r.author_id));
+}
+function dominantBranches(roomId, limit = 3) {
+  const rows = getDb().prepare(
+    "SELECT id, room_id, label, parent_id, opened_at, turn_count, last_speaker_id FROM topic_branches WHERE room_id = ? ORDER BY turn_count DESC, opened_at DESC LIMIT ?"
+  ).all(roomId, Math.max(1, Math.floor(limit)));
+  return rows.map(mapBranch);
+}
+
+// src/orchestrator/topic-tagger.ts
+async function tagMessageBranch(opts) {
+  const body = (opts.body || "").trim();
+  if (!body) return null;
+  const modelV = utilityModelFor();
+  if (!modelV) return null;
+  const existing = listBranchesForRoom(opts.roomId);
+  const branchList = existing.length === 0 ? "(none yet \u2014 this is the first branch)" : existing.map((b, i) => `${i + 1}. id=${b.id} \xB7 "${b.label}" \xB7 ${b.turnCount} turn(s)`).join("\n");
+  const prompt = `You are tagging a director's turn in a multi-director brainstorm with the topic branch it belongs to. Branches are short noun-phrase angles the room has been exploring (e.g. "audit responsibility", "informal-economy workers", "ritualised handoff").
+
+Room subject: "${opts.roomSubject}"
+
+Existing branches in this room:
+${branchList}
+
+Director's turn to tag (verbatim):
+${body.length > 1200 ? body.slice(0, 1200) + "\u2026" : body}
+
+Decide ONE of:
+  (A) This turn primarily EXTENDS existing branch X. Output: EXTEND <branch-id>
+  (B) This turn primarily OPENS a NEW branch. Output: NEW <short-label-\u2264-8-words>
+
+Rules:
+  \xB7 A turn that mostly adds detail / sub-angle to an existing branch is EXTEND.
+  \xB7 A turn that introduces a genuinely fresh lens / domain / stakeholder is NEW.
+  \xB7 When the turn could plausibly go either way, prefer NEW \xB7 the room benefits from more branches.
+  \xB7 The label should be a CONCRETE noun phrase, not a question or full sentence.
+  \xB7 Match the language of the turn for new-branch labels.
+  \xB7 Output ONLY the directive \xB7 no explanation, no JSON, no preamble.`;
+  let raw;
+  try {
+    raw = await callLLM({
+      modelV,
+      carrier: null,
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0.1,
+      maxTokens: 40
+    });
+  } catch (e) {
+    process.stderr.write(
+      `[topic-tagger] failed: ${e instanceof Error ? e.message : String(e)}
+`
+    );
+    return null;
+  }
+  const txt = (raw || "").trim();
+  if (!txt) return null;
+  const extendMatch = txt.match(/^EXTEND\s+(\S+)/i);
+  if (extendMatch) {
+    const branchId = extendMatch[1];
+    if (existing.some((b) => b.id === branchId)) {
+      tagMessageWithBranch({
+        messageId: opts.messageId,
+        branchId,
+        isOpener: false,
+        speakerId: opts.speakerId
+      });
+      return branchId;
+    }
+  }
+  const newMatch = txt.match(/^NEW\s+(.+)$/i);
+  let label = newMatch ? newMatch[1].trim() : txt.length < 80 ? txt : "";
+  label = label.replace(/^["'`]+|["'`]+$/g, "").replace(/[。.!?]+$/, "").trim();
+  if (!label || label.length > 80) return null;
+  const branch = createBranch({
+    roomId: opts.roomId,
+    label,
+    openerSpeakerId: opts.speakerId
+  });
+  tagMessageWithBranch({
+    messageId: opts.messageId,
+    branchId: branch.id,
+    isOpener: true,
+    speakerId: opts.speakerId
+  });
+  return branch.id;
+}
+
 // src/voice/sentence-splitter.ts
 var END_RE = /[。！？!?；;：:\n]|[.](?=\s|$)/;
 var SentenceChunker = class {
@@ -18035,6 +19206,9 @@ function ensureState(roomId) {
       pendingRoundEnd: false,
       savedOnPause: null,
       pendingChairPick: null,
+      pendingFrameBreakTerms: null,
+      pendingFrameBreakerRole: null,
+      lastFrameBreakerAgentId: null,
       billingHaltedThisTurn: false,
       voiceWaiters: /* @__PURE__ */ new Map()
     };
@@ -18278,11 +19452,18 @@ function tickRoom(roomId, opts) {
   if (plan.length === 0) return;
   const state = ensureState(roomId);
   if (state.inflight) state.inflight.abort();
+  for (const [, waiter] of state.voiceWaiters) {
+    waiter();
+  }
+  state.voiceWaiters.clear();
   state.queue = plan.map((a) => ({ agentId: a.id, status: "queued" }));
   state.roundNum = opts.roundNum;
   state.speakersThisTurn = 0;
   state.savedOnPause = null;
   state.pendingChairPick = null;
+  state.pendingFrameBreakTerms = null;
+  state.pendingFrameBreakerRole = null;
+  state.lastFrameBreakerAgentId = null;
   state.billingHaltedThisTurn = false;
   state.maxSpeakersThisTurn = plan.length;
   emitQueueUpdate(roomId, state);
@@ -18345,11 +19526,77 @@ async function pumpQueue(roomId) {
             try {
               emitChairPending(roomId, "next-speaker");
               const pickRoom = getRoom(roomId);
+              let convergentTerms = [];
+              try {
+                convergentTerms = await extractDominantTerms({ messages: recent });
+              } catch {
+              }
+              try {
+                const branches = dominantBranches(roomId, 3);
+                if (branches.length > 0) {
+                  const seen = new Set(convergentTerms.map((t) => t.toLowerCase()));
+                  for (const b of branches) {
+                    if (b.turnCount >= 2 && !seen.has(b.label.toLowerCase())) {
+                      convergentTerms.push(b.label);
+                      seen.add(b.label.toLowerCase());
+                    }
+                  }
+                }
+              } catch {
+              }
+              const useDissentMode = convergentTerms.length > 0;
+              if (useDissentMode) {
+                state.pendingFrameBreakTerms = convergentTerms.slice();
+                rlog(roomId, "divergence-detect", {
+                  terms: convergentTerms,
+                  pickerMode: "dissent-gap"
+                });
+              }
+              let pickerCandidates = candidates;
+              if (useDissentMode) {
+                try {
+                  const branches = dominantBranches(roomId, 3);
+                  const dominantBranchIds = branches.map((b) => b.id);
+                  if (dominantBranchIds.length > 0) {
+                    const exposed = speakersOnBranches(roomId, dominantBranchIds);
+                    const underexposed = candidates.filter((c) => !exposed.has(c.id));
+                    const overexposed = candidates.filter((c) => exposed.has(c.id));
+                    if (underexposed.length > 0 && overexposed.length > 0) {
+                      pickerCandidates = [...underexposed, ...overexposed];
+                    }
+                  }
+                } catch {
+                }
+              }
               const pick = await pickNextSpeaker({
-                candidates,
+                candidates: pickerCandidates,
                 history: recent,
-                room: pickRoom ?? void 0
+                room: pickRoom ?? void 0,
+                mode: useDissentMode ? "dissent-gap" : "lens-gap",
+                convergentTerms: useDissentMode ? convergentTerms : void 0
               });
+              if (useDissentMode && convergentTerms.length > 0) {
+                const lastBreaker = state.lastFrameBreakerAgentId;
+                const chosenId = pick.agentId ?? state.queue[0]?.agentId;
+                let breakerId = null;
+                if (chosenId && chosenId !== lastBreaker) {
+                  breakerId = chosenId;
+                } else {
+                  const alt = candidates.find((c) => c.id !== lastBreaker && c.id !== chosenId);
+                  if (alt) breakerId = alt.id;
+                }
+                if (breakerId) {
+                  const frameLabel = (convergentTerms[0] || "").slice(0, 60);
+                  state.pendingFrameBreakerRole = {
+                    agentId: breakerId,
+                    convergentFrame: frameLabel
+                  };
+                  rlog(roomId, "frame-breaker-assign", {
+                    agent: getAgent(breakerId)?.name ?? breakerId,
+                    frame: frameLabel
+                  });
+                }
+              }
               const stillSameQueue = state.queue.length === queueSnapshot.length && state.queue.every((q, i) => q.agentId === queueSnapshot[i].agentId);
               if (stillSameQueue) {
                 if (pick.agentId && pick.agentId !== state.queue[0].agentId) {
@@ -18707,6 +19954,46 @@ async function streamSpeakerTurn(args) {
       });
     }
   }
+  const tStateForTurn = ensureState(roomId);
+  let frameBreakTerms;
+  if (tStateForTurn.pendingFrameBreakTerms && tStateForTurn.pendingFrameBreakTerms.length > 0) {
+    frameBreakTerms = tStateForTurn.pendingFrameBreakTerms.slice();
+  } else if (roundNum > 1 && history.length >= 4) {
+    try {
+      frameBreakTerms = await extractDominantTerms({ messages: history });
+      if (frameBreakTerms.length > 0) {
+        rlog(roomId, "frame-break-extract", {
+          round: roundNum,
+          speaker: speaker.name,
+          terms: frameBreakTerms,
+          via: "stream-fallback"
+        });
+        tStateForTurn.pendingFrameBreakTerms = frameBreakTerms.slice();
+      }
+    } catch {
+    }
+  }
+  let frameBreakerRole;
+  if (tStateForTurn.pendingFrameBreakerRole && tStateForTurn.pendingFrameBreakerRole.agentId === speaker.id) {
+    frameBreakerRole = { convergentFrame: tStateForTurn.pendingFrameBreakerRole.convergentFrame };
+    tStateForTurn.lastFrameBreakerAgentId = speaker.id;
+    tStateForTurn.pendingFrameBreakerRole = null;
+  }
+  let unexploredAngles;
+  if (roundNum > 1) {
+    try {
+      const rows = getRecentUnexploredAngles(roomId, 3);
+      if (rows.length > 0) {
+        unexploredAngles = rows.map((r) => r.angle);
+        markAnglesConsumed(rows.map((r) => r.id));
+      }
+    } catch (e) {
+      process.stderr.write(
+        `[room] unexplored-angles read failed: ${e instanceof Error ? e.message : String(e)}
+`
+      );
+    }
+  }
   const llmMessages = buildDirectorMessages({
     speaker,
     cast,
@@ -18719,6 +20006,9 @@ async function streamSpeakerTurn(args) {
     chairBrief: chairBriefForTurn ?? void 0,
     summaryPreamble,
     priorContext,
+    frameBreakTerms,
+    frameBreakerRole,
+    unexploredAngles,
     deliveryMode: room.deliveryMode
   });
   const placeholderMeta = {
@@ -18763,10 +20053,23 @@ async function streamSpeakerTurn(args) {
   process.stderr.write(`[voice-debug] room=${roomId} deliveryMode="${room.deliveryMode}" voiceMode=${voiceMode}
 `);
   const voiceChunker = voiceMode ? new SentenceChunker({ maxChars: 120 }) : null;
-  const voiceProfile = voiceMode ? voiceProfileForAgent(speaker) : null;
+  const initialVoiceProfile = voiceMode ? voiceProfileForAgent(speaker) : null;
   let voiceSeq = 0;
+  function currentVoiceProfile() {
+    if (!voiceMode) return null;
+    try {
+      const fresh = getAgent(speaker.id);
+      if (fresh) return voiceProfileForAgent(fresh);
+    } catch (e) {
+      process.stderr.write(`[tts] currentVoiceProfile read failed: ${e instanceof Error ? e.message : String(e)}
+`);
+    }
+    return initialVoiceProfile;
+  }
   async function emitVoiceText(text) {
-    if (!voiceMode || !voiceProfile || !text.trim()) return;
+    if (!voiceMode || !text.trim()) return;
+    const voiceProfile = currentVoiceProfile();
+    if (!voiceProfile) return;
     process.stderr.write(`[tts] emitVoiceText called: provider=${voiceProfile.provider} voiceId=${voiceProfile.voiceId} textLen=${text.length} text="${text.slice(0, 50)}"
 `);
     let chunkCount = 0;
@@ -18789,8 +20092,10 @@ async function streamSpeakerTurn(args) {
       process.stderr.write(`[tts] emitVoiceText done: ${chunkCount} chunks emitted
 `);
     } catch (e) {
-      process.stderr.write(`[tts] ERROR room=${roomId} agent=${speaker.name} \xB7 ${e instanceof Error ? e.stack || e.message : String(e)}
-`);
+      process.stderr.write(
+        `[tts] ERROR room=${roomId} agent=${speaker.name} provider=${voiceProfile.provider} voiceId=${voiceProfile.voiceId} \xB7 ${e instanceof Error ? e.stack || e.message : String(e)}
+`
+      );
     }
   }
   try {
@@ -18941,6 +20246,38 @@ async function streamSpeakerTurn(args) {
       messageId: placeholder.id,
       finishReason
     });
+    if (buf.trim().length >= 40) {
+      void (async () => {
+        try {
+          await tagMessageBranch({
+            roomId,
+            messageId: placeholder.id,
+            speakerId: speaker.id,
+            body: buf,
+            roomSubject: room.subject || ""
+          });
+        } catch (e) {
+          process.stderr.write(
+            `[room] topic-tag failed: ${e instanceof Error ? e.message : String(e)}
+`
+          );
+        }
+      })();
+      void (async () => {
+        try {
+          await scoreAndArchive({
+            roomId,
+            messageId: placeholder.id,
+            body: buf
+          });
+        } catch (e) {
+          process.stderr.write(
+            `[room] qd-score failed: ${e instanceof Error ? e.message : String(e)}
+`
+          );
+        }
+      })();
+    }
   }
   return placeholder.id;
 }
@@ -19747,6 +21084,27 @@ async function runChairRoundEnd(roomId, roundNum) {
     }
   });
   void runRoundEndSummarization(roomId, roundNum);
+  void (async () => {
+    try {
+      const room = getRoom(roomId);
+      if (!room) return;
+      const allMsgs = listMessages(roomId);
+      const roundMsgs = allMsgs.filter((m) => m.roundNum === roundNum);
+      if (roundMsgs.length === 0) return;
+      const angles = await extractNegativeSpace({
+        roundMessages: roundMsgs,
+        roomSubject: room.subject || ""
+      });
+      if (angles.length > 0) {
+        insertNegativeSpaceAngles(roomId, roundNum, angles);
+      }
+    } catch (e) {
+      process.stderr.write(
+        `[chair] negative-space extract failed: ${e instanceof Error ? e.message : String(e)}
+`
+      );
+    }
+  })();
 }
 async function emitChairAnnouncementVoice(roomId, messageId, body) {
   const room = getRoom(roomId);
@@ -20026,7 +21384,7 @@ function announceRoundOpen(roomId, roundNum, opening) {
 function announceAdjournNoBrief(roomId) {
   const chair = getChairAgent();
   if (!chair) return;
-  const body = "Adjourned without filing a brief. The chair (you) declared no report is needed for this session.";
+  const body = "Session adjourned without a report. If you'd like one later, use *Generate report* in the room header.";
   const m = insertMessage({
     roomId,
     authorKind: "agent",
@@ -21378,6 +22736,42 @@ function roomsRouter() {
     if (!brief) return c.json({ error: "brief not yet generated" }, 404);
     return c.json({ ...brief, isGenerating: isBriefGenerating(brief.id) });
   });
+  r.get("/:id/diversity", (c) => {
+    const id = c.req.param("id");
+    if (!getRoom(id)) return c.json({ error: "not found" }, 404);
+    const branches = listBranchesForRoom(id).slice().sort((a, b) => b.turnCount - a.turnCount || a.openedAt - b.openedAt).map((b) => ({
+      id: b.id,
+      label: b.label,
+      parentId: b.parentId,
+      openedAt: b.openedAt,
+      turnCount: b.turnCount,
+      lastSpeakerId: b.lastSpeakerId
+    }));
+    const coverage = coverageForRoom(id);
+    const qdRows = listQDForRoom(id);
+    const buckets = {
+      abstraction: [0, 0, 0, 0],
+      time: [0, 0, 0, 0],
+      stakeholder: [0, 0, 0, 0]
+    };
+    for (const r2 of qdRows) {
+      buckets.abstraction[r2.abstractionBucket] += 1;
+      buckets.time[r2.timeBucket] += 1;
+      buckets.stakeholder[r2.stakeholderBucket] += 1;
+    }
+    const unexplored = getRecentUnexploredAngles(id, 5).map((a) => ({
+      id: a.id,
+      angle: a.angle,
+      roundNum: a.roundNum
+    }));
+    return c.json({
+      branches,
+      coverage,
+      buckets,
+      messagesScored: qdRows.length,
+      unexplored
+    });
+  });
   r.get("/:id/briefs", (c) => {
     const id = c.req.param("id");
     if (!getRoom(id)) return c.json({ error: "not found" }, 404);
@@ -21739,7 +23133,7 @@ function voicesRouter() {
 init_paths();
 
 // src/version.ts
-var VERSION = "0.1.15";
+var VERSION = "0.1.16";
 
 // src/server.ts
 function createApp() {