huddle-cli 0.0.0-stage → 0.1.1

package/dist/orchestrator/council.js

@@ -0,0 +1,615 @@
+// The design council: for a big goal, every ready agent brainstorms before
+// 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. 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 { carryGoal } from "./goal.js";
+import { goalSize, jsonCandidates, listsOwnTasks, 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 = 1200;
+/** Default per-call time box; HUDDLE_COUNCIL_TIMEOUT_S overrides. */
+export function councilTimeoutMs() {
+    const s = Number(process.env.HUDDLE_COUNCIL_TIMEOUT_S);
+    return Number.isFinite(s) && s > 0 ? s * 1000 : 120_000;
+}
+/**
+ * The synthesis time box. A council only runs for big goals, whose plan is
+ * long (10+ self-contained specs): 2 minutes, the small-goal planner's box,
+ * can cut it off half-written, and the fallback then plans the big goal alone.
+ */
+export function synthTimeoutMs(brain) {
+    return brain.spec.startsWith("ollama") ? 6 * 60_000 : 5 * 60_000;
+}
+/** The agents that sit on the council: one seat per CLI (claude#2 thinks like claude), and only those that can answer. */
+export function councilMembers(workers) {
+    const seen = new Set();
+    const out = [];
+    for (const w of workers) {
+        if (!w.adapter?.ask || seen.has(w.adapter.id))
+            continue;
+        seen.add(w.adapter.id);
+        out.push({ id: w.id, adapter: w.adapter });
+    }
+    return out;
+}
+/**
+ * Should this goal get a design council? `flag` is --council (true) /
+ * --no-council (false). Without a flag, only big goals do: a from-scratch
+ * project, a long spec, or a real goal in a (nearly) empty repo — and not when
+ * the goal already spells out its own tasks.
+ */
+export function councilWanted(goal, o) {
+    if (o.flag === false)
+        return { yes: false, why: "--no-council" };
+    if (o.members < 2)
+        return { yes: false, why: "needs 2+ agents that can answer" };
+    if (o.flag === true)
+        return { yes: true, why: "--council" };
+    // A goal that already spells out its tasks needs no brainstorm, even a big one.
+    if (listsOwnTasks(goal))
+        return { yes: false, why: "the goal already lists its tasks" };
+    const size = goalSize(goal, { repoFiles: o.repoFiles });
+    return { yes: size.big, why: size.why };
+}
+/** Strip escape codes and cap; a council answer is advice, not a novel. */
+function clean(text, cap) {
+    // eslint-disable-next-line no-control-regex
+    const t = text.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").replace(/\n{3,}/g, "\n\n").trim();
+    return t.length <= cap ? t : t.slice(0, cap - 1).replace(/\s+\S*$/, "") + "…";
+}
+function crewLine(members) {
+    return members.map((m) => `${m.id} (good at: ${m.adapter.prefers.join(", ") || "anything"})`).join("; ");
+}
+function proposalPrompt(goal, me, members, context) {
+    return `You are ${me.id}, on Huddle's design council: several AI coding agents (${members.map((m) => m.id).join(", ")}) each sketch a plan for the goal below before anyone writes code. Then the agents critique each other's sketches, and one plan is made from the best ideas. Each task will run in its own git worktree in parallel.
+
+GOAL: ${goal}
+
+CREW: ${crewLine(members)}
+
+REPO SNAPSHOT:
+${context}
+
+You have no tools in this step and cannot read files: the snapshot above is everything. Do not edit anything.
+Reply in plain text, at most 200 words, with exactly these four sections:
+ARCHITECTURE: one or two sentences — the shape of the solution (modules, layers, data flow)
+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, 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 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) {
+    const lines = text.split("\n").map((l) => l.replace(/[*#`_]/g, "").trim());
+    const i = lines.findIndex((l) => l.toUpperCase().startsWith(section.toUpperCase() + ":") || l.toUpperCase() === section.toUpperCase());
+    const pick = (l) => l.replace(/^[-•\d.)\s]+/, "").trim();
+    if (i >= 0) {
+        const rest = pick(lines[i].slice(section.length + 1));
+        if (rest)
+            return rest;
+        const next = lines.slice(i + 1).find((l) => l && !/^[A-Z ]+:/.test(l));
+        if (next)
+            return pick(next);
+    }
+    return pick(lines.find(Boolean) ?? "");
+}
+/**
+ * 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;
+        }
+        // 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 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, ...(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;
+    }));
+}
+/** 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 — 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");
+}
+/** The first JSON body in a reply that holds a tasks array. */
+function planJson(text) {
+    for (const body of jsonCandidates(text)) {
+        try {
+            const raw = JSON.parse(body);
+            if (Array.isArray(raw?.tasks))
+                return raw;
+        }
+        catch {
+            /* next candidate */
+        }
+    }
+    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), plus "objections":[{"by":"agent id","taken":true,"why":"short"}] — one entry per objection above. No prose, no code fences.`;
+}
+/**
+ * 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();
+    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);
+    const result = (extra) => ({
+        members: ids,
+        decisions: [],
+        risks: [],
+        ms: Date.now() - t0,
+        ...extra,
+    });
+    const proposals = await round(members, "proposal", (m) => proposalPrompt(goal, m, members, context), PROPOSAL_CAP, ro);
+    const good = proposals.filter((p) => p.ok);
+    const fallback = async (critiques, why) => {
+        const plan = await planGoal(goal, crew, repoRoot, { brain: opts.brain, signal: opts.signal, project: true });
+        return { ...plan, note: [why, plan.note].filter(Boolean).join("; "), council: result({ proposals, critiques, synthesizedBy: `${plan.by} (${why})` }) };
+    };
+    if (!good.length || opts.signal?.aborted)
+        return fallback([], "council: no proposals came back");
+    // 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), 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);
+    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, 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);
+    // 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, signal: opts.signal }), timeoutMs);
+            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 >= timeoutMs ? "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 };
+            }
+            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) => {
+        // 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: carried.tasks,
+        by: `council (${by}) → ${synth.id}`,
+        goalCheck: carried.check,
+        ...(carried.check.missing.length ? { note: goalNote(carried.check) } : {}),
+        ms: Date.now() - t0,
+        tokens,
+        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
+ * 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 } : {}),
+                ...(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 ?? [], 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