kaizen-agent 1.39.0 → 1.40.1

package/cli/board.test.ts

@@ -157,7 +157,7 @@ test("card menu items: appropriate actions and distinct icons across phases", ()
   const menuSnippet = (cards.slice(from, cards.indexOf('el.innerHTML += `<div class="menu-pop"', from)) + "}").replace("const items = [];", "items = [];");
   const a0 = cards.indexOf("const actionOf =");
   const actionOf = cards.slice(a0, cards.indexOf("\n\n", a0));
-  const getItems = new Function("c", "archive", "S", `const ico = ${ico.toString()};\n${actionOf}\nconst store = { S, menuKey: 1 };\nlet k = 1, items = [];\n${menuSnippet}\nreturn items;`);
+  const getItems = new Function("c", "archive", "S", `const ico = ${ico.toString()};\nconst decided = new Set(), answer = () => "";\n${actionOf}\nconst store = { S, menuKey: 1 };\nlet k = 1, items = [];\n${menuSnippet}\nreturn items;`);
 
   // Phase 0: Ideas (idea card)
   const idea = { kind: "idea", status: "idea", column: 0 };

package/cli/pty.test.ts

@@ -49,7 +49,7 @@ test.skipIf(process.platform === "win32")("the board runs the agent in the card:
     expect(r.ok).toBe(true);
     expect(r.pty).toMatch(/^[\w-]+$/);
     const card = ((await (await fetch(at + "/state")).json()) as any).cards.find((c: any) => c.text === "say hello");
-    expect(card.pty).toEqual({ key: r.pty, alive: true });
+    expect(card.pty).toEqual({ key: r.pty, alive: true, asking: false });
 
     // G-01: no Origin, a foreign one, and another local port are all refused.
     const url = `${at}/pty?key=${r.pty}`, up = { upgrade: "websocket", connection: "Upgrade", "sec-websocket-version": "13", "sec-websocket-key": "dGhlIHNhbXBsZSBub25jZQ==" };
@@ -186,3 +186,11 @@ test.skipIf(process.platform === "win32")("the done sweep keeps a session the us
   expect(alive(used)).toBe(true);
   process.kill(used, "SIGTERM");
 });
+
+test("asking: Claude Code and Codex prompts count as a question, ordinary output does not", async () => {
+  const { asking } = await import("./pty.ts");
+  expect(asking("\x1b[1mWould you like to run the following command?\x1b[0m")).toBe(true);
+  expect(asking("What behavior do you want?\r\n\x1b[36m❯ 1. Retry with backoff\x1b[0m\r\n  2. Fail\r\n  4. Type something.")).toBe(true);
+  expect(asking("Do you want to make this edit to cli/pty.ts?")).toBe(true);
+  expect(asking("Reading cli/pty.ts\r\n\x1b[2K✻ Thinking… 1. step one done")).toBe(false);
+});

package/cli/pty.ts

@@ -4,7 +4,7 @@
 // window ends the agent in it. Bun has no pseudo-terminal on Windows.
 import { writeFileSync } from "node:fs";
 
-type Pty = { proc: Bun.Subprocess; out: string[]; size: number; listeners: Set<(d: string | null) => void>; exit: number | null };
+type Pty = { proc: Bun.Subprocess; out: string[]; size: number; listeners: Set<(d: string | null) => void>; exit: number | null; asking: boolean; quiet?: Timer; total: number; since: number; onChange?: () => void };
 
 // What a page attaching late gets replayed. A full-screen tool redraws often, so the
 // tail of its output is enough to rebuild the screen.
@@ -13,21 +13,38 @@ const CAP = 512 * 1024;
 const KEEP_MS = 10 * 60_000;
 
 const ptys = new Map<string, Pty>();
+
+// A question the agent stopped on: Claude Code's and Codex's approval and choice prompts.
+// ponytail: screen-text heuristic, misses a prompt worded otherwise; read agent hooks if that bites.
+const ASK = /Would you like to|Do you want to|[❯›>] ?1\. |Type something|\(y\/n\)|\[y\/N\]|Press enter to/i;
+// Escape sequences out; a cursor move becomes a space so words drawn apart stay apart.
+export const asking = (screen: string) =>
+  ASK.test(screen.replace(/\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()][0-9A-Za-z]/g, " "));
+// How long output stays still before the screen is read for a question.
+const QUIET_MS = 700;
 // Bun gained pseudo-terminals in 1.3.5; an older one spawns without a tty, so it
 // keeps opening terminal windows.
 export const ptySupported = process.platform !== "win32" && typeof (Bun as any).Terminal === "function";
 
 // Starts cmd in a new pseudo-terminal under `key` and returns its PID. pidFile gets
 // that PID, the agent's own, so closeSessions can end it like any launched session.
-// onChange: called when the agent ends, so the board can redraw.
+// onChange: called when the agent ends or starts or stops asking, so the board can redraw.
 export function startPty(key: string, cmd: string[], cwd: string, pidFile?: string, onChange?: () => void): number {
   const dec = new TextDecoder();
-  const p: Pty = { proc: null as unknown as Bun.Subprocess, out: [], size: 0, listeners: new Set(), exit: null };
+  const p: Pty = { proc: null as unknown as Bun.Subprocess, out: [], size: 0, listeners: new Set(), exit: null, asking: false, total: 0, since: 0, onChange };
+  const flag = (v: boolean) => { if (p.asking !== v) { p.asking = v; onChange?.(); } };
   const push = (d: string) => {
     p.out.push(d);
     p.size += d.length;
+    p.total += d.length;
     while (p.size > CAP && p.out.length > 1) p.size -= p.out.shift()!.length;
     for (const f of p.listeners) f(d);
+    clearTimeout(p.quiet);
+    p.quiet = setTimeout(() => {
+      // Only what came after the user's last keystroke: a question already answered may still be in the tail.
+      const n = Math.min(4096, p.total - p.since);
+      flag(p.exit === null && n > 0 && asking(p.out.join("").slice(-n)));
+    }, QUIET_MS);
   };
   p.proc = Bun.spawn(cmd, {
     cwd,
@@ -38,6 +55,8 @@ export function startPty(key: string, cmd: string[], cwd: string, pidFile?: stri
   if (pidFile) writeFileSync(pidFile, String(p.proc.pid));
   p.proc.exited.then((code) => {
     p.exit = code;
+    clearTimeout(p.quiet);
+    p.asking = false;
     for (const f of p.listeners) f(null);
     p.listeners.clear();
     try { p.proc.terminal?.close(); } catch { /* already closed */ }
@@ -60,7 +79,10 @@ export function attachPty(key: string, fn: (d: string | null) => void): (() => v
 
 export function writePty(key: string, d: string) {
   const p = ptys.get(key);
-  if (p && p.exit === null) p.proc.terminal?.write(d);
+  if (!p || p.exit !== null) return;
+  p.since = p.total;
+  if (p.asking) { p.asking = false; p.onChange?.(); }
+  p.proc.terminal?.write(d);
 }
 
 export function resizePty(key: string, cols: number, rows: number) {
@@ -73,7 +95,7 @@ export const ptyKeys = () => [...ptys.keys()];
 
 export const ptyState = (key: string) => {
   const p = ptys.get(key);
-  return p ? { alive: p.exit === null, exit: p.exit } : null;
+  return p ? { alive: p.exit === null, exit: p.exit, asking: p.asking } : null;
 };
 
 // The environment the user's login shell builds: PATH and anything exported in their

package/cli/settings.ts

@@ -98,35 +98,35 @@ export function applyPreset(text: string, preset: PresetName, defaults: string):
 }
 
 const SETTINGS: Setting[] = [
-  { key: "preset", label: "Preset", group: "Preset", values: ["low", "medium", "ultra", "custom"], help: "Sets every row below at once. low: you do it here, step by step. medium: balanced. ultra: hands-off. Change any row and it becomes custom" },
-  { key: "mode", label: "Stop for approval", group: "Approvals", values: ["approve", "auto", "plan-only", "review-only"], help: "approve: pause and ask you at each enabled checkpoint. auto: never pause. plan-only: write the plan and stop. review-only: just audit existing work" },
-  { key: "approvals.plan", label: "Approve the plan first", group: "Approvals", values: ["true", "false"], help: "Show the plan and wait for your OK before anything is built" },
-  { key: "approvals.review", label: "Approve after review", group: "Approvals", values: ["true", "false"], help: "After the review, wait for your OK before the run is called done" },
-  { key: "approvals.each_file", label: "Confirm every file edit", group: "Approvals", values: ["true", "false"], help: "Ask before each individual file change. Maximum control, slowest" },
-  { key: "runner", label: "Stage isolation", group: "Agents", values: ["full", "lite"], help: "full: each stage is a fresh agent, so the reviewer never saw the work (costs more). lite: this one session does every stage, cheaper, reviewer may miss its own mistakes" },
-  { key: "build.executor", label: "Who builds", group: "Agents", values: ["subagent", "inline", "ask"], help: "subagent: a separate agent builds and reports back. inline: this session builds while you watch. ask: choose at the plan approval" },
-  { key: "agent.default", label: "Tool the board launches", group: "Agents", values: ["auto", "claude", "codex", "agy", "opencode", "gemini"], help: "Coding tool opened when you start a run from the board. auto: Claude Code if installed, else the first one found" },
-  { key: "agent.launch", label: "Where the board runs agents", group: "Agents", values: ["card", "terminal"], help: "card: inside the board, in the card's Terminal tab (ends if the board stops). terminal: a new terminal window each launch. Windows always uses terminal" },
-  { key: "subagents.model", label: "Model for stage agents", group: "Agents", values: ["inherit", "opus", "sonnet", "haiku"], help: "Which Claude model the planner, builder and reviewer run on. inherit: same as your main session. Claude Code only" },
-  { key: "subagents.effort", label: "Effort for stage agents", group: "Agents", values: ["inherit", "low", "medium", "high"], help: "How hard the stage agents think. low is faster and cheaper; high finds more. Claude Code only" },
-  { key: "auto_fix.enabled", label: "Fix findings automatically", group: "Auto-fix", values: ["true", "false"], help: "true: findings severe enough get fixed and re-reviewed without asking. false: every finding stops and asks you" },
-  { key: "auto_fix.min_severity", label: "Auto-fix from severity", group: "Auto-fix", values: ["critical", "high", "medium", "low"], help: "The least severe finding still fixed automatically. low fixes everything; critical fixes almost nothing" },
-  { key: "auto_fix.max_iterations", label: "Max fix rounds", group: "Auto-fix", values: ["1", "2", "3", "4", "5"], help: "Fix-then-recheck rounds before leftovers are handed to you. Each round is a full build plus a full review, the priciest knob here" },
-  { key: "git.auto_commit", label: "Commit when done", group: "Git", values: ["false", "true"], help: "Commit the work when a run finishes. Never pushes" },
-  { key: "git.branch_before_implement", label: "Branch before building", group: "Git", values: ["true", "false"], help: "Create a branch before building when you are on the default branch" },
-  { key: "git.worktree_per_run", label: "Branch and folder per run", group: "Git", values: ["true", "false"], help: "Build each run on its own branch in its own git worktree, then land it by pull request. false: every run builds in the project folder" },
-  { key: "track.default", label: "Kind of work", group: "Project", values: ["auto", "software", "writing", "communication", "operations", "research"], help: "Pin what runs in this project are (a docs repo is always writing). auto: the planner infers it per run" },
-  { key: "review.write_memory", label: "Remember lessons", group: "Project", values: ["true", "false"], help: "Let the reviewer save what it learned to .kaizen/memory.md, which every future run reads" },
-  { key: "review.memory_max_lines", label: "Memory size cap", group: "Project", values: ["50", "100", "200", "400"], help: "Lines memory.md may hold before old lessons are pruned. Every run reads it, so bigger costs more" },
-  { key: "state.keep_runs", label: "Runs to keep", group: "Project", values: ["5", "10", "20", "50"], help: "Finished runs kept before the oldest is pruned. Open backlog items are rescued first" },
-  { key: "dictation.model", label: "Dictation model", group: "Board", values: ["tiny", "base", "small", "large-v3-turbo"], help: "Whisper model the web board dictates with, in the browser. tiny ~60 MB rough; base ~165 MB English-leaning; small ~410 MB accurate across languages; large-v3-turbo ~1.5 GB best, needs a capable GPU. Downloaded once on the next mic press" },
-  { key: "sources.every", label: "Gather requests", group: "Board", values: ["off", "1h", "6h", "24h"], help: "How often the board checks your request sources for new requests, into the icebox, while it is running. off: only when you press Gather now" },
-  { key: "sources.agent", label: "Who reads social sources", group: "Board", values: ["ask", "chatgpt", "agent"], help: "Kaizen's browser reads the posts (sign it in with kaizen browser login); this picks who keeps the ones that fit the project. chatgpt: your ChatGPT plan, when you press Gather, no agent needed (connect it from the Icebox). agent: Gather opens your coding tool on /kaizen gather. ask: the Icebox offers to connect ChatGPT. Not connected, Gather always uses your agent" },
-  { key: "sources.model", label: "ChatGPT model for gathering", group: "Board", values: [], text: true, help: "The model your ChatGPT plan gathers with. Connected, this lists the models your plan offers. Empty: the first one it lists" },
-  { key: "sources.effort", label: "ChatGPT effort for gathering", group: "Board", values: ["low", "medium", "high"], help: "How hard the model thinks while gathering. low is fast and spends the least of your plan, and picking requests out of posts needs little more" },
-  { key: "board.projects_dir", label: "Projects folder", group: "Board", values: [], text: true, folder: true, help: `A folder your projects live in, e.g. ${process.platform === "win32" ? join(homedir(), "Projects") : "~/Projects"}. Every folder inside it appears in the board's project list, ready to choose; choosing one sets it up. Empty: only projects kaizen already knows` },
-  { key: "board.open", label: "Open the board in", group: "Board", values: ["browser", "app"], help: "browser: a tab in your default browser. app: a Chrome, Edge or Brave window with no tabs or address bar, like a desktop app; your default browser when none is installed" },
-  { key: "ui.mouse", label: "Enable mouse", group: "Terminal", values: ["false", "true"], help: "Click to select, click again to act. While on, the terminal cannot select text with the mouse" },
+  { key: "preset", label: "Preset", group: "Preset", values: ["low", "medium", "ultra", "custom"], help: "" },
+  { key: "mode", label: "Stop for approval", group: "Approvals", values: ["approve", "auto", "plan-only", "review-only"], help: "" },
+  { key: "approvals.plan", label: "Approve the plan first", group: "Approvals", values: ["true", "false"], help: "" },
+  { key: "approvals.review", label: "Approve after review", group: "Approvals", values: ["true", "false"], help: "" },
+  { key: "approvals.each_file", label: "Confirm every file edit", group: "Approvals", values: ["true", "false"], help: "" },
+  { key: "runner", label: "Stage isolation", group: "Agents", values: ["full", "lite"], help: "full: separate agent per stage. lite: one session" },
+  { key: "build.executor", label: "Who builds", group: "Agents", values: ["subagent", "inline", "ask"], help: "" },
+  { key: "agent.default", label: "Tool the board launches", group: "Agents", values: ["auto", "claude", "codex", "agy", "opencode", "gemini"], help: "" },
+  { key: "agent.launch", label: "Where the board runs agents", group: "Agents", values: ["card", "terminal"], help: "" },
+  { key: "subagents.model", label: "Model for stage agents", group: "Agents", values: ["inherit", "opus", "sonnet", "haiku"], help: "" },
+  { key: "subagents.effort", label: "Effort for stage agents", group: "Agents", values: ["inherit", "low", "medium", "high"], help: "" },
+  { key: "auto_fix.enabled", label: "Fix findings automatically", group: "Auto-fix", values: ["true", "false"], help: "" },
+  { key: "auto_fix.min_severity", label: "Auto-fix from severity", group: "Auto-fix", values: ["critical", "high", "medium", "low"], help: "" },
+  { key: "auto_fix.max_iterations", label: "Max fix rounds", group: "Auto-fix", values: ["1", "2", "3", "4", "5"], help: "" },
+  { key: "git.auto_commit", label: "Commit when done", group: "Git", values: ["false", "true"], help: "Never pushes" },
+  { key: "git.branch_before_implement", label: "Branch before building", group: "Git", values: ["true", "false"], help: "" },
+  { key: "git.worktree_per_run", label: "Branch and folder per run", group: "Git", values: ["true", "false"], help: "" },
+  { key: "track.default", label: "Kind of work", group: "Project", values: ["auto", "software", "writing", "communication", "operations", "research"], help: "" },
+  { key: "review.write_memory", label: "Remember lessons", group: "Project", values: ["true", "false"], help: "" },
+  { key: "review.memory_max_lines", label: "Memory size cap", group: "Project", values: ["50", "100", "200", "400"], help: "" },
+  { key: "state.keep_runs", label: "Runs to keep", group: "Project", values: ["5", "10", "20", "50"], help: "" },
+  { key: "dictation.model", label: "Dictation model", group: "Board", values: ["tiny", "base", "small", "large-v3-turbo"], help: "" },
+  { key: "sources.every", label: "Gather requests", group: "Board", values: ["off", "1h", "6h", "24h"], help: "" },
+  { key: "sources.agent", label: "Who reads social sources", group: "Board", values: ["ask", "chatgpt", "agent"], help: "" },
+  { key: "sources.model", label: "ChatGPT model for gathering", group: "Board", values: [], text: true, help: "Empty: plan default" },
+  { key: "sources.effort", label: "ChatGPT effort for gathering", group: "Board", values: ["low", "medium", "high"], help: "" },
+  { key: "board.projects_dir", label: "Projects folder", group: "Board", values: [], text: true, folder: true, help: "Empty: known projects only" },
+  { key: "board.open", label: "Open the board in", group: "Board", values: ["browser", "app"], help: "" },
+  { key: "ui.mouse", label: "Enable mouse", group: "Terminal", values: ["false", "true"], help: "" },
 ];
 
 // The same rows and the same write the TUI uses, for `kaizen web`'s settings panel:

package/cli/sources.test.ts

@@ -281,7 +281,7 @@ test("hostile content becomes plain icebox items, and promoted, plain open ideas
   for (const l of open()) promote(state, [l.id]);
   const lines = readInbox(state);
   expect(lines.length).toBe(7);
-  expect(lines[0]).toEqual({ status: "started", text: "already here" });
+  expect(lines[0]).toMatchObject({ status: "started", text: "already here" });
   const fresh = lines.slice(1);
   expect(fresh.every((l) => l.status === "open")).toBe(true);
   expect(fresh.map((l) => l.text)).toEqual([

package/cli/state.test.ts

@@ -25,6 +25,12 @@ const run = (id: string, s: object, request = "") => {
 beforeAll(() => {
   state = join(mkdtempSync(join(tmpdir(), "kaizen-")), ".kaizen");
   mkdirSync(state, { recursive: true });
+  writeInbox(state, [
+    { status: "open", text: "add oauth login" },
+    { status: "open", text: "retry failed webhooks" },
+    { status: "started", text: "nightly digest" },
+    { status: "rejected", text: "gantt view | not this product" },
+  ]);
   run("2026-09-01-waiting", { stage: "plan", awaiting: "approvals.plan" }, "# Request\n\nAdd OAuth login\n");
   run("2026-09-02-done", { stage: "done", awaiting: null }, "# Request\n\nRename cli flags\n");
   const old = run("2026-09-03-stale", { stage: "build", awaiting: null });
@@ -33,12 +39,6 @@ beforeAll(() => {
   writeFileSync(join(state, "runs", "2026-09-02-done", "06-backlog.md"),
     "# Backlog\n\n- open: `cli/x.ts:12`: low: first thing. Fix: do it.\n- done: closed one | run y\n- open: plain item\n");
   writeFileSync(join(state, "backlog.md"), "- open: orphaned item\n");
-  writeInbox(state, [
-    { status: "open", text: "add oauth login" },
-    { status: "open", text: "retry failed webhooks" },
-    { status: "started", text: "nightly digest" },
-    { status: "rejected", text: "gantt view | not this product" },
-  ]);
 });
 afterAll(() => rmSync(join(state, ".."), { recursive: true, force: true }));
 
@@ -80,6 +80,48 @@ test("boardCards: idea retired once a run's request contains it; started idea si
   expect(runs).toEqual([["2026-09-03-stale", 2, "stalled"], ["2026-09-02-done", 4, "done"], ["2026-09-01-waiting", 1, "waiting"]]);
 });
 
+test("boardCards: a started idea stays until its run has a state.json", () => {
+  const dir = join(mkdtempSync(join(tmpdir(), "kaizen-")), ".kaizen");
+  const r = join(dir, "runs", "2026-01-01-new");
+  mkdirSync(r, { recursive: true });
+  writeInbox(dir, [{ status: "started", text: "full release" }]);
+  writeFileSync(join(r, "00-request.md"), "full release\n");
+  const cards = () => boardCards([dir], Date.now()).map((k) => k.kind);
+  expect(cards()).toEqual(["idea"]);
+  writeFileSync(join(r, "state.json"), JSON.stringify({ id: "2026-01-01-new", stage: "plan", awaiting: null }));
+  expect(cards()).toEqual(["run"]);
+  rmSync(join(dir, ".."), { recursive: true, force: true });
+});
+
+test("boardCards: a run older than the idea does not retire it", () => {
+  const dir = join(mkdtempSync(join(tmpdir(), "kaizen-")), ".kaizen");
+  const r = join(dir, "runs", "2026-01-01-old");
+  mkdirSync(r, { recursive: true });
+  writeFileSync(join(r, "state.json"), JSON.stringify({ id: "2026-01-01-old", stage: "done", awaiting: null }));
+  writeFileSync(join(r, "00-request.md"), "fix this bugs\n");
+  const then = new Date(Date.now() - 3600_000);
+  utimesSync(join(r, "00-request.md"), then, then);
+  writeInbox(dir, [{ status: "open", text: "fix this bugs" }]);
+  expect(readFileSync(join(dir, "inbox.md"), "utf8")).toMatch(/- open: fix this bugs <!-- added:\d+ -->/);
+  expect(readInbox(dir)[0]!.text).toBe("fix this bugs");
+  const ideas = () => boardCards([dir], Date.now()).filter((k) => k.kind === "idea").map((k) => k.text);
+  expect(ideas()).toEqual(["fix this bugs"]);
+  // Rewriting keeps the stamp, so an edit to notes does not make it vanish.
+  writeInbox(dir, readInbox(dir).map((l) => ({ status: l.status, text: l.text, notes: "n" })));
+  expect(ideas()).toEqual(["fix this bugs"]);
+  // A run started after it retires it as before.
+  utimesSync(join(r, "00-request.md"), new Date(), new Date(Date.now() + 5000));
+  expect(ideas()).toEqual([]);
+  // Re-adding the same words while an old line holds them is a new idea with its
+  // own stamp, not the old line's (or no) stamp.
+  writeFileSync(join(dir, "inbox.md"), "- done: fix this bugs\n");
+  writeInbox(dir, [...readInbox(dir), { status: "open", text: "fix this bugs" }]);
+  utimesSync(join(r, "00-request.md"), then, then);
+  expect(ideas()).toEqual(["fix this bugs"]);
+
+  rmSync(join(dir, ".."), { recursive: true, force: true });
+});
+
 test("replaceIdea edits, rejects, deletes by text", () => {
   replaceIdea(state, "retry failed webhooks", { status: "open", text: "retry failed webhooks twice" });
   expect(readInbox(state).some((l) => l.text === "retry failed webhooks twice")).toBe(true);
@@ -103,6 +145,20 @@ test("backlog: open items only, orphanage last, count matches", () => {
   expect(backlog(state)).toBe(3);
 });
 
+test("backlog: an abandoned run's items are neither listed nor counted", () => {
+  const dir = join(state, "runs", "2026-09-03-dropped");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "state.json"), JSON.stringify({ id: "2026-09-03-dropped", stage: "abandoned" }));
+  writeFileSync(join(dir, "06-backlog.md"), "- open: never happening\n");
+  expect(allBacklog(state).some((g) => g.run === "2026-09-03-dropped")).toBe(false);
+  expect(backlog(state)).toBe(3);
+  rmSync(dir, { recursive: true });
+});
+
+test("abandonRun refuses a done run", () => {
+  expect(abandonRun(state, "2026-09-02-done", "late")).toMatch(/already done/);
+});
+
 test("parseItem: finding line splits into where, severity, text", () => {
   const it = parseItem("`cli/x.ts:12`: low: first thing. Fix: do it.");
   expect([it.where, it.severity, it.text]).toEqual(["x.ts:12", "low", "first thing."]);
@@ -188,8 +244,8 @@ test("notes: indented lines under a bullet round-trip; a legacy file is untouche
   expect(readFileSync(join(state, "inbox.md"), "utf8")).toBe(legacy);
   writeInbox(state, [{ status: "open", text: "with notes", notes: "see https://x.y/z\ncli/state.ts:12 | not a reason" }, { status: "open", text: "plain zq8" }]);
   const [a, b] = readInbox(state);
-  expect(a).toEqual({ status: "open", text: "with notes", notes: "see https://x.y/z\ncli/state.ts:12 | not a reason" });
-  expect(b).toEqual({ status: "open", text: "plain zq8" });
+  expect(a).toMatchObject({ status: "open", text: "with notes", notes: "see https://x.y/z\ncli/state.ts:12 | not a reason" });
+  expect(b).toMatchObject({ status: "open", text: "plain zq8" });
 });
 
 test("notes: survive reject and started; edit can replace or clear them", () => {
@@ -334,6 +390,7 @@ console.log(JSON.stringify(out));`;
 test("boardCards: a short idea is not retired by a request that merely contains the word", () => {
   const dir = join(mkdtempSync(join(tmpdir(), "kz-")), ".kaizen");
   mkdirSync(join(dir, "runs", "2026-09-01-a"), { recursive: true });
+  writeFileSync(join(dir, "runs", "2026-09-01-a", "state.json"), JSON.stringify({ id: "2026-09-01-a", stage: "plan", awaiting: null }));
   writeFileSync(join(dir, "runs", "2026-09-01-a", "00-request.md"), "# Request\n\n> /kaizen lite add retry\n\nDone means the tests pass.\n");
   writeInbox(dir, [{ status: "open", text: "test" }, { status: "open", text: "add retry" }]);
   expect(boardCards([dir], Date.now()).filter((k) => k.kind === "idea").map((k) => k.text)).toEqual(["test"]);
@@ -986,7 +1043,7 @@ test("moveIdea carries notes and linked attachments, leaves the old inbox withou
   expect(moveIdea(a, b, "nope")).toBe("no such idea");
   expect(moveIdea(a, b, "go")).toBeNull();
   expect(readInbox(a).map((l) => l.text)).toEqual(["keep"]);
-  expect(readInbox(b)).toEqual([{ status: "open", text: "go", notes: "see [shot](attachments/x-shot.png)" }]);
+  expect(readInbox(b)).toMatchObject([{ status: "open", text: "go", notes: "see [shot](attachments/x-shot.png)" }]);
   expect(readFileSync(join(b, "attachments", "x-shot.png"), "utf8")).toBe("png");
   writeInbox(a, [{ status: "open", text: "go" }]);
   expect(moveIdea(a, b, "go")).toBe("that project already has this idea");

package/cli/state.ts

@@ -435,7 +435,7 @@ export function unrechecked(state: string, id: string) {
 export function backlog(state: string) {
   const files = [join(state, "backlog.md")];
   const runs = join(state, "runs");
-  if (existsSync(runs)) for (const id of readdirSync(runs)) files.push(join(runs, id, "06-backlog.md"));
+  if (existsSync(runs)) for (const id of readdirSync(runs)) if (!abandoned(join(runs, id))) files.push(join(runs, id, "06-backlog.md"));
   let n = 0;
   for (const f of files) {
     if (!existsSync(f)) continue;
@@ -581,11 +581,17 @@ export function readBacklog(file: string) {
     .map((l) => l.replace(/^-\s*open:\s*/, ""));
 }
 
+// An abandoned run's backlog is not open work (spec-main.md).
+function abandoned(run: string) {
+  try { return JSON.parse(readText(join(run, "state.json"))).stage === "abandoned"; } catch { return false; }
+}
+
 export function allBacklog(state: string) {
   const out: { run: string; items: string[] }[] = [];
   const runs = join(state, "runs");
   if (existsSync(runs)) {
     for (const id of readdirSync(runs).sort().reverse()) {
+      if (abandoned(join(runs, id))) continue;
       const items = readBacklog(join(runs, id, "06-backlog.md"));
       if (items.length) out.push({ run: id, items });
     }
@@ -676,7 +682,8 @@ export function columnOf(stage: string, awaiting: string | null = null) {
 
 // notes: free text under the bullet -- links, path:line refs, background. Kept as
 // indented continuation lines so a one-line inbox from before notes reads unchanged.
-export type InboxLine = { status: string; text: string; notes?: string };
+// `added` is when the line first appeared (ms), kept as a hidden comment on its bullet.
+export type InboxLine = { status: string; text: string; notes?: string; added?: number };
 
 // Ideas with no run yet. Deliberately not backlog.md, which the spec defines as
 // an orphanage for items rescued from pruned runs, and not a run stub each.
@@ -686,7 +693,11 @@ export function readInbox(state: string): InboxLine[] {
   const out: InboxLine[] = [];
   for (const raw of readText(f).split("\n")) {
     const m = /^-\s*(open|started|done|rejected|archived):\s*(.+)$/.exec(raw.trim());
-    if (m) { out.push({ status: m[1]!, text: m[2]!.trim() }); continue; }
+    if (m) {
+      const a = /\s*<!-- added:(\d+) -->$/.exec(m[2]!);
+      out.push(a ? { status: m[1]!, text: m[2]!.slice(0, a.index).trim(), added: +a[1]! } : { status: m[1]!, text: m[2]!.trim() });
+      continue;
+    }
     // An indented line belongs to the bullet above it; anything else is noise.
     const last = out[out.length - 1];
     if (last && /^\s{2,}\S/.test(raw)) last.notes = (last.notes ? last.notes + "\n" : "") + raw.trim();
@@ -699,12 +710,24 @@ export function readInbox(state: string): InboxLine[] {
 // needs a lock or an append-only journal.
 export function writeInbox(state: string, lines: InboxLine[]) {
   mkdirSync(state, { recursive: true });
+  // A line already in the file keeps its stamp; a text the file never had is new now.
+  // Lines from before stamps existed stay unstamped rather than looking new.
+  // Stamps queue per text and each is used once: re-adding words the file already
+  // holds (a done or rejected line, or an open duplicate) is a new idea, not the old
+  // one's stamp, which an older run with those words would retire.
+  const had = new Map<string, (number | undefined)[]>();
+  for (const l of readInbox(state)) had.set(l.text, [...(had.get(l.text) ?? []), l.added]);
+  const stamp = (l: InboxLine) => {
+    if (l.added) return l.added;
+    const q = had.get(l.text);
+    return q?.length ? q.shift() : Date.now();
+  };
   const body = [
     "# Inbox",
     "",
     "Ideas with no run yet. One line each, same format as a run's backlog.",
     "",
-    ...lines.flatMap((l) => [`- ${l.status}: ${l.text}`, ...noteLines(l.notes)]),
+    ...lines.flatMap((l) => { const a = stamp(l); return [`- ${l.status}: ${l.text}${a ? ` <!-- added:${a} -->` : ""}`, ...noteLines(l.notes)]; }),
   ];
   writeFileSync(join(state, "inbox.md"), body.join("\n") + "\n");
 }
@@ -863,6 +886,7 @@ export function abandonRun(st: string, id: string, why: string): string | null {
   try {
     const run = JSON.parse(readText(file));
     if (run.stage === "abandoned") return "That run is already abandoned.";
+    if (run.stage === "done") return "That run is already done.";
     run.stage = "abandoned";
     run.awaiting = null;
     run.updated = new Date().toISOString();
@@ -961,15 +985,20 @@ export function boardCards(states: string[], now: number): Card[] {
     if (!bodies.has(f)) { try { bodies.set(f, readText(f)); } catch { bodies.set(f, ""); } }
     return bodies.get(f)!;
   };
-  const requests: string[] = [];
+  // Each request with when it was written, so a run older than an idea cannot retire it.
+  const requests: { at: number; text: string }[] = [];
   // Each request line on its own, quote and list markers stripped: what an idea
   // nobody launched from the board is matched against.
-  const lines: string[] = [];
+  const lines: { at: number; text: string }[] = [];
   for (const st of [...states, ...knownProjects().map((d) => join(d, ".kaizen")), join(home, ".kaizen")]
     .filter((d, i, all) => all.indexOf(d) === i && existsSync(join(d, "runs")))) {
-    for (const id of readdirSync(join(st, "runs"))) { const b = body(st, id); if (!b) continue;
-      requests.push(normalise(b));
-      for (const l of b.split("\n")) lines.push(normalise(l.replace(/^[\s>*"'`-]+|[\s"'`.]+$/g, "")));
+    // A run with no state.json yet has no card either: retiring the idea against it
+    // leaves the board showing neither until the agent writes one.
+    for (const id of readdirSync(join(st, "runs"))) { const b = body(st, id); if (!b || !existsSync(join(st, "runs", id, "state.json"))) continue;
+      let at = 0;
+      try { at = statSync(join(st, "runs", id, "00-request.md")).mtimeMs; } catch {}
+      requests.push({ at, text: normalise(b) });
+      for (const l of b.split("\n")) lines.push({ at, text: normalise(l.replace(/^[\s>*"'`-]+|[\s"'`.]+$/g, "")) });
     }
   }
   for (const st of states) {
@@ -986,7 +1015,11 @@ export function boardCards(states: string[], now: number): Card[] {
       // prefix): a short idea like "test" is a substring of half the requests
       // ever written, and would vanish the moment it was added.
       const t = normalise(it.text);
-      if (it.status === "started" ? requests.some((r) => r.includes(t)) : lines.some((l) => l === t || l.endsWith(" " + t))) continue;
+      // A run written before the idea existed is not this idea's run: an old request
+      // titled "fix this bugs" must not swallow a new idea with the same words.
+      // ponytail: 2s slack for coarse filesystem clocks.
+      const after = (r: { at: number }) => !it.added || r.at >= it.added - 2000;
+      if (it.status === "started" ? requests.some((r) => after(r) && r.text.includes(t)) : lines.some((l) => after(l) && (l.text === t || l.text.endsWith(" " + t)))) continue;
       next.push(it.status === "started"
         ? { kind: "idea", status: "starting", text: it.text, state: st, where, column: 1, awaiting: null, dim: true, archived: false, notes: it.notes, parent: parentOf(it.notes) }
         : { kind: "idea", status: "idea", text: it.text, state: st, where, column: 0, awaiting: null, dim: false, archived: it.status === "archived", notes: it.notes, parent: parentOf(it.notes) });
@@ -1392,7 +1425,7 @@ export function trustFolder(dir: string, cfg = join(process.env.CLAUDE_CONFIG_DI
 
 // run: the run a decision is for. Without it, an idea starting a new run.
 // pick: the tool, model and yolo chosen for a new run; a decision takes the run's own
-// tool and model, and never yolo. card: run it inside the board (agent.launch: card),
+// tool and model, and stays in Yolo when the run was started in it. card: run it inside the board (agent.launch: card),
 // where a pseudo-terminal exists; onChange is told when that agent ends.
 const CHILD_ENV = /^(CLAUDECODE|CLAUDE_PID|CLAUDE_CODE_(SESSION_ID|CHILD_SESSION|SESSION_ATTENDED|MESSAGING_SOCKET|MESSAGING_TOKEN))$/;
 
@@ -1413,7 +1446,10 @@ export function launchRun(it: Item, from: string, run?: string, pick: { agent?:
   const wanted = pick.model ?? (own?.cmd === agent.cmd ? own.model : null) ?? undefined;
   const model = wanted && plainModel(wanted) ? wanted : undefined;
   // Yolo was picked for one tool; a fallback to another opens in its normal mode.
-  const yolo = !!pick.yolo && agent.cmd === pick.agent && !!YOLO_FLAGS[agent.cmd];
+  // A decision on a run started in Yolo keeps it, or its next stage stops on every command.
+  const st = join(projectDir, ".kaizen");
+  const wasYolo = !!run && !pick.agent && readSessions(st).some((s) => s.yolo && s.cmd === agent.cmd && ownerOf(st, s) === run);
+  const yolo = (wasYolo || (!!pick.yolo && agent.cmd === pick.agent)) && !!YOLO_FLAGS[agent.cmd];
   const flags = [...agentFlags(projectDir, agent.cmd, undefined, model), ...(yolo ? YOLO_FLAGS[agent.cmd] : [])];
   // The idea as its run's request will hold it: without the runner word in front.
   const s = sessionLaunch(projectDir, agent.cmd, [agentBin, ...flags], prompt, it.text.replace(/^(lite|full|auto|plan)\s+/i, ""), run, model, yolo);

package/cli/web.ts

@@ -191,7 +191,9 @@ export async function web(repoDir: string, opts: Opts = {}) {
     const key = c.kind === "run"
       ? readSessions(c.state).filter((s) => live.has(s.key) && ownerOf(c.state, s) === c.id).pop()?.key
       : ideaPty.get(`${c.state}\0${c.text}`);
-    return key && live.has(key) ? { key, alive: ptyState(key)!.alive } : undefined;
+    if (!key || !live.has(key)) return undefined;
+    const st = ptyState(key)!;
+    return { key, alive: st.alive, asking: st.asking };
   };
   // Dev: the page reloads itself when board.html or its bundle is saved. Server code needs
   // `bun --watch cli/install.ts web`; the page reconnects and reloads on hello.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaizen-agent",
-  "version": "1.39.0",
+  "version": "1.40.1",
   "description": "Staged workflow for AI agents — code, writing, research, operations: plan, human approval, build, independent review, bounded fix loop.",
   "type": "module",
   "bin": {

package/skills/kaizen/SKILL.md

@@ -108,8 +108,9 @@ rather than dispatching them, then stop after the review: report the findings an
 the user choose, rather than entering the fix loop. The loop
 exists because a fix to something intricate can be worse than the defect — it is not
 worth two more stages to confirm a one-line message now reads correctly. A finding at
-`high` or above pulls the run back onto the full path whatever its size, since that
-severity is the loop's whole reason for existing.
+`high` or above still enters the fix loop whatever the run's size, since that
+severity is the loop's whole reason for existing — on the same runner, which is fixed
+at intake.
 
 **Short work still gets a run.** A one-line change is not skipped past the stages: the card on the board moves through plan, build and review like any other. Run it with `runner: lite` and the short path above — a brief plan, the build, a short review — so the cost stays small and the run stays visible.
 

package/skills/kaizen/spec-build.md

@@ -119,7 +119,12 @@ library, an API — may give command output alone. A report with no screenshot i
 A headless browser does it: `playwright screenshot <url> runs/<id>/attachments/<name>.png`,
 or `chromium --headless --screenshot=<abs path>.png --window-size=1280,900 <url>` where
 playwright has no browser installed. A file (document, diff, output) opens as `file://<path>`.
-Where no proof can be produced, say why in one line under `## Preview`.
+Where no proof can be produced, say why in one line under `## Preview` — but a missing
+browser is never that reason. Before giving up, try each of: `playwright screenshot`,
+`bunx playwright screenshot`, `chromium --headless`, `google-chrome --headless`,
+and `bunx playwright install chromium` then retry. Start the app if it is not running.
+Only a result with no screen, or a capture that failed after every one of these (quote
+the error), may skip the screenshot.
 
 **A revise retakes the screenshots.** When the run being revised, or the run a follow-up
 names in `Follow-up of:`, already shows screenshots in its `## Preview`, the build that

package/skills/kaizen/spec-main.md

@@ -89,7 +89,8 @@ Before setting `stage: "review"` after a build, in either runner, open `03-impl.
 check its `## Preview`: it has `### How to test` steps, and — when the result shows on a
 screen — at least one `![…](attachments/<name>.png)` embed whose file exists under
 `runs/<id>/attachments/`. A result with no screen needs one line under `## Preview`
-saying why there is no screenshot. Anything missing means the build is not finished:
+saying why there is no screenshot; "no headless browser" for a result that shows on a
+screen does not count — take it as missing. Anything missing means the build is not finished:
 under `lite`, take the screenshot and write the section now; under `full`, send the
 builder back to add it. Then advance. This is the step that keeps the board's Preview
 tab from staying empty; the reviewer flagging it later is a second net, not the first.

package/skills/kaizen/spec.md

@@ -143,7 +143,7 @@ the config said the day someone came back to it.
 If the request remains ambiguous enough that a plan would be guesswork, ask now. One
 round of questions here is cheaper than a rejected plan.
 
-**Short work is not skipped.** Even a one-line change gets `01-plan.md` and `04-review.md`, so the run moves through every stage. Keep them brief and run under `runner: lite`.
+**Short work is not skipped.** Even a one-line change gets `01-plan.md` and `04-review.md`, so the run moves through every stage. Keep them brief and run under `runner: lite`; a `high`+ finding still enters the fix loop, on that same runner.
 
 **Follow-ups are runs too.** Both runners record the same artifacts: `01-plan.md`, `03-impl.md`, `04-review.md`, and a final `state.json` — `lite` and `full` differ only in who executes the stages. A message the user sends later in the same session is judged by what it asks: a question, explanation or chat is answered, no run; a request to change or produce something is building, so it goes through the flow. While the previous run has not reached `done` (including awaiting its final approval), the change is a revise of that run, recorded in `02-approval.md`. After `done` or `abandoned`, open a new run whose `00-request.md` is the user's words verbatim, then a line `Follow-up of: <previous run id>`. Never reopen a finished run. When unsure whether a message asks for a change, ask once.
 

package/web/board/cards.ts

@@ -9,7 +9,7 @@ import { brief } from "./markdown.ts";
 import { open, toggleArchive } from "./panel.ts";
 import { ideaCombo, list, newDir, plogo, short, showList, showable } from "./projects.ts";
 import { askNotify, toast } from "./toast.ts";
-import { resumable, resume } from "./approvals.ts";
+import { answer, decided, resumable, resume } from "./approvals.ts";
 
 let filter = null;
 let query = ""; // the header filter box, matched against a card's title and request
@@ -42,8 +42,11 @@ const nested = (c) =>
 const kidsOpen = new Set();
 
 // What opening a waiting run does, in words: the card's button and its menu say the same.
+// One already answered from this page says so until the agent moves the run on.
 const actionOf = (c) =>
-  c.status !== "waiting"
+  decided.has(answer(c))
+    ? "Sent to agent"
+    : c.status !== "waiting"
     ? "Open"
     : { "approvals.plan": "Review plan", findings: "See findings", "approvals.review": "Review work" }[c.awaiting] || "Open";
 
@@ -84,7 +87,9 @@ function card(c) {
       marks.push(`<span class="mk warn" title="Started in Yolo: the agent runs commands without asking">yolo</span>`);
     else chips.push(`<span class="chip">${esc(NAMES[t] || t)}</span>`);
   }
-  if (c.pty && c.pty.alive)
+  if (c.pty && c.pty.alive && c.pty.asking)
+    marks.push(mk("i-ask", "The agent is asking you something: open it, terminal button at the top", " warn ask"));
+  else if (c.pty && c.pty.alive)
     marks.push(mk("i-term", "The agent is running in this card: open it, terminal button at the top", " run"));
   // A gathered idea's notes open with the stamp promote() writes (ingest() wrote it before
   // the icebox); its chip names the source.
@@ -112,7 +117,7 @@ function card(c) {
   const act =
     c.kind === "run" && !archive && !pick
       ? c.status === "waiting"
-        ? `<button class="btn sm pri act" data-a="open">${actionOf(c)}</button>`
+        ? `<button class="btn sm${decided.has(answer(c)) ? "" : " pri"} act" data-a="open">${actionOf(c)}</button>`
         : c.status === "stalled" && resumable(c)
           ? `<button class="btn sm act" data-a="resume">Resume</button>`
           : ""