huddle-cli 0.1.1 → 0.1.5

package/dist/ui/transcript.js

@@ -0,0 +1,434 @@
+// An agent's own session, as a readable transcript: what it said, what it
+// thought (when the CLI shows it), every tool call with its arguments in short,
+// and what came back — trimmed. `huddle export --level full` puts one of these
+// under each task of a run.
+//
+// The logs are whatever the agent CLI printed (.huddle/logs/<agent>-<task>.log,
+// src/orchestrator/launcher.ts):
+//   claude  --output-format stream-json   assistant/user messages, tool_use ↔ tool_result
+//   codex   exec --json                   item.started / item.completed (agent_message,
+//                                         command_execution, mcp_tool_call, file_change, …)
+//   cursor  --output-format stream-json   assistant text, thinking deltas, tool_call
+//                                         started/completed (shellToolCall, readToolCall, …)
+// amp and qwen speak Claude's shape. Anything else — another CLI, a log cut
+// short, a format that changed — is kept as plain text, never dropped.
+import fs from "node:fs";
+/** One tool result keeps this much; the rest is cut with a note saying how much. */
+export const OUTPUT_MAX = { chars: 2_000, lines: 40 };
+/** Arguments, summarized, keep this much. */
+const INPUT_MAX = 600;
+/** The launch prompt (long and the same for every task) keeps this much. */
+const PROMPT_MAX = 3_000;
+/** A raw (unparsed) log keeps this much. */
+export const RAW_MAX = 200_000;
+/** Logs bigger than this are read from the start only. */
+const READ_MAX = 32 * 1024 * 1024;
+/** Cut text to `chars` and `lines`, saying what was cut. */
+export function cap(text, max = OUTPUT_MAX) {
+    let t = text.replace(/\s+$/, "");
+    const lines = t.split("\n");
+    let cut = "";
+    if (lines.length > max.lines) {
+        t = lines.slice(0, max.lines).join("\n");
+        cut = `${lines.length - max.lines} more line${lines.length - max.lines === 1 ? "" : "s"}`;
+    }
+    if (t.length > max.chars) {
+        const more = text.length - max.chars;
+        t = t.slice(0, max.chars);
+        cut = `${more.toLocaleString("en-US")} more characters`;
+    }
+    return cut ? `${t}\n… [cut: ${cut} — the whole output is in the agent's log]` : t;
+}
+const one = (s, n = INPUT_MAX) => {
+    const l = s.replace(/\s+/g, " ").trim();
+    return l.length <= n ? l : l.slice(0, n - 1) + "…";
+};
+const str = (v) => (v === undefined || v === null ? "" : typeof v === "string" ? v : JSON.stringify(v));
+/**
+ * Absolute worktree paths → repo-relative ones. Every tool call names
+ * /…/repo/.huddle/worktrees/claude-aCN9HG/src/csv.js; a reader wants src/csv.js.
+ */
+export function relPaths(s) {
+    return s.replace(CD_WT, "").replace(WT_SLASH, "").replace(WT, ".");
+}
+const WT_SRC = String.raw `[^\s"'\`]*?\.huddle[\\/]worktrees[\\/][^\\/\s"'\`]+`;
+const CD_WT = new RegExp(String.raw `cd\s+(["']?)` + WT_SRC + String.raw `\1\s*(?:&&|;|\n)\s*`, "g");
+const WT_SLASH = new RegExp(WT_SRC + String.raw `[\\/]`, "g");
+const WT = new RegExp(WT_SRC, "g");
+const tidy = (s) => relPaths(s);
+/** "mcp__huddle__huddle_send" / "huddle-huddle_send" → "huddle_send". */
+const toolName = (n) => n.replace(/^mcp__[^_]+(?:_[^_]+)*?__/, "").replace(/^huddle-/, "");
+/** A tool's arguments in a line: the command, the path, the message — not the JSON. */
+export function summarizeInput(tool, input) {
+    const a = (input && typeof input === "object" ? input : {});
+    const t = toolName(tool).toLowerCase();
+    if (typeof input === "string")
+        return tidy(one(input));
+    // A command keeps its lines (a heredoc is a file being written), capped like an output.
+    if (a.command !== undefined)
+        return tidy(cap(Array.isArray(a.command) ? a.command.join(" ") : str(a.command), { chars: 1_500, lines: 30 }));
+    const file = a.file_path ?? a.path ?? a.notebook_path ?? a.targetFile;
+    if (/^(write|create)/.test(t) && file)
+        return `${tidy(str(file))} (${str(a.content ?? a.contents ?? a.streamContent).split("\n").length} lines)`;
+    if (/edit/.test(t) && file)
+        return tidy(str(file));
+    if (file && Object.keys(a).length <= 3)
+        return tidy(`${str(file)}${a.offset || a.limit ? ` (from line ${a.offset ?? 1}${a.limit ? `, ${a.limit} lines` : ""})` : ""}`);
+    if (a.pattern !== undefined || a.globPattern !== undefined)
+        return tidy(one(`${str(a.pattern ?? a.globPattern)}${a.path || a.targetDirectory ? " in " + str(a.path ?? a.targetDirectory) : ""}`));
+    // Huddle's own tools: who it's to and what it says — the conversation, in the agent's words.
+    if (a.to !== undefined && (a.message !== undefined || a.body !== undefined))
+        return one(`to ${str(a.to)}: ${str(a.message ?? a.body)}`, 2_000);
+    if (a.question !== undefined)
+        return one(`${a.to ? "to " + str(a.to) + ": " : ""}${str(a.question)}`, 2_000);
+    const keys = Object.keys(a);
+    if (!keys.length)
+        return "";
+    return tidy(one(keys.map((k) => `${k}: ${typeof a[k] === "string" ? a[k] : JSON.stringify(a[k])}`).join(" · ")));
+}
+/** Text out of an MCP / Claude tool result: strings, [{type:"text", text}], {content:[…]}. */
+function resultText(v) {
+    if (v === undefined || v === null)
+        return "";
+    if (typeof v === "string")
+        return v;
+    if (Array.isArray(v))
+        return v
+            .map((x) => (typeof x === "string" ? x : x?.type === "text" || typeof x?.text === "string" ? str(x.text) : typeof x?.text?.text === "string" ? x.text.text : x?.type === "tool_reference" ? `(loaded ${toolName(str(x.tool_name))})` : x?.type === "image" ? "(an image)" : JSON.stringify(x)))
+            .join("\n");
+    if (typeof v === "object") {
+        const o = v;
+        if (o.content !== undefined)
+            return resultText(o.content);
+        if (o.text !== undefined)
+            return resultText(o.text);
+        if (o.output !== undefined)
+            return resultText(o.output);
+        return JSON.stringify(o, null, 1);
+    }
+    return String(v);
+}
+function json(line) {
+    const l = line.trim();
+    if (!l.startsWith("{"))
+        return undefined;
+    try {
+        return JSON.parse(l);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Which CLI wrote this log, from its lines (the agent's id is only a hint: custom ids exist). */
+export function sniffFormat(lines, hint = "") {
+    let claude = 0;
+    let codex = 0;
+    let cursor = 0;
+    for (const l of lines.slice(0, 400)) {
+        const e = json(l);
+        if (!e || typeof e !== "object")
+            continue;
+        if (/^(thread\.started|turn\.(started|completed|failed)|item\.(started|updated|completed))$/.test(str(e.type)))
+            codex++;
+        else if (e.type === "tool_call" || (e.type === "thinking" && e.subtype) || e.model_call_id || e.timestamp_ms)
+            cursor++;
+        else if ((e.type === "assistant" || e.type === "user") && e.message && Array.isArray(e.message.content) && (e.message.id || e.parent_tool_use_id !== undefined || e.uuid))
+            claude++;
+        else if (e.type === "system" && e.subtype === "init" && Array.isArray(e.tools))
+            claude++;
+        else if (e.type === "assistant" || e.type === "user" || e.type === "result")
+            claude += 0.5;
+    }
+    const best = Math.max(claude, codex, cursor);
+    if (!best)
+        return "raw";
+    const h = hint.split("#")[0];
+    if (h === "cursor" && cursor === best)
+        return "cursor";
+    if (h === "codex" && codex === best)
+        return "codex";
+    return codex === best ? "codex" : cursor === best ? "cursor" : "claude";
+}
+/** Consecutive non-JSON lines (stderr, a banner) as one note. */
+function notes(lines, into) {
+    const t = lines.join("\n").trim();
+    if (t)
+        into.push({ kind: "note", text: cap(tidy(t), { chars: 1_000, lines: 15 }) });
+    lines.length = 0;
+}
+function parseClaude(lines) {
+    const turns = [];
+    const calls = new Map();
+    const loose = [];
+    for (const line of lines) {
+        const e = json(line);
+        if (!e) {
+            if (line.trim())
+                loose.push(line);
+            continue;
+        }
+        notes(loose, turns);
+        if (e.type === "assistant" && Array.isArray(e.message?.content)) {
+            for (const c of e.message.content) {
+                if (c?.type === "text" && str(c.text).trim())
+                    turns.push({ kind: "text", text: str(c.text).trim() });
+                else if (c?.type === "thinking" && str(c.thinking).trim())
+                    turns.push({ kind: "thinking", text: str(c.thinking).trim() });
+                else if (c?.type === "tool_use") {
+                    const name = toolName(str(c.name));
+                    const t = { kind: "tool", tool: name, text: "", input: summarizeInput(str(c.name), c.input) };
+                    // What it wrote: a Write's content, an Edit's change — trimmed like an output.
+                    const i = c.input ?? {};
+                    if (/^(Write|create_file)$/i.test(name) && typeof i.content === "string")
+                        t.output = cap(i.content);
+                    else if (/Edit$/i.test(name) && (typeof i.old_string === "string" || typeof i.new_string === "string"))
+                        t.output = cap(`${str(i.old_string).split("\n").map((l) => "- " + l).join("\n")}\n${str(i.new_string).split("\n").map((l) => "+ " + l).join("\n")}`);
+                    else if (/MultiEdit$/i.test(name) && Array.isArray(i.edits))
+                        t.output = cap(`${i.edits.length} edit(s)`);
+                    t.text = `${name}${t.input ? " " + t.input : ""}`;
+                    if (typeof i.description === "string" && i.description.trim())
+                        t.about = one(i.description, 200);
+                    turns.push(t);
+                    if (c.id)
+                        calls.set(str(c.id), t);
+                }
+            }
+        }
+        else if (e.type === "user" && e.message) {
+            const content = Array.isArray(e.message.content) ? e.message.content : [{ type: "text", text: str(e.message.content) }];
+            for (const c of content) {
+                if (c?.type === "tool_result") {
+                    const t = calls.get(str(c.tool_use_id));
+                    const out = tidy(resultText(c.content));
+                    const wrote = t?.output;
+                    if (t) {
+                        t.error = c.is_error === true || undefined;
+                        // A Write's result ("File created successfully…") says less than what it wrote.
+                        if (!wrote || t.error)
+                            t.output = cap(out);
+                    }
+                    else
+                        turns.push({ kind: "tool", tool: "?", text: "(result of an earlier call)", output: cap(out), ...(c.is_error ? { error: true } : {}) });
+                }
+                else if (c?.type === "text" && str(c.text).trim())
+                    turns.push({ kind: turns.length ? "note" : "prompt", text: cap(tidy(str(c.text)), { chars: PROMPT_MAX, lines: 80 }) });
+            }
+        }
+        else if (e.type === "result") {
+            const bits = [e.subtype && e.subtype !== "success" ? str(e.subtype) : "finished", e.duration_ms ? `${Math.round(Number(e.duration_ms) / 1000)}s` : "", e.num_turns ? `${e.num_turns} turns` : "", e.is_error ? "with an error" : ""];
+            turns.push({ kind: "end", text: bits.filter(Boolean).join(" · ") });
+        }
+        else if (e.type === "system" && e.subtype === "init") {
+            turns.push({ kind: "note", text: `session started${e.model ? " · " + str(e.model) : ""}` });
+        }
+        // hook_*, thinking_tokens, rate_limit_event, tool_progress: plumbing.
+    }
+    notes(loose, turns);
+    return turns;
+}
+function parseCodex(lines) {
+    const turns = [];
+    const loose = [];
+    for (const line of lines) {
+        const e = json(line);
+        if (!e) {
+            // "Reading additional input from stdin..." is codex reading its prompt: noise.
+            if (line.trim() && !/^Reading (additional )?(input|prompt) from stdin/i.test(line.trim()))
+                loose.push(line);
+            continue;
+        }
+        notes(loose, turns);
+        if (e.type === "item.completed" && e.item) {
+            const it = e.item;
+            switch (it.type) {
+                case "agent_message":
+                case "assistant_message":
+                    if (str(it.text).trim())
+                        turns.push({ kind: "text", text: str(it.text).trim() });
+                    break;
+                case "reasoning":
+                    if (str(it.text ?? it.summary).trim())
+                        turns.push({ kind: "thinking", text: resultText(it.text ?? it.summary).trim() });
+                    break;
+                case "command_execution": {
+                    const input = tidy(cap(str(it.command).replace(/^\/bin\/(?:ba|z)?sh -lc /, "").replace(/^(["'])([\s\S]*)\1$/, "$2"), { chars: 1_500, lines: 30 }));
+                    const code = it.exit_code;
+                    turns.push({ kind: "tool", tool: "shell", text: `shell ${input}`, input, output: cap(tidy(str(it.aggregated_output))) + (typeof code === "number" && code !== 0 ? `\n(exit ${code})` : ""), ...(typeof code === "number" && code !== 0 ? { error: true } : {}) });
+                    break;
+                }
+                case "mcp_tool_call": {
+                    const name = toolName(str(it.tool));
+                    const input = summarizeInput(name, it.arguments);
+                    const err = it.error ? resultText(it.error.message ?? it.error) : "";
+                    turns.push({ kind: "tool", tool: name, text: `${name}${input ? " " + input : ""}`, input, output: cap(tidy(err || resultText(it.result))), ...(err || it.status === "failed" ? { error: true } : {}) });
+                    break;
+                }
+                case "file_change": {
+                    const ch = Array.isArray(it.changes) ? it.changes : [];
+                    const input = ch.map((c) => `${str(c.kind) || "edit"} ${tidy(str(c.path))}`).join(", ");
+                    turns.push({ kind: "tool", tool: "edit", text: `edit ${input}`, input, ...(it.status === "failed" ? { error: true } : {}) });
+                    break;
+                }
+                case "web_search":
+                    turns.push({ kind: "tool", tool: "web_search", text: `web_search ${one(str(it.query))}`, input: one(str(it.query)) });
+                    break;
+                case "todo_list":
+                    turns.push({ kind: "note", text: `plan: ${(Array.isArray(it.items) ? it.items : []).map((x) => `${x.completed ? "✓" : "○"} ${str(x.text)}`).join(" · ")}` });
+                    break;
+                case "error":
+                    turns.push({ kind: "note", text: `error: ${str(it.message)}` });
+                    break;
+                default:
+                    turns.push({ kind: "note", text: `[${str(it.type)}] ${one(JSON.stringify(it), 400)}` });
+            }
+        }
+        else if (e.type === "turn.completed") {
+            const u = e.usage ?? {};
+            const tok = (Number(u.input_tokens) || 0) + (Number(u.output_tokens) || 0);
+            turns.push({ kind: "end", text: `turn finished${tok ? ` · ${tok.toLocaleString("en-US")} tokens` : ""}` });
+        }
+        else if (e.type === "turn.failed" || e.type === "error") {
+            turns.push({ kind: "note", text: `error: ${str(e.error?.message ?? e.message ?? e.error)}` });
+        }
+    }
+    notes(loose, turns);
+    return turns;
+}
+/** cursor-agent's tool_call: { <name>ToolCall: { args, result: { success | failure } } }. */
+function cursorTool(tc) {
+    const key = Object.keys(tc).find((k) => /ToolCall$/.test(k)) ?? Object.keys(tc)[0] ?? "tool";
+    const body = tc[key] ?? {};
+    const args = body.args ?? {};
+    let name = key.replace(/ToolCall$/, "");
+    let input;
+    if (name === "mcp") {
+        name = toolName(str(args.toolName ?? args.name));
+        input = summarizeInput(name, args.args);
+    }
+    else if (name === "shell")
+        input = tidy(cap(str(args.command), { chars: 1_500, lines: 30 }));
+    else if (name === "edit" || name === "write")
+        input = tidy(str(args.path));
+    else
+        input = summarizeInput(name, args);
+    const r = body.result ?? {};
+    const ok = r.success;
+    const bad = r.failure ?? r.error ?? r.rejected;
+    const res = ok ?? bad;
+    let output = "";
+    if (res && typeof res === "object") {
+        if (name === "shell")
+            output = [str(res.stdout), str(res.stderr)].filter((x) => x.trim()).join("\n") + (res.exitCode ? `\n(exit ${res.exitCode})` : "");
+        else if (name === "edit" || name === "write")
+            output = str(res.diffString) || str(res.message);
+        else if (name === "glob")
+            output = (Array.isArray(res.files) ? res.files : []).join("\n");
+        else if (name === "read")
+            output = str(res.content);
+        else
+            output = resultText(res);
+    }
+    else if (res !== undefined)
+        output = str(res);
+    const error = !!bad || (name === "shell" && Number(res?.exitCode) > 0) || ok?.isError === true;
+    return { kind: "tool", tool: name, text: `${name}${input ? " " + input : ""}`, input, output: cap(tidy(output)), ...(error ? { error: true } : {}) };
+}
+function parseCursor(lines) {
+    const turns = [];
+    const loose = [];
+    let thinking = "";
+    const flush = () => {
+        if (thinking.trim())
+            turns.push({ kind: "thinking", text: thinking.trim() });
+        thinking = "";
+    };
+    for (const line of lines) {
+        const e = json(line);
+        if (!e) {
+            if (line.trim())
+                loose.push(line);
+            continue;
+        }
+        notes(loose, turns);
+        const ts = Number(e.timestamp_ms) || undefined;
+        if (e.type === "thinking") {
+            if (e.subtype === "delta")
+                thinking += str(e.text);
+            else
+                flush();
+            continue;
+        }
+        flush();
+        if (e.type === "assistant") {
+            const text = resultText(e.message?.content).trim();
+            if (text)
+                turns.push({ kind: "text", text, ...(ts ? { ts } : {}) });
+        }
+        else if (e.type === "user") {
+            const text = resultText(e.message?.content).trim();
+            if (text)
+                turns.push({ kind: turns.some((t) => t.kind === "prompt") ? "note" : "prompt", text: cap(tidy(text), { chars: PROMPT_MAX, lines: 80 }) });
+        }
+        else if (e.type === "tool_call" && e.subtype === "completed" && e.tool_call) {
+            turns.push({ ...cursorTool(e.tool_call), ...(ts ? { ts } : {}) });
+        }
+        else if (e.type === "result") {
+            turns.push({ kind: "end", text: [e.is_error ? "finished with an error" : "finished", e.duration_ms ? `${Math.round(Number(e.duration_ms) / 1000)}s` : ""].filter(Boolean).join(" · ") });
+        }
+        else if (e.type === "system" && e.subtype === "init") {
+            turns.push({ kind: "note", text: `session started${e.model ? " · " + str(e.model) : ""}` });
+        }
+    }
+    flush();
+    notes(loose, turns);
+    return turns;
+}
+/** A log's text → turns. Unknown formats are kept as one raw block (capped). */
+export function parseLog(text, agentHint = "") {
+    const lines = text.split(/\r?\n/);
+    const format = sniffFormat(lines, agentHint);
+    try {
+        const turns = format === "claude" ? parseClaude(lines) : format === "codex" ? parseCodex(lines) : format === "cursor" ? parseCursor(lines) : [];
+        if (format !== "raw" && turns.length)
+            return { format, turns };
+    }
+    catch {
+        /* a shape we didn't expect: fall back to the raw text below */
+    }
+    const raw = text.trim();
+    return { format: "raw", turns: raw ? [{ kind: "note", text: cap(tidy(raw), { chars: RAW_MAX, lines: 4_000 }) }] : [] };
+}
+/** Read and parse one log file; null when it isn't there. */
+export function readLog(file, agentHint = "") {
+    let st;
+    try {
+        st = fs.statSync(file);
+    }
+    catch {
+        return null;
+    }
+    if (!st.isFile())
+        return null;
+    let text;
+    let partial = false;
+    if (st.size > READ_MAX) {
+        const fd = fs.openSync(file, "r");
+        try {
+            const buf = Buffer.alloc(READ_MAX);
+            const n = fs.readSync(fd, buf, 0, READ_MAX, 0);
+            text = buf.subarray(0, n).toString("utf8");
+            text = text.slice(0, text.lastIndexOf("\n") + 1);
+            partial = true;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    else
+        text = fs.readFileSync(file, "utf8");
+    const parsed = parseLog(text, agentHint);
+    if (partial)
+        parsed.turns.push({ kind: "note", text: `… the log is ${Math.round(st.size / 1024 / 1024)} MB; only its first ${READ_MAX / 1024 / 1024} MB are shown` });
+    return { ...parsed, bytes: st.size, ...(partial ? { partial } : {}) };
+}
+//# sourceMappingURL=transcript.js.map

package/dist/ui/undo.js

@@ -0,0 +1,131 @@
+// `huddle undo`: take back what a run merged. It adds one commit that reverts
+// the run's commits (history stays; nothing is force-pushed), so an undo can
+// itself be undone with git revert.
+//
+//   huddle undo            the last run (asks first; --yes doesn't)
+//   huddle undo --run 3    that run (numbers from `huddle runs`)
+import fs from "node:fs";
+import readline from "node:readline";
+import { spawnSync } from "node:child_process";
+import { C } from "./term.js";
+import { pickRun, splitRuns } from "./story.js";
+const git = (root, args) => {
+    const r = spawnSync("git", args, { cwd: root, encoding: "utf8" });
+    return { ok: r.status === 0, out: (r.stdout ?? "").trim(), err: (r.stderr ?? "").trim() };
+};
+/** What undoing run `which` would revert, or why it can't. */
+export function undoPlan(root, events, which) {
+    const runs = splitRuns(events);
+    const run = pickRun(runs, which);
+    if (!run)
+        return { ok: false, why: runs.length ? `no run ${which} (see huddle runs)` : "no runs here yet" };
+    const base = { index: run.index, goal: run.goal, id: run.id };
+    // An undo is recorded when it happens, so it lands in whichever run is the
+    // latest by then: look in every run for one that names this run.
+    const undone = runs.some((r) => r.events.some((e) => e.type === "git.undone" && (e.p.id ? e.p.id === run.id : Number(e.p.run) === run.index)));
+    if (undone)
+        return { ...base, ok: false, why: `run ${run.index} is already undone` };
+    const g = run.events.filter((e) => e.type === "git.range").at(-1);
+    if (!g)
+        return { ...base, ok: false, why: `run ${run.index} has no record of its commits (it ran before Huddle 0.1.4, or didn't finish)` };
+    const start = String(g.p.start ?? "");
+    const end = String(g.p.end ?? "");
+    if (!start || !end || start === end)
+        return { ...base, ok: false, why: `run ${run.index} didn't merge anything` };
+    if (!git(root, ["merge-base", "--is-ancestor", end, "HEAD"]).ok)
+        return { ...base, ok: false, why: `run ${run.index}'s commits aren't on this branch (${git(root, ["symbolic-ref", "--short", "HEAD"]).out || "detached HEAD"})` };
+    const commits = git(root, ["log", "--format=%h %s", `${start}..${end}`]).out.split("\n").filter(Boolean);
+    return { ...base, ok: true, start, end, commits };
+}
+/** The run's goal as one short line, for the revert commit and the screen. */
+export const undoTitle = (plan) => String(plan.goal ?? "").split("\n")[0].slice(0, 80);
+/**
+ * Carries out a plan from undoPlan: the revert commit, then the git.undone
+ * event that marks the run undone. `huddle undo` and the dashboard both go
+ * through here, so an undo is recorded the same way wherever you clicked it.
+ */
+export function undoRun(root, db, plan) {
+    if (!plan.ok)
+        return { ok: false, why: plan.why };
+    const goal = undoTitle(plan);
+    const r = revertRange(root, plan.start, plan.end, `huddle: undo run ${plan.index} (${goal})\n\nReverts ${plan.start.slice(0, 7)}..${plan.end.slice(0, 7)}.`);
+    if (!r.ok)
+        return { ok: false, why: r.why };
+    db.publish("git.undone", { payload: { run: plan.index, ...(plan.id ? { id: plan.id } : {}), commit: r.commit } });
+    const up = git(root, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]);
+    const pushed = up.ok && git(root, ["merge-base", "--is-ancestor", plan.end, up.out]).ok;
+    return { ok: true, commit: r.commit, ...(pushed ? { pushedTo: up.out } : {}) };
+}
+/** Reverts start..end as one commit. A conflict (later work built on it) leaves the tree as it was. */
+export function revertRange(root, start, end, message) {
+    const dirty = git(root, ["status", "--porcelain", "--untracked-files=no"]).out;
+    if (dirty)
+        return { ok: false, why: "you have uncommitted changes — commit or stash them first" };
+    const r = git(root, ["revert", "--no-edit", "--no-commit", `${start}..${end}`]);
+    if (!r.ok) {
+        git(root, ["revert", "--abort"]);
+        git(root, ["reset", "--hard", "-q", "HEAD"]);
+        return { ok: false, why: "later commits build on this run's work, so it can't be taken back cleanly — revert by hand: git revert " + `${start.slice(0, 7)}..${end.slice(0, 7)}` };
+    }
+    if (!git(root, ["status", "--porcelain", "--untracked-files=no"]).out) {
+        git(root, ["revert", "--quit"]);
+        return { ok: false, why: "nothing to undo: the run's changes are already gone from this branch" };
+    }
+    const c = git(root, ["commit", "-q", "--no-verify", "-m", message]);
+    if (!c.ok) {
+        git(root, ["revert", "--abort"]);
+        return { ok: false, why: c.err.split("\n")[0] || "git commit failed" };
+    }
+    git(root, ["revert", "--quit"]);
+    return { ok: true, commit: git(root, ["rev-parse", "--short", "HEAD"]).out };
+}
+async function confirm(q) {
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const a = await new Promise((r) => rl.question(q, r));
+    rl.close();
+    return /^y(es)?$/i.test(a.trim());
+}
+export async function runUndo(args) {
+    const { dbPath, repoRoot } = await import("./app.js");
+    if (!fs.existsSync(dbPath())) {
+        console.log(C.faint("  no runs here yet — nothing to undo."));
+        return 0;
+    }
+    const i = args.indexOf("--run");
+    const which = i >= 0 ? args[i + 1] : args.find((a) => /^\d+$/.test(a));
+    const { RoomDB } = await import("../room/db.js");
+    const db = new RoomDB(dbPath());
+    try {
+        const root = repoRoot();
+        const plan = undoPlan(root, db.allEvents(), which);
+        if (!plan.ok) {
+            console.log(C.red("✗ ") + plan.why);
+            return 1;
+        }
+        console.log(`Undo run ${plan.index}: ${C.bold(undoTitle(plan))}`);
+        console.log(C.faint(`  it reverts ${plan.commits.length} commit(s), as one new commit:`));
+        for (const c of plan.commits.slice(0, 12))
+            console.log(C.faint(`    ${c}`));
+        if (plan.commits.length > 12)
+            console.log(C.faint(`    … and ${plan.commits.length - 12} more`));
+        if (!args.includes("--yes") && !args.includes("-y") && !(await confirm("  Undo it? [y/N] "))) {
+            console.log(C.faint(process.stdin.isTTY ? "  left as it is." : "  not a terminal: add --yes to undo."));
+            return process.stdin.isTTY ? 0 : 1;
+        }
+        const r = undoRun(root, db, plan);
+        if (!r.ok) {
+            console.log(C.red("✗ ") + r.why);
+            return 1;
+        }
+        console.log(`${C.green("✓")} undone in ${r.commit}. ${C.faint(`Changed your mind? git revert ${r.commit}`)}`);
+        if (r.pushedTo)
+            console.log(C.faint(`  the run was already pushed to ${r.pushedTo}: git push sends the undo there too`));
+        return 0;
+    }
+    finally {
+        db.close();
+    }
+}
+//# sourceMappingURL=undo.js.map

package/dist/ui/watch.js

@@ -107,6 +107,10 @@ export function activityOf(e) {
                 agent: p.to ?? who,
                 text: `${C.violet("◎")} ${p.kind === "radar" ? "radar finding" : `${p.by}'s buddy note`} ${p.how === "ignored" ? C.yellow("ignored") : C.green(p.how === "replied" ? "answered" : "addressed in code")}: ${clip(p.body, 100)}`,
             };
+        case "run.busy":
+            return { agent: who, text: `${C.faint("⧗ running a long command")} · quiet ${Math.round((Number(p.quietMs) || 0) / 60_000) || "<1"} min, not silent: ${clip(p.why, 80)}` };
+        case "run.budget":
+            return { text: `${C.yellow("! token budget")} ${p.level === "hard" ? "ran over — agents stopped" : "nearly spent — no new work"}${(p.left ?? []).length ? ` · left undone: ${clip((p.left ?? []).join(" · "), 80)}` : ""}` };
         case "run.pair":
             return { agent: who, text: `${C.violet("⇉")} pairs with ${p.with} on “${clip(p.title, 60)}”: ${clip(p.part, 80)}` };
         case "qa.round":

package/dist/update.js

@@ -0,0 +1,84 @@
+// `huddle update`: get the newest Huddle from npm. Found live (0.1.3): the user
+// typed `huddle --update`, the way other CLIs work, and got "unknown command".
+import { fileURLToPath } from "node:url";
+import { packageInfo } from "./preflight.js";
+import { spawnToolSync } from "./platform.js";
+import { C } from "./ui/term.js";
+/** -1, 0 or 1, comparing x.y.z (a pre-release tag sorts before its release). */
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const [core, pre] = v.trim().replace(/^v/, "").split("-", 2);
+        return { nums: core.split(".").map((n) => Number(n) || 0), pre: pre ?? "" };
+    };
+    const x = parse(a);
+    const y = parse(b);
+    for (let i = 0; i < 3; i++) {
+        const d = (x.nums[i] ?? 0) - (y.nums[i] ?? 0);
+        if (d)
+            return Math.sign(d);
+    }
+    if (x.pre === y.pre)
+        return 0;
+    if (!x.pre)
+        return 1;
+    if (!y.pre)
+        return -1;
+    return x.pre < y.pre ? -1 : 1;
+}
+/**
+ * What `huddle update` should do. Only an npm install (a path through
+ * node_modules/huddle-cli) is replaced with npm; a source checkout is told how
+ * to update itself instead of getting a second, global copy.
+ */
+export function updatePlan(current, latest, cliPath) {
+    if (!latest)
+        return { kind: "offline" };
+    const c = compareVersions(current, latest);
+    if (c === 0)
+        return { kind: "latest", current };
+    if (c > 0)
+        return { kind: "ahead", current, latest };
+    if (!/[\\/]node_modules[\\/]huddle-cli[\\/]/.test(cliPath)) {
+        return { kind: "source", current, latest, dir: cliPath.replace(/[\\/]dist[\\/].*$/, "") };
+    }
+    return { kind: "install", current, latest };
+}
+/** The newest huddle-cli on npm, or null when npm can't be reached. */
+export function latestOnNpm() {
+    const r = spawnToolSync(["npm", "view", "huddle-cli", "version", "--prefer-online"], { encoding: "utf8", timeout: 30_000 });
+    const v = r.status === 0 ? r.stdout.trim().split(/\s+/).pop() ?? "" : "";
+    return /^\d+\.\d+\.\d+/.test(v) ? v : null;
+}
+export function runUpdate() {
+    const current = packageInfo().version;
+    console.log(C.faint(`huddle ${current} · checking npm…`));
+    const plan = updatePlan(current, latestOnNpm(), fileURLToPath(import.meta.url));
+    switch (plan.kind) {
+        case "offline":
+            console.log(C.red("✗ couldn't reach npm.") + " Check your connection, or run: npm install -g huddle-cli@latest");
+            return 1;
+        case "latest":
+            console.log(C.green("✓") + ` huddle ${plan.current} is the newest version.`);
+            return 0;
+        case "ahead":
+            console.log(C.green("✓") + ` huddle ${plan.current} is newer than npm's ${plan.latest} (a preview build). Nothing to do.`);
+            return 0;
+        case "source":
+            console.log(`huddle ${plan.latest} is out; this huddle runs from a source checkout (${plan.dir}).`);
+            console.log(C.faint("  update it there: git pull && npm install && npm run build"));
+            return 0;
+        case "install": {
+            console.log(`updating huddle ${plan.current} → ${C.violet(plan.latest)}`);
+            const r = spawnToolSync(["npm", "install", "-g", `huddle-cli@${plan.latest}`], { stdio: "inherit" });
+            if (r.status !== 0) {
+                console.log(C.red("✗ npm couldn't install it.") + ` Try it yourself: npm install -g huddle-cli@${plan.latest}`);
+                if (process.platform !== "win32")
+                    console.log(C.faint("  a permissions error means npm's global folder needs sudo; nvm avoids that"));
+                return 1;
+            }
+            console.log(C.green("✓") + ` huddle ${plan.latest} installed.` + C.faint(" Open a new terminal (or run hash -r) if `huddle --version` still shows the old one."));
+            return 0;
+        }
+    }
+}
+//# sourceMappingURL=update.js.map