huddle-cli 0.1.0 → 0.1.3

package/dist/orchestrator/council.js

@@ -1,21 +1,29 @@
 // The design council: for a big goal, every ready agent brainstorms before
-// anyone writes code — not just the brain. Three short rounds:
+// anyone writes code — not just the brain. Short rounds:
 //
-//   1. propose   each agent, in parallel and read-only, sketches architecture,
-//                a task breakdown, the contracts between tasks, and the risks
-//   2. critique  each agent reads the OTHERS' proposals and lists flaws,
-//                missing pieces and what should come next
-//   3. synthesize the brain turns all of it into the plan (the same PlannedTask
-//                JSON the scheduler already runs), noting whose idea each task was
+//   1. propose     each agent, in parallel and read-only, sketches architecture,
+//                  a task breakdown, the contracts between tasks, and the risks
+//   2. cross-review each agent reads the OTHERS' proposals and answers in fixed
+//                  sections: ADOPT (what <agent> got right that I missed), FLAW
+//                  (what <agent> got wrong and why), REVISED (my new position) —
+//                  what a person does by pasting one chat's answer into another
+//   3. synthesize  the agent whose ideas the others ADOPTed most writes the plan
+//                  (the brain when nobody adopted anything, or as the fallback),
+//                  with ONE primary idea author per task and a CONTRACT: the
+//                  exact names every task codes to
+//   4. ratify      every other agent replies OK or OBJECT: <change>; objections
+//                  get one revision by the synthesizer, never more
 //
 // Every call is time-boxed: an agent that is slow or errors is skipped, never
 // waited on. Small goals skip the council and keep the fast single-brain plan.
+import { setContract, capContract } from "../room/contract.js";
 import { askAgent } from "./ask.js";
 import { repoContext } from "./brain.js";
-import { goalSize, jsonCandidates, listsOwnTasks, parsePlan, planGoal, plannerPrompt } from "./planner.js";
-const defaultAsk = (m, prompt, cwd, o) => askAgent(m.adapter, prompt, cwd, { ...o, noTools: true, quick: true });
+import { carryGoal } from "./goal.js";
+import { goalSize, jsonCandidates, listsOwnTasks, parsePlain, parsePlan, planGoal, plannerPrompt } from "./planner.js";
+const defaultAsk = (m, prompt, cwd, o) => askAgent(m.adapter, prompt, cwd, { timeoutMs: o.timeoutMs, signal: o.signal, noTools: true, quick: o.quick ?? true });
 const PROPOSAL_CAP = 1500;
-const CRITIQUE_CAP = 900;
+const CRITIQUE_CAP = 1200;
 /** Default per-call time box; HUDDLE_COUNCIL_TIMEOUT_S overrides. */
 export function councilTimeoutMs() {
     const s = Number(process.env.HUDDLE_COUNCIL_TIMEOUT_S);
@@ -86,18 +94,18 @@ TASKS: 2-8 lines "- title — files — depends on"
 CONTRACTS: the interfaces tasks share (exact function names, file paths, data shapes)
 RISKS: the flaws, unknowns and edge cases most likely to break this`;
 }
-function critiquePrompt(goal, me, others) {
-    return `You are ${me.id}, on Huddle's design council. Your teammates proposed these plans for the goal below. Find what is wrong or missing before anyone builds it.
+function critiquePrompt(goal, me, others, mine) {
+    return `You are ${me.id}, on Huddle's design council. Your teammates proposed these plans for the goal below. Find what is wrong or missing before anyone builds it — and what they got right that you missed.
 
 GOAL: ${goal}
 
 ${others.map((p) => `--- ${p.agent} proposes ---\n${clean(p.text, 1200)}`).join("\n\n")}
-
+${mine ? `\n--- your own proposal ---\n${clean(mine.text, 800)}\n` : ""}
 You have no tools in this step. Do not edit anything.
-Reply in plain text, at most 120 words, with exactly these three sections (1-3 short lines each, name whose proposal you mean):
-FLAWS: bugs, broken contracts, wrong assumptions, tasks that would collide
-MISSING: requirements, tests, edge cases or pieces nobody planned
-NEXT: what should be built first, or what to decide before work starts`;
+Reply in plain text, at most 160 words, with exactly these three sections. Start every ADOPT and FLAW line with the agent it is about (${others.map((p) => p.agent).join(", ")}):
+ADOPT: 1-3 lines "- <agent>: what they got right that you missed"
+FLAW: 1-3 lines "- <agent>: what they got wrong and why — a concrete break (a name mismatch, two tasks in one file, a missed requirement)"
+REVISED: your updated position, 3-6 lines`;
 }
 /** First meaningful line of a section ("ARCHITECTURE:", "FLAWS:") for a one-line summary. */
 export function headline(text, section) {
@@ -114,79 +122,255 @@ export function headline(text, section) {
     }
     return pick(lines.find(Boolean) ?? "");
 }
-async function round(members, name, promptFor, cap, o) {
-    o.onEvent?.({ type: "round", round: name, agents: members.map((m) => m.id) });
-    return Promise.all(members.map(async (m) => {
-        const t0 = Date.now();
-        // The time box is ours too, not only the adapter's: a call that ignores it still can't hold up the run.
-        let timer;
-        const late = new Promise((r) => {
-            timer = setTimeout(() => r({ ok: false, text: "", late: true }), o.timeoutMs + 2000);
-        });
-        let res;
-        try {
-            res = await Promise.race([o.ask(m, promptFor(m), o.cwd, { timeoutMs: o.timeoutMs, signal: o.signal }), late]);
-        }
-        catch (e) {
-            res = { ok: false, text: String(e?.message ?? e) };
+/**
+ * The lines under each SECTION header, header-line remainder included. Real
+ * models dress headers up: "ADOPT:", "ADOPTS", "**Adopt:**", "## ADOPT",
+ * "1. ADOPT:", "ADOPTED IDEAS:" — all count. `ids` are agent ids, so a
+ * "CODEX: …" line is content, not a new section.
+ */
+function sections(text, names, ids = []) {
+    const out = Object.fromEntries(names.map((n) => [n, []]));
+    const alias = (w) => names.find((n) => w === n || w === n + "S" || w === n + "ED" || (n === "REVISED" && /^REVISIONS?$/.test(w)));
+    let cur = null;
+    for (const raw of text.split("\n")) {
+        // Strip markdown emphasis and heading marks, but keep a "#" inside an id (claude#2).
+        const line = raw.replace(/[*`]|__/g, "").replace(/^\s*#+\s*/, "").trim();
+        const head = /^([-•]\s*)?(?:\d+[.)]\s*)?([A-Za-z]+)((?:\s+[A-Za-z]+){0,2})\s*(?:(:)\s*(.*))?$/.exec(line);
+        const word = head?.[2].toUpperCase() ?? "";
+        const isId = !!head && !head[3] && ids.some((i) => i.toUpperCase() === word);
+        // With a colon, "ADOPT:" / "Adopted ideas:"; without one only a bare word ("ADOPT"), so "- revised the schema" stays content.
+        const name = head && !isId && (head[4] || (!head[1] && !head[3])) ? alias(word) : undefined;
+        if (head && name) {
+            cur = name;
+            if (head[5]?.trim())
+                out[name].push(head[5].trim());
+            continue;
         }
-        finally {
-            clearTimeout(timer);
+        // Another all-caps section (MISSING:, NEXT:) ends this one.
+        if (head && head[4] && !isId && !head[1] && /^[A-Z]{3,}$/.test(head[2] + head[3].replace(/\s+/g, "")))
+            cur = null;
+        else if (cur && line)
+            out[cur].push(line);
+    }
+    return out;
+}
+/**
+ * ADOPT / FLAW lines from a cross-review, each tied to the teammate it is
+ * about: "- codex: …" (or a line naming one teammate). A line about yourself
+ * or nobody is dropped — credit has to point at someone else.
+ */
+export function parseReview(text, me, others) {
+    const s = sections(text, ["ADOPT", "FLAW", "REVISED"], [me, ...others]);
+    const target = (line) => {
+        const body = line.replace(/^[-•*\d.)\s]+/, "").trim();
+        if (!body || /^(none|nothing|n\/a)\b/i.test(body))
+            return null;
+        const lead = /^@?([\w#./-]+?)(?:'s)?\s*(?:[:—–]|\s-\s)\s*(.+)$/.exec(body);
+        if (lead) {
+            const of = others.find((o) => o.toLowerCase() === lead[1].toLowerCase());
+            if (of)
+                return { of, text: lead[2].trim() };
         }
-        const ms = Date.now() - t0;
+        const named = others.filter((o) => new RegExp(`(^|[^\\w#/-])${o.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}($|[^\\w#/-])`, "i").test(body));
+        return named.length === 1 ? { of: named[0], text: body } : null;
+    };
+    const points = (lines) => lines
+        .map(target)
+        .filter((x) => !!x && x.of !== me)
+        .slice(0, 4)
+        .map((x) => ({ by: me, of: x.of, text: clean(x.text, 300) }));
+    return { adopts: points(s.ADOPT), flaws: points(s.FLAW), revised: clean(s.REVISED.join("\n"), 600) };
+}
+/** Run a call under our own time box too: a call that ignores its timeout still can't hold up the run. */
+async function boxed(call, timeoutMs) {
+    const t0 = Date.now();
+    let timer;
+    const late = new Promise((r) => {
+        timer = setTimeout(() => r({ ok: false, text: "", late: true }), timeoutMs + 2000);
+    });
+    try {
+        return { res: await Promise.race([call(), late]), ms: Date.now() - t0 };
+    }
+    catch (e) {
+        return { res: { ok: false, text: String(e?.message ?? e) }, ms: Date.now() - t0 };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function round(members, name, promptFor, cap, o, parse) {
+    o.onEvent?.({ type: "round", round: name, agents: members.map((m) => m.id) });
+    return Promise.all(members.map(async (m) => {
+        const { res, ms } = await boxed(() => o.ask(m, promptFor(m), o.cwd, { timeoutMs: o.timeoutMs, signal: o.signal }), o.timeoutMs);
         const text = res.ok ? clean(res.text, cap) : "";
         const entry = text
-            ? { agent: m.id, round: name, ok: true, text, ms }
+            ? { agent: m.id, round: name, ok: true, text, ms, ...(parse ? parse(m, res.text) : {}) }
             : { agent: m.id, round: name, ok: false, text: "", ms, skipped: res.late || ms >= o.timeoutMs ? "timed out" : "no answer" };
         o.onEvent?.({ type: "entry", entry });
         return entry;
     }));
 }
-/** The council's material for the brain, compact. */
-function councilNotes(proposals, critiques) {
+/** Who earned ADOPTs from whom (only from OTHERS — you can't adopt your own idea). */
+export function adoptTally(critiques) {
+    const out = {};
+    for (const c of critiques)
+        for (const a of c.adopts ?? [])
+            if (a.of !== a.by)
+                out[a.of] = [...new Set([...(out[a.of] ?? []), a.by])];
+    return out;
+}
+/** Total ADOPT points and FLAW points each proposer received from OTHERS (tie-breaks for who writes the plan). */
+export function reviewTally(critiques) {
+    const adopts = {};
+    const flaws = {};
+    for (const c of critiques) {
+        for (const a of c.adopts ?? [])
+            if (a.of !== a.by)
+                adopts[a.of] = (adopts[a.of] ?? 0) + 1;
+        for (const f of c.flaws ?? [])
+            if (f.of !== f.by)
+                flaws[f.of] = (flaws[f.of] ?? 0) + 1;
+    }
+    return { adopts, flaws };
+}
+/**
+ * Who writes the plan: the proposer whose ideas the most teammates ADOPTed.
+ * Ties, in order: more ADOPT points in all, fewer FLAWs found in its
+ * proposal, fewest plans synthesized so far, then roster order. Found live
+ * (capstone round 4): all three were adopted by 2 teammates, the tie fell
+ * through to roster order and claude wrote the plan although codex's ideas
+ * were adopted 4 times to claude's 2.
+ * null = nobody adopted anything: no signal, so the brain writes it.
+ */
+export function pickSynthesizer(candidates, adopted, past = {}, tally = {}) {
+    const score = (id) => adopted[id]?.length ?? 0;
+    const best = Math.max(0, ...candidates.map(score));
+    if (!best)
+        return null;
+    const top = candidates.filter((c) => score(c) === best);
+    const total = (id) => tally.adopts?.[id] ?? score(id);
+    const flaws = (id) => tally.flaws?.[id] ?? 0;
+    const plans = (id) => past[id] ?? 0;
+    // Each tie-break in turn, as [value, larger wins?, how the reason says it].
+    const breaks = [
+        [total, true, (v) => `won on most adoptions in all (${v})`],
+        [flaws, false, (v) => `won on fewest flaws found in its proposal (${v})`],
+        [plans, false, () => "won on fewest plans written so far"],
+    ];
+    let field = top;
+    let won = "first on the roster";
+    for (const [f, more, say] of breaks) {
+        if (field.length < 2)
+            break;
+        const v = more ? Math.max(...field.map(f)) : Math.min(...field.map(f));
+        const next = field.filter((c) => f(c) === v);
+        if (next.length < field.length)
+            won = say(v);
+        field = next;
+    }
+    const id = field[0];
+    const tie = top.length > 1 ? `; tied with ${top.filter((c) => c !== id).join(", ")}, ${won}` : "";
+    return { id, why: `most ideas adopted by teammates (${best}: ${adopted[id].join(", ")})${tie}` };
+}
+/** The council's material for the synthesizer, compact. */
+function councilNotes(proposals, critiques, adopted) {
     const parts = [`DESIGN COUNCIL — proposals (each agent planned independently):`];
     for (const p of proposals)
         parts.push(`--- ${p.agent} ---\n${p.text}`);
     if (critiques.length) {
-        parts.push(`DESIGN COUNCIL — critiques (each agent read the others' proposals):`);
+        parts.push(`DESIGN COUNCIL — cross-reviews (each agent read the others' proposals: ADOPT = what it took from a teammate, FLAW = what it found wrong):`);
         for (const c of critiques)
             parts.push(`--- ${c.agent} ---\n${c.text}`);
     }
+    const tally = Object.entries(adopted).map(([a, by]) => `${a} (by ${by.join(", ")})`);
+    if (tally.length)
+        parts.push(`ADOPTED IDEAS: ${tally.join("; ")}. Build on these; fix every FLAW.`);
     return parts.join("\n\n");
 }
-/** decisions / risks from the synthesis reply (the tasks come from parsePlan). */
-function parseExtras(text, members) {
+/** The first JSON body in a reply that holds a tasks array. */
+function planJson(text) {
     for (const body of jsonCandidates(text)) {
-        let raw;
         try {
-            raw = JSON.parse(body);
+            const raw = JSON.parse(body);
+            if (Array.isArray(raw?.tasks))
+                return raw;
         }
         catch {
-            continue;
+            /* next candidate */
         }
-        if (!Array.isArray(raw?.tasks))
-            continue;
-        const decisions = (Array.isArray(raw.decisions) ? raw.decisions : []).map((d) => clean(String(d ?? ""), 300)).filter(Boolean).slice(0, 6);
-        const risks = (Array.isArray(raw.risks) ? raw.risks : [])
-            .map((r) => {
-            const body = clean(String(typeof r === "string" ? r : r?.risk ?? r?.body ?? ""), 300);
-            const by = typeof r === "object" && members.includes(String(r?.by)) ? String(r.by) : undefined;
-            return body ? { body, ...(by ? { by } : {}) } : null;
-        })
-            .filter(Boolean)
-            .slice(0, 6);
-        return { decisions, risks };
     }
-    return { decisions: [], risks: [] };
+    return null;
+}
+/** decisions / risks / contract from the synthesis reply (the tasks come from parsePlan). */
+function parseExtras(text, members) {
+    const raw = planJson(text);
+    if (!raw)
+        return { decisions: [], risks: [], contract: "", objections: [] };
+    const decisions = (Array.isArray(raw.decisions) ? raw.decisions : []).map((d) => clean(String(d ?? ""), 300)).filter(Boolean).slice(0, 6);
+    const risks = (Array.isArray(raw.risks) ? raw.risks : [])
+        .map((r) => {
+        const body = clean(String(typeof r === "string" ? r : r?.risk ?? r?.body ?? ""), 300);
+        const by = typeof r === "object" ? members.find((m) => m.toLowerCase() === String(r?.by ?? "").trim().toLowerCase()) : undefined;
+        return body ? { body, ...(by ? { by } : {}) } : null;
+    })
+        .filter(Boolean)
+        .slice(0, 6);
+    // A model may hand back the contract as an object; keep it readable either way.
+    const c = raw.contract;
+    const contract = typeof c === "string" ? c : c && typeof c === "object" ? JSON.stringify(c, null, 1) : "";
+    return { decisions, risks, contract: capContract(clean(contract, 100_000)), objections: Array.isArray(raw.objections) ? raw.objections : [] };
+}
+function ratifyPrompt(goal, me, by, tasks, contract) {
+    return `You are ${me.id}, on Huddle's design council. ${by} wrote the plan below from everyone's proposals. Before anyone codes, check its CONTRACT: the exact names every task will code to.
+
+GOAL: ${goal}
+
+TASKS:
+${tasks.map((t, i) => `${i}. ${t.title}${t.files?.length ? ` (${t.files.join(", ")})` : ""}`).join("\n")}
+
+CONTRACT:
+${contract}
+
+You have no tools in this step. Do not edit anything.
+Reply with ONLY "OK", or up to 3 lines "OBJECT: <one concrete change>". Object only to what would break a task: a missing or mismatched name, a wrong signature, two tasks owning one file, a requirement no task covers, or a name, message or format that differs from what the GOAL states exactly (e.g. a new error message for a case the goal already gives one).`;
+}
+/** OK / OBJECT: … → a verdict. Anything else is unclear, which never blocks the plan. */
+export function parseRatify(text) {
+    const lines = text.split("\n").map((l) => l.replace(/[*`_]/g, "").trim());
+    const objections = lines
+        // "OBJECT: x", "OBJECTION - x", "I object: x" — models vary the punctuation.
+        .map((l) => /^[-•\d.)\s]*(?:I\s+)?OBJECT(?:ION)?S?\s*(?::|\s[-—–])\s*(.+)$/i.exec(l)?.[1]?.trim())
+        .filter((x) => !!x && !/^(none|nothing)\b/i.test(x))
+        .slice(0, 3)
+        .map((x) => clean(x, 400));
+    if (objections.length)
+        return { verdict: "object", objections };
+    return { verdict: lines.some((l) => /^[-•\s]*(OK|APPROVED?|LGTM|NO OBJECTIONS?)\b/i.test(l)) ? "ok" : "unclear", objections: [] };
+}
+function revisionPrompt(goal, objections, planText) {
+    return `You wrote this plan for Huddle's design council. Before work starts, teammates object to it:
+${objections.map((o) => `- ${o.by}: ${o.objection}`).join("\n")}
+
+GOAL: ${goal}
+
+YOUR PLAN:
+${planText}
+
+Apply each objection that is right and reject the others. You have no tools in this step.
+Reply with ONLY the full revised JSON in the same shape (tasks, decisions, risks, contract, plain, example), plus "objections":[{"by":"agent id","taken":true,"why":"short"}] — one entry per objection above. No prose, no code fences.`;
 }
 /**
- * Brainstorm with every member, then have the brain write the plan. Falls
- * back to today's single-brain planner whenever the council can't help (no
- * proposals came back, or the synthesis wasn't a plan), so it never blocks a run.
+ * Brainstorm with every member, cross-review, then have the most-adopted
+ * agent (or the brain) write the plan and its contract, and the others ratify
+ * it. Falls back to today's single-brain planner whenever the council can't
+ * help (no proposals came back, or no synthesis was a plan), so it never blocks a run.
  */
 export async function runCouncil(goal, crew, members, repoRoot, opts) {
     const t0 = Date.now();
     const timeoutMs = opts.timeoutMs ?? councilTimeoutMs();
+    // Ratifying is "OK" or up to 3 objections: it never needs a design's time box. Found live
+    // (0.1.2): the whole team waited 2 minutes on one agent's ratify that then timed out.
+    const ratifyMs = Math.min(timeoutMs, (Number(process.env.HUDDLE_RATIFY_TIMEOUT_S) || 75) * 1000);
     const ro = { ask: opts.ask ?? defaultAsk, cwd: repoRoot, timeoutMs, signal: opts.signal, onEvent: opts.onEvent };
     const context = repoContext(repoRoot, 150);
     const ids = members.map((m) => m.id);
@@ -205,70 +389,233 @@ export async function runCouncil(goal, crew, members, repoRoot, opts) {
     };
     if (!good.length || opts.signal?.aborted)
         return fallback([], "council: no proposals came back");
-    // A critique needs someone else's proposal to read.
+    // A cross-review needs someone else's proposal to read.
     const critics = good.length >= 2 ? members.filter((m) => good.some((p) => p.agent === m.id)) : [];
+    const proposers = good.map((p) => p.agent);
     const critiques = critics.length
-        ? await round(critics, "critique", (m) => critiquePrompt(goal, m, good.filter((p) => p.agent !== m.id)), CRITIQUE_CAP, ro)
+        ? await round(critics, "critique", (m) => critiquePrompt(goal, m, good.filter((p) => p.agent !== m.id), good.find((p) => p.agent === m.id)), CRITIQUE_CAP, ro, (m, text) => parseReview(text, m.id, proposers.filter((p) => p !== m.id)))
         : [];
     const heard = critiques.filter((c) => c.ok);
-    if (!opts.brain || opts.signal?.aborted)
-        return fallback(critiques, "council: no brain to synthesize");
-    opts.onEvent?.({ type: "synthesizing", brain: opts.brain.label });
+    const adopted = adoptTally(heard);
+    if (opts.signal?.aborted)
+        return fallback(critiques, "council: stopped");
     const speaking = [...new Set([...good, ...heard].map((e) => e.agent))];
-    const prompt = plannerPrompt(goal, crew, context, { notes: councilNotes(good, heard), members: speaking });
-    const res = await opts.brain.think(prompt, repoRoot, {
-        signal: opts.signal,
-        timeoutMs: synthTimeoutMs(opts.brain),
-        json: true,
-        selfContained: true,
-    });
-    const tasks = res.ok ? parsePlan(res.text) : null;
-    if (!tasks)
-        return fallback(critiques, `council: ${opts.brain.label} didn't synthesize a plan`);
-    const extras = parseExtras(res.text, speaking);
-    const by = members.length ? speaking.join(", ") : "";
+    const prompt = plannerPrompt(goal, crew, context, { notes: councilNotes(good, heard, adopted), members: speaking });
+    // The synthesizers to try, in order: the most-adopted agent, then the brain.
+    const synths = [];
+    const hung = new Set(); // a synthesizer that ran out its box isn't asked to ratify (it would hang again)
+    const pick = pickSynthesizer(proposers, adopted, opts.pastSyntheses, reviewTally(heard));
+    const agentSynth = pick && members.find((m) => m.id === pick.id);
+    if (pick && agentSynth) {
+        const box = opts.synthTimeoutMs ?? 5 * 60_000;
+        synths.push({
+            id: pick.id,
+            kind: "agent",
+            why: pick.why,
+            run: async (p) => {
+                const { res, ms } = await boxed(() => ro.ask(agentSynth, p, repoRoot, { timeoutMs: box, signal: opts.signal, quick: false }), box);
+                if (res.late || ms >= box)
+                    hung.add(agentSynth.id);
+                return res;
+            },
+        });
+    }
+    const brain = opts.brain;
+    if (brain)
+        synths.push({
+            id: brain.label,
+            kind: "brain",
+            why: pick ? `${pick.id} didn't write a usable plan` : "no idea was adopted by a teammate, so the brain writes it",
+            run: (p) => brain.think(p, repoRoot, { signal: opts.signal, timeoutMs: synthTimeoutMs(brain), json: true, selfContained: true }),
+        });
+    if (!synths.length)
+        return fallback(critiques, "council: no brain to synthesize");
+    let synth = null;
+    let synthText = "";
+    let tasks = null;
+    let tokens;
+    const missed = [];
+    for (const s of synths) {
+        if (opts.signal?.aborted)
+            break;
+        opts.onEvent?.({ type: "synthesizing", brain: s.id, why: s.why });
+        const res = await s.run(prompt);
+        tasks = res.ok ? parsePlan(res.text) : null;
+        if (tasks) {
+            synth = s;
+            synthText = res.text;
+            tokens = res.tokens;
+            break;
+        }
+        missed.push(s.id);
+    }
+    if (!synth || !tasks)
+        return fallback(critiques, `council: ${missed.join(", then ") || "nobody"} didn't synthesize a plan`);
+    let extras = parseExtras(synthText, speaking);
+    let plain = parsePlain(synthText);
+    // Ratify: everyone else on the council checks the contract once, in parallel.
+    // The brain's own CLI doesn't ratify the brain's plan (it would grade itself).
+    const ratify = [];
+    const objections = [];
+    const brainCli = brain?.spec.split(":")[0];
+    const ratifiers = members.filter((m) => proposers.includes(m.id) && m.id !== synth.id && !hung.has(m.id) && !(synth.kind === "brain" && m.adapter.id === brainCli));
+    if (extras.contract && ratifiers.length && !opts.signal?.aborted) {
+        opts.onEvent?.({ type: "ratify", by: synth.id, agents: ratifiers.map((m) => m.id) });
+        const verdicts = await Promise.all(ratifiers.map(async (m) => {
+            const { res, ms } = await boxed(() => ro.ask(m, ratifyPrompt(goal, m, synth.id, tasks, extras.contract), repoRoot, { timeoutMs: ratifyMs, signal: opts.signal }), ratifyMs);
+            const e = res.ok && res.text.trim()
+                ? { agent: m.id, ...parseRatify(res.text), ms }
+                : { agent: m.id, verdict: "skipped", objections: [], ms, skipped: res.late || ms >= ratifyMs ? "timed out" : "no answer" };
+            opts.onEvent?.({ type: "ratified", entry: e });
+            return e;
+        }));
+        ratify.push(...verdicts);
+        const raised = verdicts.flatMap((v) => v.objections.map((objection) => ({ by: v.agent, objection })));
+        if (raised.length && !opts.signal?.aborted) {
+            // One revision by the synthesizer, never a loop.
+            const res = await synth.run(revisionPrompt(goal, raised, planJson(synthText) ? JSON.stringify(planJson(synthText)) : synthText));
+            const revised = res.ok ? parsePlan(res.text) : null;
+            if (revised) {
+                const next = parseExtras(res.text, speaking);
+                const said = next.objections.filter((x) => x && typeof x === "object");
+                const seenBy = {};
+                for (const o of raised) {
+                    // The synthesizer's answer to this objection: one quoting it, else the nth answer to the nth objection by that agent.
+                    const nth = (seenBy[o.by] = (seenBy[o.by] ?? -1) + 1);
+                    const mine = said.filter((x) => String(x.by ?? "").toLowerCase() === o.by.toLowerCase());
+                    const s = mine.find((x) => x.objection && String(x.objection).includes(o.objection.slice(0, 20))) ?? mine[nth];
+                    // No word on it: count it taken only if the contract actually changed.
+                    const taken = s ? s.taken === true || s.taken === "true" : next.contract !== extras.contract;
+                    objections.push({ ...o, taken, ...(s?.why ? { why: clean(String(s.why), 200) } : {}) });
+                }
+                // A revision that drops the idea credit keeps the first plan's, task by task (same title).
+                tasks = revised.map((t) => (t.from?.length ? t : { ...t, ...(tasks.find((x) => x.title === t.title)?.from ? { from: tasks.find((x) => x.title === t.title).from } : {}) }));
+                if (res.tokens)
+                    tokens = (tokens ?? 0) + res.tokens;
+                extras = { ...next, contract: next.contract || extras.contract };
+                plain = parsePlain(res.text) ?? plain;
+            }
+            else
+                for (const o of raised)
+                    objections.push({ ...o, taken: false, why: `${synth.id} didn't revise the plan` });
+            opts.onEvent?.({ type: "revised", by: synth.id, ok: !!revised, taken: objections.filter((o) => o.taken).length, rejected: objections.filter((o) => !o.taken).length });
+        }
+    }
+    const by = speaking.join(", ");
     const attributed = tasks.map((t) => {
-        const from = (t.from ?? []).filter((f) => speaking.includes(f));
-        const credit = from.length ? `proposed by ${from.join(", ")} in Huddle's design council (${by})` : `planned by Huddle's design council (${by})`;
+        // ONE primary idea author (first in `from`), plus contributors.
+        // Ids as the members spell them: a model may write "Codex" for codex.
+        const from = [...new Set((t.from ?? []).map((f) => speaking.find((x) => x.toLowerCase() === f.trim().toLowerCase())).filter((f) => !!f))];
+        const credit = from.length
+            ? `idea from ${from[0]}${from.length > 1 ? ` (with ${from.slice(1).join(", ")})` : ""} in Huddle's design council (${by})`
+            : `planned by Huddle's design council (${by})`;
         return {
             ...t,
             from,
+            ...(from.length ? { primary: from[0] } : {}),
             spec: `${t.spec}\n\nDesign: ${credit}. Its decisions and risks are in shared memory — huddle_recall "council" before you start.`,
         };
     });
+    // The goal's exact requirements ride in every spec, and any string no spec carried gets an owner (goal.ts).
+    const carried = carryGoal(goal, attributed, extras.contract);
     return {
-        tasks: attributed,
-        by: `council (${by}) → ${opts.brain.label}`,
+        tasks: carried.tasks,
+        by: `council (${by}) → ${synth.id}`,
+        goalCheck: carried.check,
+        ...(carried.check.missing.length ? { note: goalNote(carried.check) } : {}),
         ms: Date.now() - t0,
-        tokens: res.tokens,
-        council: result({ proposals, critiques, synthesizedBy: opts.brain.label, ...extras }),
+        tokens,
+        ...(plain ? { plain } : {}),
+        council: result({
+            proposals,
+            critiques,
+            synthesizedBy: synth.id,
+            synthesizer: { id: synth.id, kind: synth.kind, why: synth.why },
+            adoptedFrom: adopted,
+            contract: extras.contract,
+            ratify,
+            objections,
+            decisions: extras.decisions,
+            risks: extras.risks,
+            goalCheck: carried.check,
+        }),
     };
 }
+/** One line for the plan: how many of the goal's exact strings the plan had dropped, and who owns them now. */
+export function goalNote(c) {
+    const owners = Object.keys(c.carried);
+    return `goal check: ${c.missing.length}/${c.atoms} exact string(s) were in no spec or the contract — carried verbatim to ${owners.length ? owners.map((t) => `"${t}"`).join(", ") : "the specs"}`;
+}
 /**
  * Put the council in the Room once the board exists: every proposal and
- * critique as an event, the plan with who-proposed-what, and the decisions
- * and risks in shared memory so agents can huddle_recall them mid-task.
+ * cross-review as an event (and each ADOPT / FLAW, so `huddle story` shows who
+ * took what from whom), the ratify verdicts, the plan with who-proposed-what,
+ * the contract, and the decisions and risks in shared memory so agents can
+ * huddle_recall them mid-task.
  */
 export function recordCouncil(db, council, tasks, taskIds) {
     for (const e of [...council.proposals, ...council.critiques]) {
         const type = e.ok ? `council.${e.round}` : "council.skipped";
-        db.publish(type, { agent_id: e.agent, payload: { agent: e.agent, round: e.round, text: e.text, ms: e.ms, ...(e.skipped ? { reason: e.skipped } : {}) } });
+        db.publish(type, {
+            agent_id: e.agent,
+            payload: {
+                agent: e.agent,
+                round: e.round,
+                text: e.text,
+                ms: e.ms,
+                ...(e.skipped ? { reason: e.skipped } : {}),
+                ...(e.adopts?.length ? { adopts: e.adopts.map((a) => ({ of: a.of, text: a.text })) } : {}),
+                ...(e.flaws?.length ? { flaws: e.flaws.map((a) => ({ of: a.of, text: a.text })) } : {}),
+            },
+        });
+        for (const a of e.adopts ?? [])
+            db.publish("council.adopt", { agent_id: a.by, payload: { agent: a.by, of: a.of, body: a.text } });
+        for (const f of e.flaws ?? [])
+            db.publish("council.flaw", { agent_id: f.by, payload: { agent: f.by, of: f.of, body: f.text } });
+    }
+    for (const r of council.ratify ?? []) {
+        if (r.verdict === "skipped")
+            db.publish("council.skipped", { agent_id: r.agent, payload: { agent: r.agent, round: "ratify", ms: r.ms, reason: r.skipped ?? "no answer" } });
+        else
+            db.publish("council.ratify", { agent_id: r.agent, payload: { agent: r.agent, verdict: r.verdict, objections: r.objections, ms: r.ms } });
     }
     db.publish("council.plan", {
         agent_id: "council",
         payload: {
             members: council.members,
             by: council.synthesizedBy,
+            ...(council.synthesizer ? { synthesizer: council.synthesizer } : {}),
             ms: council.ms,
-            tasks: tasks.map((t, i) => ({ id: taskIds[i] ?? null, title: t.title, from: t.from ?? [] })),
+            tasks: tasks.map((t, i) => ({ id: taskIds[i] ?? null, title: t.title, from: t.from ?? [], primary: t.primary ?? t.from?.[0] ?? null })),
             decisions: council.decisions,
             risks: council.risks,
+            ...(council.adoptedFrom ? { adopted: council.adoptedFrom } : {}),
+            ...(council.objections?.length ? { objections: council.objections } : {}),
+            contract_chars: council.contract?.length ?? 0,
+            ...(council.goalCheck ? { goal_check: { atoms: council.goalCheck.atoms, missing: council.goalCheck.missing.slice(0, 40), carried: council.goalCheck.carried } } : {}),
         },
     });
+    if (council.contract)
+        setContract(db, council.contract, council.synthesizer?.id ?? council.synthesizedBy);
     const who = council.members.join(", ");
     for (const d of council.decisions)
         db.remember({ kind: "decision", body: `council: ${d}`, why: `agreed by the design council (${who}) before work started`, author: "council" });
     for (const r of council.risks)
         db.remember({ kind: "gotcha", body: `council risk: ${r.body}`, why: r.by ? `flagged by ${r.by} in the design council` : "flagged in the design council", author: "council" });
 }
+/** How many plans each agent synthesized in earlier runs in this Room (for rotation ties). */
+export function pastSyntheses(db) {
+    const out = {};
+    for (const e of db.eventsOfType(["council.plan"], 0, 500)) {
+        try {
+            const s = JSON.parse(e.payload || "{}").synthesizer;
+            if (s?.kind === "agent" && s.id)
+                out[s.id] = (out[s.id] ?? 0) + 1;
+        }
+        catch {
+            /* an old or odd event */
+        }
+    }
+    return out;
+}
 //# sourceMappingURL=council.js.map