kaizen-agent 1.43.0 → 1.43.2

package/agents/kaizen-reviewer.md

@@ -142,7 +142,7 @@ open human check never reads as a clean pass.
 
 ## Memory
 
-When memory writing is enabled, append to `.kaizen/memory.md` any durable lesson
+When `review.write_memory` is true (the default), append to `.kaizen/memory.md` any durable lesson
 about this codebase: a recurring bug pattern, a non-obvious constraint, a convention
 worth preserving. One line each. Nothing run-specific, nothing already obvious from
 reading the code.

package/cli/board.test.ts

@@ -186,10 +186,11 @@ test("card menu items: appropriate actions and distinct icons across phases", ()
   // Phase 1: Planning (run waiting for plan approval)
   const planWaiting = { kind: "run", status: "waiting", awaiting: "approvals.plan", column: 1 };
   const planItems = getItems(planWaiting, false);
-  expect(planItems.map((i: any) => i ? i[1] : null)).toEqual(["Review plan", "Archive", null, "Abandon"]);
+  expect(planItems.map((i: any) => i ? i[1] : null)).toEqual(["Review plan", "Archive", "Back to idea", null, "Abandon"]);
   expect(planItems[0][2]).toBe(ico("open"));
   expect(planItems[1][2]).toBe(ico("archive"));
-  expect(planItems[3][2]).toBe(ico("x"));
+  expect(planItems[2][2]).toBe(ico("restore"));
+  expect(planItems[4][2]).toBe(ico("x"));
 
   // Phase 2: Building (running run)
   const buildingRun = { kind: "run", status: "running", column: 2 };

package/cli/browser.test.ts

@@ -18,7 +18,7 @@ const run = async (code: string, env: Record<string, string> = {}) => {
   const script = `import * as br from ${JSON.stringify(join(repo, "cli/browser.ts"))};
 Object.assign(process.env, ${JSON.stringify({ HOME: process.env.HOME ?? "", USERPROFILE: process.env.USERPROFILE ?? "" })});
 console.log(JSON.stringify(await (async () => { ${code} })()));`;
-  const p = Bun.spawn(["bun", "-e", script], { cwd: home, env: { ...process.env, HOME: home, USERPROFILE: home, ...env }, stdout: "pipe", stderr: "pipe" });
+  const p = Bun.spawn(["bun", "-e", script], { cwd: home, env: { ...process.env, HOME: home, USERPROFILE: home, KAIZEN_BROWSER_PACE: "0.1", ...env }, stdout: "pipe", stderr: "pipe" });
   const [out, err, code_] = [await new Response(p.stdout).text(), await new Response(p.stderr).text(), await p.exited];
   if (code_ !== 0) throw new Error(err);
   return JSON.parse(out.trim().split("\n").at(-1)!);

package/cli/browser.ts

@@ -30,6 +30,8 @@ export const POST: Record<string, RegExp> = {
 };
 // Grids show thumbnails, not text: each post page is opened for its caption.
 const GRID = new Set(["instagram"]);
+// The fixed waits below are sized for real platforms; KAIZEN_BROWSER_PACE scales them (the tests run at 0.1).
+const nap = (ms: number) => Bun.sleep(ms * (Number(process.env.KAIZEN_BROWSER_PACE) || 1));
 
 // KAIZEN_BROWSER, else the usual names on PATH, else the usual install paths.
 export function findBrowser(): string | null {
@@ -97,9 +99,9 @@ export class Page {
   async go(url: string) {
     await this.call("Page.navigate", { url });
     const end = Date.now() + 20_000;
-    await Bun.sleep(1500);
-    while (Date.now() < end && (await this.js("document.readyState")) !== "complete") await Bun.sleep(250);
-    await Bun.sleep(2000);   // the posts arrive after the page itself
+    await nap(1500);
+    while (Date.now() < end && (await this.js("document.readyState")) !== "complete") await nap(250);
+    await nap(2000);   // the posts arrive after the page itself
   }
   close() { try { this.ws.close(); } catch { /* already gone */ } }
 }
@@ -200,7 +202,10 @@ export async function browse<T>(use: (page: Page) => Promise<T>): Promise<T | {
   } finally {
     page?.close();
     proc.kill();
-    await Promise.race([proc.exited, Bun.sleep(5000)]);
+    // A cleared timer, not Bun.sleep: a pending sleep keeps the process alive 5 s after Chrome is gone.
+    let t: Timer | undefined;
+    await Promise.race([proc.exited, new Promise((r) => { t = setTimeout(r, 5000); })]);
+    clearTimeout(t);
     if (proc.exitCode === null) proc.kill(9);
   }
 }
@@ -230,7 +235,7 @@ export async function readPage(page: Page, url: string, platform: string, max =
     // A page that renders its posts late is not empty: stop early only once some arrived.
     still = seen.size && seen.size === before ? still + 1 : 0;
     await page.js("window.scrollBy(0, window.innerHeight * 1.5)");
-    await Bun.sleep(1500);
+    await nap(1500);
   }
   let found = [...seen.values()].slice(0, max);
   if (GRID.has(platform)) {
@@ -310,12 +315,12 @@ export async function replyOn(page: Page, link: string, platform: string, text:
   if (!(await page.js<boolean>(FIND(how.box, "focus"))))
     return { ok: false, note: (await page.js<boolean>(OFFERS)) ? signInNote(platform) : `Could not find the reply box on ${name}. Nothing was posted.` };
   await page.call("Input.insertText", { text });
-  await Bun.sleep(800);
+  await nap(800);
   if (!(await here())) return { ok: false, note: `The page left ${name}. Nothing was posted.` };
   if (!(await page.js<boolean>(FIND(how.send, "click")))) return { ok: false, note: `Could not find ${name}'s send button. Nothing was posted.` };
   // Sent once the box is gone or emptied; still holding the text means it did not go.
   for (let i = 0; i < 20; i++) {
-    await Bun.sleep(500);
+    await nap(500);
     const left = await page.js<string | null>(BOX);
     if (left === null || !left.trim()) return { ok: true };
   }

package/cli/pty.test.ts

@@ -186,6 +186,16 @@ test.skipIf(process.platform === "win32")("the done sweep keeps a session the us
   await Bun.sleep(200);
   expect(alive(used)).toBe(true);
   process.kill(used, "SIGTERM");
+
+  // Only looked at: the page's focus and query answers reach the tty but are not typing.
+  done(Date.now() - 60_000);
+  const looked = launch("looked");
+  await Bun.sleep(200);
+  writePty("looked", "\x1b[I\x1b[O\x1b[?0u\x1b[<64;10;5M\x1bP>|xterm.js(6.0)\x1b\\");
+  await Bun.sleep(200);
+  expect(ptyState("looked")!.typed).toBe(0);
+  sweepSessions(st, Date.now() + CLOSE_GRACE_MS);
+  expect(await gone(looked)).toBe(true);
 });
 
 test("asking: Claude Code and Codex prompts count as a question, ordinary output does not", async () => {

package/cli/pty.ts

@@ -11,7 +11,7 @@ const WIN = process.platform === "win32";
 // Windows PowerShell, which every Windows has, both hosts the console and runs the agent in it.
 const winPs = () => join(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
 
-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 };
+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; typed: 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.
@@ -38,7 +38,7 @@ export const ptySupported = WIN || typeof (Bun as any).Terminal === "function";
 // 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, asking: false, total: 0, since: 0, onChange };
+  const p: Pty = { proc: null as unknown as Bun.Subprocess, out: [], size: 0, listeners: new Set(), exit: null, asking: false, total: 0, since: 0, typed: 0, onChange };
   const flag = (v: boolean) => { if (p.asking !== v) { p.asking = v; onChange?.(); } };
   const push = (d: string) => {
     p.out.push(d);
@@ -81,7 +81,8 @@ export function startPty(key: string, cmd: string[], cwd: string, pidFile?: stri
     for (const f of p.listeners) f(null);
     p.listeners.clear();
     try { p.proc.terminal?.close(); } catch { /* already closed */ }
-    setTimeout(() => { if (ptys.get(key) === p) ptys.delete(key); }, KEEP_MS).unref();
+    // Dropped: pages showing it (the Terminal page) refresh, or its tile lingers until some other change.
+    setTimeout(() => { if (ptys.get(key) === p) { ptys.delete(key); onChange?.(); } }, KEEP_MS).unref();
     onChange?.();
   });
   return p.proc.pid;
@@ -98,11 +99,19 @@ export function attachPty(key: string, fn: (d: string | null) => void): (() => v
   return () => p.listeners.delete(fn);
 }
 
+// What the page's terminal sends by itself: focus in/out (Claude Code turns focus
+// reporting on), mouse and wheel reports, and answers to the agent's queries (cursor,
+// device, mode, colour, version). None of it is the user typing.
+const REPORT = /\x1b\[[IO]|\x1b\[<[\d;]*[Mm]|\x1b\[\?[\d;]*(?:[cnu]|\$y)|\x1b\[>[\d;]*c|\x1b\[\d+;\d+R|\x1b\[\d*n|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1bP[^\x1b]*\x1b\\/g;
+
 export function writePty(key: string, d: string) {
   const p = ptys.get(key);
   if (!p || p.exit !== null) return;
-  p.since = p.total;
-  if (p.asking) { p.asking = false; p.onChange?.(); }
+  if (d.replace(REPORT, "")) {
+    p.typed = Date.now();
+    p.since = p.total;
+    if (p.asking) { p.asking = false; p.onChange?.(); }
+  }
   send(p, d);
 }
 
@@ -121,7 +130,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, asking: p.asking } : null;
+  return p ? { alive: p.exit === null, exit: p.exit, asking: p.asking, typed: p.typed } : null;
 };
 
 // The environment the user's login shell builds: PATH and anything exported in their

package/cli/settings.test.ts

@@ -6,6 +6,7 @@ import { test, expect, beforeAll, afterAll } from "bun:test";
 import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, copyFileSync, rmSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
+import { applyPreset, detectPreset } from "./settings.ts";
 
 const repo = join(dirname(import.meta.path), "..");
 const defaults = join(repo, "skills/kaizen/config.default.yml");
@@ -48,3 +49,40 @@ test("board settings save to the global config, project settings to the project"
   expect(inProject(`return setSetting(repo, "git.auto_commit", "true")`)).toEqual({ ok: true });
   expect(readFileSync(join(project, ".kaizen", "config.yml"), "utf8")).toMatch(/auto_commit: true/);
 });
+
+test("every row is a key in config.default.yml, and every `when` names a row and one of its values", () => {
+  const rows = inProject(`return listSettings(repo).rows`);
+  const text = readFileSync(defaults, "utf8");
+  for (const r of rows) {
+    const [top, leaf] = r.key.split(".");
+    const block = leaf ? new RegExp(`^${top}:\\n(?:(?:  .*|\\s*)\\n)*?  ${leaf}:`, "m") : new RegExp(`^${top}:`, "m");
+    expect(block.test(text) ? r.key : `${r.key} missing`).toBe(r.key);
+    if (!r.when) continue;
+    const dep = rows.find((x) => x.key === r.when[0]);
+    expect(dep?.values).toContain(r.when[1]);
+  }
+});
+
+test("a row dims while the setting it depends on has it switched off, and a leftover dead key changes nothing", () => {
+  const conf = join(project, ".kaizen", "config.yml");
+  // The low preset as an older config holds it, with keys kaizen no longer reads.
+  writeFileSync(conf, readFileSync(defaults, "utf8")
+    .replace("enabled: true\n  # critical", "enabled: false\n  # critical")
+    .replace("git:\n", "git:\n  branch_before_implement: false\n")
+    + "\ntrack:\n  default: software\n");
+  const idle = (k: string) => inProject(`return listSettings(repo).rows.find((r) => r.key === ${JSON.stringify(k)}).idle`);
+  expect(idle("auto_fix.min_severity")).toBe("No effect unless Fix findings automatically is on");
+  expect(idle("auto_fix.enabled")).toBe("");
+  expect(inProject(`return setSetting(repo, "auto_fix.max_iterations", "3")`)).toEqual({ ok: true });
+  expect(inProject(`return setSetting(repo, "auto_fix.enabled", "true")`)).toEqual({ ok: true });
+  expect(idle("auto_fix.min_severity")).toBe("");
+  expect(inProject(`return value("auto_fix.max_iterations")`)).toBe("3");
+  copyFileSync(defaults, conf);
+});
+
+test("a config still holding git.branch_before_implement keeps its preset", () => {
+  const text = readFileSync(defaults, "utf8");
+  const low = applyPreset(text, "low", text).replace("git:\n", "git:\n  branch_before_implement: true\n");
+  expect(detectPreset(low, text)).toBe("low");
+  expect(detectPreset(text, text)).toBe("medium");
+});

package/cli/settings.ts

@@ -6,7 +6,10 @@ import { homedir } from "node:os";
 import { readText } from "./state.ts";
 
 // `text` is a value typed rather than chosen: a path. It has no values to cycle.
-type Setting = { key: string; label: string; group: string; values: string[]; help: string; text?: boolean; folder?: boolean };
+// `when`: the row only has an effect while that other key holds that value; both
+// settings screens dim it otherwise, and it stays editable (`/kaizen full` overrides
+// the runner for one run, so a subagent model still matters under `runner: lite`).
+type Setting = { key: string; label: string; group: string; values: string[]; help: string; text?: boolean; folder?: boolean; when?: [string, string] };
 
 export type PresetName = "low" | "medium" | "ultra";
 
@@ -29,7 +32,6 @@ export const PRESETS: Record<PresetName, {
       "auto_fix.min_severity": "high",
       "auto_fix.max_iterations": "1",
       "git.auto_commit": "false",
-      "git.branch_before_implement": "false",
       "git.worktree_per_run": "false",
     },
   },
@@ -47,7 +49,6 @@ export const PRESETS: Record<PresetName, {
       "auto_fix.min_severity": "high",
       "auto_fix.max_iterations": "2",
       "git.auto_commit": "false",
-      "git.branch_before_implement": "true",
       "git.worktree_per_run": "true",
     },
   },
@@ -65,7 +66,6 @@ export const PRESETS: Record<PresetName, {
       "auto_fix.min_severity": "low",
       "auto_fix.max_iterations": "4",
       "git.auto_commit": "true",
-      "git.branch_before_implement": "true",
       "git.worktree_per_run": "true",
     },
   },
@@ -99,31 +99,29 @@ export function applyPreset(text: string, preset: PresetName, defaults: string):
 
 const SETTINGS: Setting[] = [
   { 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: "mode", label: "Run mode", group: "Approvals", values: ["approve", "auto", "plan-only", "review-only"], help: "" },
+  { key: "approvals.plan", label: "Approve the plan first", group: "Approvals", values: ["true", "false"], help: "", when: ["mode", "approve"] },
+  { key: "approvals.review", label: "Approve after review", group: "Approvals", values: ["true", "false"], help: "", when: ["mode", "approve"] },
+  { key: "approvals.each_file", label: "Confirm every file edit", group: "Approvals", values: ["true", "false"], help: "", when: ["mode", "approve"] },
   { 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: "build.executor", label: "Who builds", group: "Agents", values: ["subagent", "inline", "ask"], help: "subagent: its own agent · inline: this session · ask: pick at plan approval", when: ["runner", "full"] },
   { 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: "subagents.model", label: "Model for subagents", group: "Agents", values: ["inherit", "opus", "sonnet", "haiku"], help: "Planner, builder, reviewer", when: ["runner", "full"] },
+  { key: "subagents.effort", label: "Effort for subagents", group: "Agents", values: ["inherit", "low", "medium", "high"], help: "Planner, builder, reviewer", when: ["runner", "full"] },
   { 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: "auto_fix.min_severity", label: "Lowest severity to fix", group: "Auto-fix", values: ["critical", "high", "medium", "low"], help: "", when: ["auto_fix.enabled", "true"] },
+  { key: "auto_fix.max_iterations", label: "Max fix rounds", group: "Auto-fix", values: ["1", "2", "3", "4", "5"], help: "", when: ["auto_fix.enabled", "true"] },
   { 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: "sources.agent", label: "Who picks social posts", group: "Board", values: ["ask", "chatgpt", "agent"], help: "X, TikTok, Instagram, Threads" },
+  { key: "sources.model", label: "ChatGPT model for gathering", group: "Board", values: [], text: true, help: "Empty: plan default", when: ["sources.agent", "chatgpt"] },
+  { key: "sources.effort", label: "ChatGPT effort for gathering", group: "Board", values: ["low", "medium", "high"], help: "", when: ["sources.agent", "chatgpt"] },
   { 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: "" },
@@ -137,13 +135,18 @@ export function listSettings(repoRoot: string) {
   const load = (f: string) => existsSync(f) ? readText(f) : "";
   const text = load(file), board = load(globalFile());
   const preset = detectPreset(text, defaults);
-  return {
-    file: tilde(file),
-    rows: SETTINGS.map((s) => ({
-      ...s,
-      value: s.key === "preset" ? preset : (read(s.group === "Board" ? board : text, s.key) || read(defaults, s.key)) ?? s.values[0] ?? "",
-    })),
-  };
+  const rows = SETTINGS.map((s) => ({
+    ...s,
+    value: s.key === "preset" ? preset : (read(s.group === "Board" ? board : text, s.key) || read(defaults, s.key)) ?? s.values[0] ?? "",
+  }));
+  const valueOf = (k: string) => rows.find((r) => r.key === k)?.value ?? null;
+  return { file: tilde(file), rows: rows.map((r) => ({ ...r, idle: idle(r, valueOf) })) };
+}
+
+// Why a row has no effect right now, or "" while it has one: its `when` is not met.
+function idle(s: Setting, valueOf: (key: string) => string | null) {
+  if (!s.when || valueOf(s.when[0]) === s.when[1]) return "";
+  return `No effect unless ${SETTINGS.find((x) => x.key === s.when![0])!.label} is ${s.when[1] === "true" ? "on" : s.when[1]}`;
 }
 
 export function setSetting(repoRoot: string, key: string, value: string) {
@@ -217,13 +220,17 @@ export async function settings(repoRoot: string, standalone = true) {
       }
       return v;
     };
+    const valueOf = (k: string) => {
+      const d = SETTINGS.find((x) => x.key === k)!;
+      return read(fileFor(d) === file ? text : readText(fileFor(d)), k) || read(defaults, k);
+    };
     const rows = SETTINGS.map((s) => ({
       s,
-      // Older configs spell "infer the track" as an empty string; show what it means.
+      idle: idle(s, valueOf),
       // The preset as a game's quick preset: arrows either side, the tier lit after it. No colour codes: the selected row wraps this in inverse, which a reset would end.
       value: s.key === "preset"
         ? `◁ ${currentPreset.padEnd(6)} ▷ ${(["low", "medium", "ultra"] as const).map((p) => p === currentPreset ? "━" : "─").join("")}`
-        : show(s, (read(fileFor(s) === file ? text : readText(fileFor(s)), s.key) || (s.key === "track.default" ? "auto" : undefined)) ?? c.dim("(default)")),
+        : show(s, read(fileFor(s) === file ? text : readText(fileFor(s)), s.key) ?? c.dim("(default)")),
     }));
     const width = Math.max(...SETTINGS.map((s) => s.label.length)) + 4;
 
@@ -234,7 +241,7 @@ export async function settings(repoRoot: string, standalone = true) {
     rowAt = [];
     let line = 2, group = "";
     const list = shown();
-    for (const [i, { s, value }] of rows.entries()) {
+    for (const [i, { s, value, idle: off }] of rows.entries()) {
       if (!list.includes(i)) continue;
       if (s.group !== group) {
         group = s.group;
@@ -245,14 +252,14 @@ export async function settings(repoRoot: string, standalone = true) {
       const name = s.label.padEnd(width);
       stdout.write(on
         ? `  ${c.cyan("›")} ${c.bold(name)}${c.inv(` ${value} `)}\n`
-        : `    ${c.dim(name)}${value}\n`);
+        : `    ${c.dim(name)}${off ? c.dim(value) : value}\n`);
       rowAt[line++] = i;
     }
     const cur = SETTINGS[active]!;
     if (!list.length) stdout.write(`\n  ${c.dim(`no setting matches "${query}"`)}\n\n`);
     else {
       stdout.write(`\n  ${c.dim(cur.key)}  ${c.dim("options:")} ${cur.values.map((v) => v || '""').join(c.dim(" / "))}\n`);
-      stdout.write(`  ${cur.help}\n`);
+      stdout.write(`  ${[cur.help, rows[active]!.idle].filter(Boolean).join(" · ")}\n`);
     }
     stdout.write(`\n  ${c.dim(typing
       ? "type to filter · enter or ↑↓ keep it · esc clear"

package/cli/state.test.ts

@@ -7,7 +7,7 @@ import { tmpdir } from "node:os";
 import { issueUrl, systemInfo, scrubHome, REPO_URL, home as realHome, trustFolder } from "./state.ts";
 import * as stateModule from "./state.ts";
 import {
-  readRuns, readInbox, writeInbox, replaceIdea, moveIdea, abandonRun, allBacklog, backlog,
+  readRuns, readInbox, writeInbox, replaceIdea, moveIdea, abandonRun, runToIdea, allBacklog, backlog,
   requestTitle, statusOf, columnOf, parseItem, startedRuns, boardCards, parentOf, addCard, readArchive, setArchived,
   requestOf, agentFlags, plainModel, readNotes, writeNotes, manualCommand, parseNotes, formatNote, appendNote, saveAttachment,
   reviewFindings, pickFindings, fixPrompt, approvalPrompt, sessionLaunch, closeSessions, sweepSessions, readSessions, ownerOf, CLOSE_GRACE_MS, gitStatus, runGit, cardsGit, commitPush, readCommit, findTerminal, nativePath, pruneRuns, unrechecked, notice, notifier, notifyArgs, LOGO, type Card,
@@ -176,6 +176,30 @@ test("backlog: an abandoned run's items are neither listed nor counted", () => {
   rmSync(dir, { recursive: true });
 });
 
+test("runToIdea: a planning run goes back to its idea, newer than the run", () => {
+  const id = "2026-09-04-planning", dir = join(state, "runs", id);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "state.json"), JSON.stringify({ id, stage: "plan", awaiting: "approvals.plan" }));
+  writeFileSync(join(dir, "00-request.md"), "/kaizen lite export invoices as csv\n");
+  const then = new Date(Date.now() - 30_000);
+  utimesSync(join(dir, "00-request.md"), then, then);
+  writeInbox(state, [...readInbox(state), { status: "started", text: "export invoices", added: Date.now() - 60_000 }, { status: "started", text: "export invoices as csv", notes: "see #12", added: Date.now() - 60_000 }]);
+  expect(runToIdea(state, id)).toBeNull();
+  expect(JSON.parse(readFileSync(join(dir, "state.json"), "utf8")).stage).toBe("abandoned");
+  const cards = boardCards([state], Date.now());
+  expect(cards.find((c) => c.kind === "idea" && c.text === "export invoices as csv")).toMatchObject({ status: "idea", notes: "see #12" });
+  expect(cards.find((c) => c.kind === "run" && c.id === id)?.archived).toBe(true);
+  expect(readInbox(state).filter((l) => l.text === "export invoices as csv").length).toBe(1);
+  expect(readInbox(state).find((l) => l.text === "export invoices")?.status).toBe("started");
+  expect(runToIdea(state, id)).toMatch(/planning/);
+  writeFileSync(join(dir, "state.json"), JSON.stringify({ id, stage: "plan" }));
+  rmSync(join(dir, "00-request.md"));
+  expect(runToIdea(state, id)).toMatch(/no request/);
+  replaceIdea(state, "export invoices", null);
+  setArchived(state, id, false);
+  rmSync(dir, { recursive: true });
+});
+
 test("abandonRun refuses a done run", () => {
   expect(abandonRun(state, "2026-09-02-done", "late")).toMatch(/already done/);
 });

package/cli/state.ts

@@ -5,7 +5,7 @@ import { existsSync, readFileSync, readdirSync, appendFileSync, writeFileSync, m
 import { Database } from "bun:sqlite";
 import { join, dirname, win32, posix } from "node:path";
 import { homedir, arch, cpus, release, totalmem, version as osVersion } from "node:os";
-import { startPty, ptySupported } from "./pty.ts";
+import { startPty, ptySupported, ptyState } from "./pty.ts";
 import { codeDir, projectFromWorktree } from "./worktree.ts";
 
 // The real path: process.cwd() is always physical, so a raw $HOME that crosses a
@@ -1015,6 +1015,32 @@ export function abandonRun(st: string, id: string, why: string): string | null {
   }
 }
 
+// A run still planning, back to the idea it came from: abandoned and archived (the
+// record stays), and the idea open again. Its fresh stamp is newer than the run's
+// request, so the old run no longer retires it.
+export function runToIdea(st: string, id: string): string | null {
+  let stage = "";
+  try { stage = JSON.parse(readText(join(st, "runs", id, "state.json"))).stage; } catch {}
+  if (stage !== "plan") return "Only a run still in planning goes back to an idea.";
+  let req = "";
+  try { req = readText(join(st, "runs", id, "00-request.md")).trim(); } catch {}
+  const lines = readInbox(st);
+  // The longest started idea the request holds: "test" must not stand in for "test login".
+  let at = -1;
+  lines.forEach((l, i) => { if (l.status === "started" && normalise(req).includes(normalise(l.text)) && (at < 0 || l.text.length > lines[at]!.text.length)) at = i; });
+  const [first = "", ...rest] = req.split("\n");
+  const idea: InboxLine = at >= 0
+    ? { ...lines[at]!, status: "open", added: Date.now() }
+    : { status: "open", text: first.replace(/^\/kaizen(?:-\w+)?\s+(?:(?:lite|full|auto|plan)\s+)?/i, "").trim(), notes: rest.join("\n").trim() || undefined, added: Date.now() };
+  if (!idea.text) return "That run has no request to make an idea of.";
+  const failed = abandonRun(st, id, "Sent back to ideas from the board.");
+  if (failed) return failed;
+  setArchived(st, id, true);
+  if (at >= 0) lines.splice(at, 1);
+  writeInbox(st, [...lines, idea]);
+  return null;
+}
+
 export function replaceIdea(state: string, text: string, next: InboxLine | null) {
   const lines = readInbox(state);
   const at = lines.findIndex((l) => (l.status === "open" || l.status === "started") && l.text === text);
@@ -1317,7 +1343,7 @@ function opencodeRows(sql: string, ...args: (string | number)[]): string[] {
   } catch { return []; }
 }
 
-export const CLOSE_GRACE_MS = 2 * 60_000;
+export const CLOSE_GRACE_MS = 60_000;
 const sessionsDir = (st: string) => join(st, "sessions");
 
 export function readSessions(st: string): Session[] {
@@ -1483,7 +1509,11 @@ export function sweepSessions(st: string, now: number) {
 // Whether the user typed into the session's terminal after `t`: its tty's access time
 // moves when input is read. Such a session is the user's now, not the run's to close.
 // No tty (Windows, a stranger's PID): false, so the sweep closes as before.
+// A board card's session is judged by its keystrokes: the page's terminal answers the
+// agent's focus and query reports on that tty too, which moved its time on every look.
 function typedSince(st: string, s: Session, t: number): boolean {
+  const card = ptyState(s.key);
+  if (card) return card.typed > t;
   try {
     if (process.platform === "win32") return false;
     const pid = parseInt(readText(join(sessionsDir(st), s.key + ".pid")));

package/cli/web.ts

@@ -4,7 +4,7 @@ import { existsSync, readdirSync, statSync, watch, appendFileSync, mkdirSync, cp
 import { join, dirname, resolve, sep, basename } from "node:path";
 import {
   home, type Item, type Card, boardCards, knownProjects, remember, locate, label, tilde, searchRoots, findProjects,
-  readInbox, writeInbox, replaceIdea, moveIdea, abandonRun, launchRun, parseItem, agentChoices, projectOf, KNOWN_AGENTS, plainModel, short, setArchived, writeNotes,
+  readInbox, writeInbox, replaceIdea, moveIdea, abandonRun, runToIdea, launchRun, parseItem, agentChoices, projectOf, KNOWN_AGENTS, plainModel, short, setArchived, writeNotes,
   appendNote, saveAttachment, pidOnPort, readText, cmdExe, sysExe, powershellExe, runGit, cardsGit, readCommit, commitPush, notice, notifier, LOGO,
   reviewFindings, pickFindings, backlogCards, backlogItem, startedBacklog, closeBacklog, markBacklogDone, fixPrompt, approvalPrompt, canApproveAwaiting, nativePath, closeSessions, sweepSessions, issueUrl,
   launchMode, readSessions, ownerOf, runIndex, resumePrompt, runAgent, firstSession, webHosts,
@@ -209,6 +209,8 @@ export async function web(repoDir: string, opts: Opts = {}) {
       const key = c.kind === "run" ? runs.get(`${c.state}\0${c.id}`) : ideaPty.get(`${c.state}\0${c.text}`);
       if (!key || !live.has(key)) return undefined;
       const st = ptyState(key)!;
+      // A finished run's agent that has ended has nothing left to show or resume.
+      if (!st.alive && (c.status === "done" || c.status === "abandoned")) return undefined;
       return { key, alive: st.alive, asking: st.asking };
     };
   };
@@ -1140,6 +1142,14 @@ export async function web(repoDir: string, opts: Opts = {}) {
             : { ok: false, why: r.why, manual: r.manual, agent: r.agent }, r.ok ? 200 : 500);
         }
 
+        if (path === "/to-idea") {
+          const id = String(body.id ?? "");
+          if (!/^[\w.-]+$/.test(id)) return bad("bad run id");
+          const failed = runToIdea(dir, id);
+          changed();
+          return failed ? bad(failed, 409) : json({ ok: true });
+        }
+
         if (path === "/abort") {
           const id = String(body.id ?? "");
           const why = String(body.why ?? "").trim() || "abandoned from the web board";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaizen-agent",
-  "version": "1.43.0",
+  "version": "1.43.2",
   "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/README.md

@@ -207,11 +207,7 @@ the defaults.
 | `auto_fix.max_iterations` | `2` | Fix/recheck rounds before whatever is left is escalated to you |
 | `review.memory_max_lines` | `100` | The cap on `memory.md`, which every stage of every run reads. Raise only if the lessons are genuinely all load-bearing |
 | `git.auto_commit` | `false` | `true` commits the files a run changed when it is done, by path. Never pushes |
-| `track.default` | `auto` (inferred) | A repo that is always one kind of work, e.g. a docs repo |
 | `backlog.enabled` | `true` | Set `false` to skip both backlog capture points; the run still executes, just without a `06-backlog.md` |
-| `backlog.file` | `06-backlog.md` | The per-run file name. Rarely. |
-| `backlog.statuses` | `[open, done, rejected]` | Rarely. Only `open` items are printed |
-| `backlog.orphan_file` | `backlog.md` | Where open items go when their run is pruned |
 | `state.keep_runs` | `20` | You want a longer or shorter run history |
 
 Mode never overrides a refusal: destructive or irreversible actions still get confirmed

package/skills/kaizen/SKILL.md

@@ -276,7 +276,10 @@ After a subagent returns, update `state.json` yourself in the main thread. Subag
 report; the main thread owns the state machine.
 Before moving any run from `build` to `review`, under either runner, apply the
 *Preview gate* in [`spec-main.md`](spec-main.md): no `## Preview` with a screenshot
-(or a one-line reason there is none) means the build is not done.
+(or a one-line reason there is none) means the build is not done. Before the final
+report and before `stage: "done"`, under either runner and in every mode, apply the
+*Docs gate* there too: the project's docs vault is brought up to date with what the
+run changed.
 
 **Name files, do not narrate them.** The prompt says which paths to read, which
 decisions bind the stage, and what to report back. It does not summarize those files: