huddle-cli 0.0.0-stage → 0.1.0

package/dist/orchestrator/council.js

@@ -0,0 +1,274 @@
+// The design council: for a big goal, every ready agent brainstorms before
+// anyone writes code — not just the brain. Three 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
+//
+// 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 { 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 });
+const PROPOSAL_CAP = 1500;
+const CRITIQUE_CAP = 900;
+/** 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) {
+    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.
+
+GOAL: ${goal}
+
+${others.map((p) => `--- ${p.agent} proposes ---\n${clean(p.text, 1200)}`).join("\n\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`;
+}
+/** 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) ?? "");
+}
+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) };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const ms = Date.now() - t0;
+        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: 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) {
+    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):`);
+        for (const c of critiques)
+            parts.push(`--- ${c.agent} ---\n${c.text}`);
+    }
+    return parts.join("\n\n");
+}
+/** decisions / risks from the synthesis reply (the tasks come from parsePlan). */
+function parseExtras(text, members) {
+    for (const body of jsonCandidates(text)) {
+        let raw;
+        try {
+            raw = JSON.parse(body);
+        }
+        catch {
+            continue;
+        }
+        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: [] };
+}
+/**
+ * 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.
+ */
+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 critique needs someone else's proposal to read.
+    const critics = good.length >= 2 ? members.filter((m) => good.some((p) => p.agent === m.id)) : [];
+    const critiques = critics.length
+        ? await round(critics, "critique", (m) => critiquePrompt(goal, m, good.filter((p) => p.agent !== m.id)), CRITIQUE_CAP, ro)
+        : [];
+    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 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 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})`;
+        return {
+            ...t,
+            from,
+            spec: `${t.spec}\n\nDesign: ${credit}. Its decisions and risks are in shared memory — huddle_recall "council" before you start.`,
+        };
+    });
+    return {
+        tasks: attributed,
+        by: `council (${by}) → ${opts.brain.label}`,
+        ms: Date.now() - t0,
+        tokens: res.tokens,
+        council: result({ proposals, critiques, synthesizedBy: opts.brain.label, ...extras }),
+    };
+}
+/**
+ * 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.
+ */
+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("council.plan", {
+        agent_id: "council",
+        payload: {
+            members: council.members,
+            by: council.synthesizedBy,
+            ms: council.ms,
+            tasks: tasks.map((t, i) => ({ id: taskIds[i] ?? null, title: t.title, from: t.from ?? [] })),
+            decisions: council.decisions,
+            risks: council.risks,
+        },
+    });
+    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" });
+}
+//# sourceMappingURL=council.js.map

package/dist/orchestrator/handoff.js

@@ -0,0 +1,117 @@
+// Handoffs: when a task merges, the agents whose tasks depended on it start
+// with a compact brief from the author — what changed, the exact signatures it
+// exports, and the notes it left — instead of rediscovering it from the code.
+//
+// Captured right after the merge lands (base = main before the fast-forward),
+// stored in the Room, and injected into each dependent's launch prompt.
+import { execFileSync } from "node:child_process";
+const MAX_FILES = 30;
+const MAX_SYMBOLS = 25;
+const MAX_NOTES = 8;
+function git(cwd, args) {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 32 * 1024 * 1024 }).trim();
+}
+export function headSha(repoRoot) {
+    try {
+        return git(repoRoot, ["rev-parse", "HEAD"]);
+    }
+    catch {
+        return null;
+    }
+}
+// Lines that declare something other code can use. Deliberately simple: the
+// signature line is what a dependent needs, not a parse tree.
+const DECL = [
+    /^\s*export\s+(default\s+)?(declare\s+)?(async\s+)?(function\*?|class|interface|type|enum|const|let|var|abstract\s+class)\s+[\w$]+/, // TS / JS
+    /^\s*export\s*\{[^}]+\}/, // export { a, b }
+    /^module\.exports\b|^exports\.[\w$]+\s*=/, // CommonJS
+    /^(async\s+)?def\s+[A-Za-z]\w*\s*\(|^class\s+[A-Za-z]\w*/, // Python (top level, public)
+    /^func\s+(\([^)]*\)\s*)?[A-Z]\w*\s*\(|^type\s+[A-Z]\w*\s/, // Go (exported)
+    /^\s*pub\s+(async\s+)?(fn|struct|enum|trait|type|const|mod)\s+\w+/, // Rust
+];
+/** Exported signature lines added by a unified diff. */
+export function exportedSymbols(diff) {
+    const out = [];
+    let file = "";
+    for (const line of diff.split("\n")) {
+        if (line.startsWith("+++ ")) {
+            file = line.replace(/^\+\+\+ (b\/)?/, "");
+            continue;
+        }
+        if (!line.startsWith("+") || line.startsWith("+++"))
+            continue;
+        const src = line.slice(1);
+        if (!DECL.some((r) => r.test(src)))
+            continue;
+        const sig = src.trim().replace(/\s*[{=]>?\s*$/, "").replace(/\s+/g, " ").slice(0, 160);
+        const entry = `${file}: ${sig}`;
+        if (!out.includes(entry))
+            out.push(entry);
+        if (out.length >= MAX_SYMBOLS)
+            break;
+    }
+    return out;
+}
+/** What a merge changed on main: name-status lines and exported signatures. */
+export function captureChanges(repoRoot, base) {
+    try {
+        const files = git(repoRoot, ["diff", "--name-status", "--no-renames", base, "HEAD"])
+            .split("\n")
+            .filter(Boolean)
+            .map((l) => l.replace(/\t/, " "))
+            .slice(0, MAX_FILES);
+        const diff = git(repoRoot, ["diff", "--unified=0", "--no-color", base, "HEAD"]);
+        return { files, symbols: exportedSymbols(diff) };
+    }
+    catch {
+        return { files: [], symbols: [] };
+    }
+}
+/** Record the handoff for a just-merged task (base = main before it landed). */
+export function recordHandoff(db, repoRoot, opts) {
+    const { files, symbols } = opts.base ? captureChanges(repoRoot, opts.base) : { files: [], symbols: [] };
+    // The author's own notes from this task (its "Task … done" line is the summary).
+    const notes = db
+        .recall()
+        .filter((m) => m.author === opts.agentId && m.created_at >= opts.since && !m.body.startsWith(`Task ${opts.taskId} done:`))
+        .reverse()
+        .slice(0, MAX_NOTES)
+        .map((m) => `${m.kind}: ${m.body}${m.why ? ` (why: ${m.why})` : ""}`.slice(0, 400));
+    return db.saveHandoff({ task_id: opts.taskId, agent_id: opts.agentId, title: opts.title, files, symbols, notes });
+}
+export function handoffText(h) {
+    const lines = [`— from ${h.agent_id}, task "${h.title}" (${h.task_id}), merged into main:`];
+    if (h.summary)
+        lines.push(`  summary: ${h.summary}`);
+    if (h.files.length)
+        lines.push(`  files: ${h.files.join(", ")}`);
+    if (h.symbols.length) {
+        lines.push("  exports (use these exact names/signatures):");
+        for (const s of h.symbols)
+            lines.push(`    ${s}`);
+    }
+    if (h.notes.length) {
+        lines.push("  notes:");
+        for (const n of h.notes)
+            lines.push(`    - ${n}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * The handoff block for a task's launch prompt: one entry per merged
+ * dependency that has one. Empty string when there's nothing to hand off.
+ */
+export function handoffsFor(db, taskId) {
+    const task = db.getTask(taskId);
+    if (!task)
+        return { text: "", from: [] };
+    const deps = JSON.parse(task.depends_on || "[]");
+    const from = deps.map((d) => db.getHandoff(d)).filter((h) => !!h);
+    if (!from.length)
+        return { text: "", from };
+    return {
+        text: `\n\nHANDOFF — the tasks yours depends on are merged; their work is already in your directory:\n${from.map(handoffText).join("\n")}`,
+        from,
+    };
+}
+//# sourceMappingURL=handoff.js.map

package/dist/orchestrator/launcher.js

@@ -0,0 +1,155 @@
+// The launcher: for a scheduled task, it (1) makes the agent's sandbox worktree,
+// (2) hands the agent the Plug (MCP) in whatever way its vendor expects,
+// (3) spawns the agent CLI non-interactively with a prompt that tells it to use
+// the Room. Output goes to .huddle/logs/, not the user's terminal — the Huddle
+// screen shows progress from Room events instead.
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createWorktree, worktreeFor } from "../sandbox/worktree.js";
+import { UsageMeter } from "../adapters/usage.js";
+const CHECKIN = `
+You are collaborating with other AI agents in a shared repo via the "huddle" MCP tools.
+RULES:
+1. Call huddle_recall() and huddle_board() BEFORE you start — inherit context, don't re-derive it.
+2. Your task below is already claimed for you — don't claim it again.
+3. Call huddle_announce_plan() with the files/symbols you'll touch BEFORE editing. If huddle_check_overlap flags a teammate, coordinate via huddle_remember instead of colliding.
+   Your task's file list is a plan, not a fence: if the work needs another file (e.g. a test wants your module registered in an index),
+   announce it and make the edit — Huddle lands same-file edits from different agents safely. Never finish with failing tests
+   because a file wasn't on your list; Huddle's merge gate runs the full test suite and rejects red work.
+4. Call huddle_progress() after each meaningful step.
+5. Record decisions with huddle_remember(kind="decision", ..., why=...) so teammates learn WHY.
+   Unsure about a shape or contract another task owns? huddle_ask("…", to="<agent>") before guessing — teammates may be on other machines.
+   Changing something a teammate relies on? Tell them: huddle_send(to="<agent>" or "all", message="…").
+   If a tool result shows unread_messages, call huddle_inbox() and answer questions with huddle_send(reply_to=…).
+   A teammate offers help and part of your task is separable? huddle_split it to them instead of doing it all yourself.
+   A HANDOFF section below (if any) is what the tasks you depend on built — use those exact names.
+6. Do the work by editing files in your current directory. Don't commit — Huddle tests and merges for you.
+7. When finished, call huddle_done(task_id, summary).
+`.trim();
+// dist/orchestrator/launcher.js -> dist/cli.js
+const CLI_PATH = fileURLToPath(new URL("../cli.js", import.meta.url));
+function modelFor(adapter, role) {
+    return role === "orchestrator"
+        ? adapter.models.orchestrator
+        : role === "fast"
+            ? adapter.models.fast
+            : role === "reviewer"
+                ? adapter.models.reviewer
+                : adapter.models.worker;
+}
+/**
+ * Launch `agentId` (an instance of `adapter`) on a task. `dryRun` returns the
+ * exact command without creating a worktree or spawning anything.
+ */
+export function launchAgent(opts) {
+    const { repoRoot, adapter, agentId, role, taskId, taskSpec, roomUrl } = opts;
+    const wt = opts.worktree ?? (opts.dryRun ? worktreeFor(repoRoot, agentId, taskId) : createWorktree(repoRoot, agentId, taskId));
+    const slug = `${agentId}-${taskId}`.replace(/[^\w.-]/g, "_");
+    const runDir = path.join(repoRoot, ".huddle", "run", slug);
+    const logPath = path.join(repoRoot, ".huddle", "logs", `${slug}.log`);
+    const plug = {
+        command: process.execPath,
+        args: [CLI_PATH, "plug"],
+        env: { HUDDLE_ROOM_URL: roomUrl, HUDDLE_AGENT_ID: agentId, HUDDLE_SECRET: opts.roomSecret ?? "" },
+    };
+    let mcpConfigPath = null;
+    const excludes = [];
+    if (adapter.plug.file && adapter.plug.entry) {
+        const inWorktree = adapter.plug.file.in === "worktree";
+        mcpConfigPath = path.join(inWorktree ? wt.path : runDir, adapter.plug.file.path);
+        if (inWorktree)
+            excludes.push(adapter.plug.file.path);
+        if (!opts.dryRun)
+            writeJsonMerged(mcpConfigPath, adapter.plug.entry(plug));
+    }
+    const prompt = `${CHECKIN}\n\nYOUR TASK (task_id: ${taskId}): ${taskSpec}`;
+    const { cmd, cwd, env } = adapter.launch({
+        worktree: wt.path,
+        prompt,
+        model: modelFor(adapter, role),
+        mcpConfigPath,
+        plug,
+        approvals: opts.approvals,
+    });
+    const handle = {
+        agentId,
+        taskId,
+        worktree: wt.path,
+        branch: wt.branch,
+        cmd,
+        logPath,
+        excludes,
+        startedAt: Date.now(),
+        meter: new UsageMeter(),
+    };
+    if (opts.dryRun)
+        return handle;
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    const log = fs.createWriteStream(logPath, { flags: "a" });
+    handle.child = spawn(cmd[0], cmd.slice(1), {
+        cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, ...env, ...plug.env },
+    });
+    // Everything still goes to the log; stdout is also scanned for token usage.
+    let partial = "";
+    handle.child.stdout.on("data", (chunk) => {
+        log.write(chunk);
+        if (!adapter.usage)
+            return;
+        const lines = (partial + chunk.toString("utf8")).split("\n");
+        partial = lines.pop() ?? "";
+        let changed = false;
+        for (const line of lines) {
+            const r = adapter.usage(line.trim());
+            if (r) {
+                handle.meter.add(r);
+                changed = true;
+            }
+        }
+        if (changed)
+            opts.onTokens?.(handle.meter.tokens);
+    });
+    handle.child.stderr.on("data", (chunk) => log.write(chunk));
+    handle.child.on("exit", () => log.end());
+    return handle;
+}
+/**
+ * Stop an agent's process: SIGTERM, then SIGKILL if it is still alive after
+ * `graceMs`. Found live on the capstone: a cursor-agent QA check whose
+ * connection stalled ignored SIGTERM, so QA's 15-minute time box did nothing
+ * and the run hung for 65 more minutes.
+ */
+export function stopChild(child, graceMs = 5000) {
+    if (!child || child.exitCode !== null || child.signalCode !== null)
+        return;
+    child.kill("SIGTERM");
+    setTimeout(() => {
+        if (child.exitCode === null && child.signalCode === null)
+            child.kill("SIGKILL");
+    }, graceMs).unref();
+}
+// --- tiny helpers ---------------------------------------------------------
+function writeJsonMerged(file, entry) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    let existing = {};
+    if (fs.existsSync(file)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(file, "utf8"));
+        }
+        catch {
+            /* overwrite malformed */
+        }
+    }
+    fs.writeFileSync(file, JSON.stringify(deepMerge(existing, entry), null, 2));
+}
+function deepMerge(a, b) {
+    const out = { ...a };
+    for (const [k, v] of Object.entries(b)) {
+        out[k] = v && typeof v === "object" && !Array.isArray(v) ? deepMerge(a[k] ?? {}, v) : v;
+    }
+    return out;
+}
+//# sourceMappingURL=launcher.js.map