kaizen-agent 1.9.3 → 1.10.0

package/cli/state.test.ts

@@ -8,7 +8,7 @@ import {
   readRuns, readInbox, writeInbox, replaceIdea, abandonRun, allBacklog, backlog,
   statusOf, columnOf, parseItem, startedRuns, boardCards, readArchive, setArchived,
   requestOf, agentFlags, readNotes, writeNotes, manualCommand, parseNotes, formatNote, appendNote, saveAttachment,
-  reviewFindings, pickFindings, fixPrompt, gitStatus, runGit, cardsGit, commitPush, readCommit, findTerminal, nativePath, pruneRuns, unrechecked, notice, notifier, notifyArgs, LOGO, type Card,
+  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,
 } from "./state.ts";
 
 let state: string;
@@ -129,6 +129,22 @@ test("reviewFindings: numbered lines under Findings, closed by the backlog; the
   expect(fixPrompt("x", [2, 5])).toContain("fix findings 2, 5 from");
 });
 
+test("approvalPrompt: approve or revise, the comment kept on one line", () => {
+  expect(approvalPrompt("r", "approvals.plan")).toBe("run r: the plan is approved from the board. Record it in 02-approval.md and build it, first asking any of its open questions still unanswered.");
+  expect(approvalPrompt("r", "approvals.review", "  ")).toContain("approved from the board at the final approval");
+  const p = approvalPrompt("r", "approvals.plan", " drop step 3,\n\tkeep \"the rest\" ");
+  expect(p).toContain('to revise: "drop step 3, keep "the rest"".');
+  expect(p).toContain("revise 01-plan.md");
+  expect(p).not.toContain("\n");
+  expect(approvalPrompt("r", "approvals.review", "rename it")).toContain('final approval: "rename it". Record it in 02-approval.md, change the work');
+});
+
+test("approvalPrompt: a plan's answers numbered on one line", () => {
+  const p = approvalPrompt("r", "approvals.plan", undefined, ["Where? — Footer", "Chip?\n — No; keep it\tsmall"]);
+  expect(p).toBe("run r: the plan is approved from the board, with answers to its open questions: 1) Where? — Footer; 2) Chip? — No; keep it small. Record them in 02-approval.md and build the plan with them.");
+  expect(approvalPrompt("r", "approvals.plan", "redo it", ["x"])).toContain("to revise");
+});
+
 test("startedRuns: normalised request bodies", () => {
   expect(startedRuns(state).sort()).toEqual(["# request add oauth login", "# request rename cli flags"]);
 });
@@ -346,6 +362,8 @@ test.skipIf(process.platform === "win32")("findTerminal: a running herdr wins, t
     stub("herdr", 0);
     const h = findTerminal("/p", full)!;
     expect([h.cmd[0], h.cmd[1], h.cmd[4], h.detached]).toEqual(["sh", "-c", "/p", false]);
+    expect(h.cmd[2]).toContain(`pane run "$p" "exec sh $f"`);   // exec: the tab closes with the agent
+    expect(h.cmd[2]).toContain("[ $s = 127 ] || exit $s");   // ...unless it never started
     expect(t.cmd.slice(4)).toEqual(full);   // argv: tmux runs it without its default-shell
     const back = Bun.spawnSync(["/bin/sh", "-c", `printf '%s\\n' ${h.cmd[5]}`]).stdout.toString();
     expect(back).toBe(full.join("\n") + "\n");
@@ -388,7 +406,8 @@ test("findTerminal on Windows names cmd and PowerShell by full path, so a PATH w
     expect(launch).toContain("tab create --cwd 'C:\\p' --label kaizen --focus");
     const typed = /pane run \$Matches\[1\] '(.*)' \}/.exec(launch)![1].replace(/''/g, "'");
     expect(typed).not.toContain("\n");
-    const run = Buffer.from(typed.split(" -EncodedCommand ")[1], "base64").toString("utf16le");
+    expect(typed).toEndWith("; exit");   // the tab closes with the run
+    const run = Buffer.from(typed.split(" -EncodedCommand ")[1].replace(/; exit$/, ""), "base64").toString("utf16le");
     expect(run).toBe("Set-Location 'C:\\p'; & 'claude' '/kaizen it''s\nnote'");
   } finally {
     Object.defineProperty(process, "platform", platform);
@@ -475,3 +494,196 @@ test("files written by Windows PowerShell, with a byte order mark, still read: t
   expect(readRuns(st).map((r) => [r.id, r.stage])).toEqual([["r1", "plan"]]);
   expect(readInbox(st)).toEqual([{ status: "open", text: "first idea" }]);
 });
+
+test("remember on Windows stores one spelling per folder, the one knownProjects returns", () => {
+  // REGISTRY is bound to the home at import, so this runs in a child with a scratch HOME.
+  const home = mkdtempSync(join(tmpdir(), "kz-home-"));
+  const script = `Object.defineProperty(process, "platform", { value: "win32" });
+const { remember, knownProjects, REGISTRY } = await import(${JSON.stringify(join(dirname(import.meta.path), "state.ts"))});
+remember("c:\\\\p"); remember("C:\\\\p"); remember("/c/p");
+console.log(JSON.stringify([require("node:fs").readFileSync(REGISTRY, "utf8"), knownProjects()]));`;
+  try {
+    const p = Bun.spawnSync(["bun", "-e", script], { cwd: home, env: { ...process.env, HOME: home, USERPROFILE: home } });
+    if (p.exitCode !== 0) throw new Error(p.stderr.toString());
+    expect(JSON.parse(p.stdout.toString())).toEqual(["C:\\p\n", ["C:\\p"]]);
+  } finally { rmSync(home, { recursive: true, force: true }); }
+});
+
+test("files saved with CRLF (PowerShell, autocrlf clones) read the same as LF", () => {
+  const lf = join(mkdtempSync(join(tmpdir(), "kz-")), ".kaizen"), crlf = join(mkdtempSync(join(tmpdir(), "kz-")), ".kaizen");
+  const files = {
+    "config.yml": "agent:\n  default: claude\n  claude: { model: opus, effort: high }\n",
+    "inbox.md": "# Inbox\n\n- open: add retry\n- rejected: drop cache\n",
+    "runs/2026-10-01-a/state.json": JSON.stringify({ stage: "build", status: "running" }, null, 2) + "\n",
+    "runs/2026-10-01-a/00-request.md": "# Request\n\n> /kaizen add retry\n",
+  };
+  for (const [dir, eol] of [[lf, "\n"], [crlf, "\r\n"]] as const)
+    for (const [f, text] of Object.entries(files)) {
+      mkdirSync(dirname(join(dir, f)), { recursive: true });
+      writeFileSync(join(dir, f), text.replace(/\n/g, eol));
+    }
+  expect(agentFlags(dirname(crlf), "claude")).toEqual(["--model", "opus", "--effort", "high"]);
+  expect(readInbox(crlf)).toEqual(readInbox(lf));
+  const runs = (s: string) => readRuns(s).map(({ moved, ...r }) => ({ ...r, dir: undefined }));
+  expect(runs(crlf)).toEqual(runs(lf));
+});
+
+// A project whose agent sessions are recorded: close on, one run asked for "tidy logs".
+const sessionProject = () => {
+  const p = mkdtempSync(join(tmpdir(), "kz-sess-"));
+  mkdirSync(join(p, ".kaizen", "runs"), { recursive: true });
+  writeFileSync(join(p, ".kaizen", "config.yml"), "agent:\n  default: claude\n  close: on\n");
+  return p;
+};
+const newRun = (p: string, id: string, request: string, s: object = { stage: "plan", awaiting: "approvals.plan" }) => {
+  mkdirSync(join(p, ".kaizen", "runs", id), { recursive: true });
+  writeFileSync(join(p, ".kaizen", "runs", id, "00-request.md"), `# Request (verbatim)\n\n${request}\n`);
+  writeFileSync(join(p, ".kaizen", "runs", id, "state.json"), JSON.stringify(s));
+};
+
+test("sessionLaunch: claude gets a conversation id, a decision resumes it while its transcript exists, codex starts fresh", () => {
+  const p = sessionProject(), st = join(p, ".kaizen");
+  const saved = process.env.CLAUDE_CONFIG_DIR;
+  process.env.CLAUDE_CONFIG_DIR = mkdtempSync(join(tmpdir(), "kz-claude-"));
+  try {
+    const idea = sessionLaunch(p, "claude", ["/bin/claude", "--model", "opus"], "/kaizen tidy logs", "tidy logs");
+    const [rec] = readSessions(st);
+    expect(rec.sessionId).toMatch(/^[0-9a-f-]{36}$/);
+    expect(idea.fullCmd).toEqual(["/bin/claude", "--model", "opus", "--session-id", rec.sessionId!, "/kaizen tidy logs"]);
+    expect(idea.pidFile).toBe(join(st, "sessions", rec.key + ".pid"));
+    newRun(p, "2026-10-01-tidy-logs", "/kaizen tidy logs");
+    expect(ownerOf(st, rec)).toBe("2026-10-01-tidy-logs");
+
+    // No transcript on disk: a fresh session, with an id of its own.
+    const fresh = sessionLaunch(p, "claude", ["/bin/claude"], "/kaizen run x: approved", "run x: approved", "2026-10-01-tidy-logs");
+    expect(fresh.fullCmd[1]).toBe("--session-id");
+    expect(fresh.fullCmd[2]).not.toBe(rec.sessionId);
+
+    const t = join(process.env.CLAUDE_CONFIG_DIR, "projects", p.replace(/[^A-Za-z0-9]/g, "-"));
+    mkdirSync(t, { recursive: true });
+    writeFileSync(join(t, `${rec.sessionId}.jsonl`), "{}\n");
+    const back = sessionLaunch(p, "claude", ["/bin/claude"], "/kaizen run x: approved", "run x: approved", "2026-10-01-tidy-logs");
+    expect(back.fullCmd).toEqual(["/bin/claude", "--resume", rec.sessionId!, "/kaizen run x: approved"]);
+    expect(readSessions(st).filter((r) => r.run === "2026-10-01-tidy-logs" && r.sessionId === rec.sessionId)).toHaveLength(1);
+
+    // Another tool's record never resumes; codex takes no id at all.
+    expect(sessionLaunch(p, "codex", ["/bin/codex"], "/kaizen run x: approved", "x", "2026-10-01-tidy-logs").fullCmd).toEqual(["/bin/codex", "/kaizen run x: approved"]);
+  } finally {
+    saved === undefined ? delete process.env.CLAUDE_CONFIG_DIR : (process.env.CLAUDE_CONFIG_DIR = saved);
+  }
+  // A folder with no state dir gets no record, and no .kaizen made for one.
+  const bare = mkdtempSync(join(tmpdir(), "kz-bare-"));
+  expect(sessionLaunch(bare, "claude", ["claude"], "/kaizen x", "x")).toMatchObject({ fullCmd: ["claude", "/kaizen x"], pidFile: undefined });
+  expect(existsSync(join(bare, ".kaizen"))).toBe(false);
+});
+
+test("ownerOf: an idea's session belongs to the first run created after it, not an older one with the same words", () => {
+  const p = sessionProject(), st = join(p, ".kaizen");
+  newRun(p, "2026-09-01-old", "/kaizen fix the login page");
+  const rec = { key: "k", run: null, text: "fix the login page", cmd: "claude", sessionId: null, started: Date.now() + 5000 };
+  expect(ownerOf(st, rec)).toBe(null);
+  expect(ownerOf(st, { ...rec, started: 0 })).toBe("2026-09-01-old");
+  expect(ownerOf(st, { ...rec, run: "2026-10-01-x" })).toBe("2026-10-01-x");
+});
+
+test("findTerminal records the agent's PID: a POSIX wrapper that execs it, a PowerShell prefix on Windows", () => {
+  const keys = ["PATH", "HERDR_ENV", "TMUX", "TERMINAL", "SystemRoot", "windir", "ComSpec"];
+  const saved = keys.map((k) => process.env[k]);
+  const platform = Object.getOwnPropertyDescriptor(process, "platform")!;
+  const bin = mkdtempSync(join(tmpdir(), "kz-bin-"));
+  try {
+    process.env.PATH = bin;
+    for (const k of keys.slice(1)) delete process.env[k];
+    writeFileSync(join(bin, "tmux"), "#!/bin/sh\nexit 0\n", { mode: 0o755 });
+    if (process.platform !== "win32") {
+      const t = findTerminal("/p", ["claude", "/kaizen x"], "/s/k.pid")!;
+      expect(t.cmd.slice(4)).toEqual(["sh", "-c", 'echo $$ > "$0"; exec "$@"', "/s/k.pid", "claude", "/kaizen x"]);
+    }
+    Object.defineProperty(process, "platform", { value: "win32" });
+    process.env.SystemRoot = "D:\\Win";
+    const w = findTerminal("C:\\p", ["claude", "/kaizen x"], "C:\\p\\.kaizen\\sessions\\k.pid")!;
+    const ps = Buffer.from(w.cmd.at(-1)!, "base64").toString("utf16le");
+    expect(ps).toBe("$PID | Set-Content -LiteralPath 'C:\\p\\.kaizen\\sessions\\k.pid'; Set-Location 'C:\\p'; & 'claude' '/kaizen x'");
+  } finally {
+    Object.defineProperty(process, "platform", platform);
+    keys.forEach((k, i) => (saved[i] === undefined ? delete process.env[k] : (process.env[k] = saved[i])));
+    rmSync(bin, { recursive: true, force: true });
+  }
+});
+
+test.skipIf(process.platform === "win32")("closeSessions ends only the run's own live sessions launched before the decision", async () => {
+  const p = sessionProject(), st = join(p, ".kaizen"), dir = join(st, "sessions");
+  newRun(p, "2026-10-01-a", "/kaizen a");
+  mkdirSync(dir, { recursive: true });
+  // A stand-in agent through the real wrapper: `kzagent <id>` in its arguments, as
+  // `claude --session-id <id>` would be. `; :` keeps sh from exec'ing sleep itself.
+  const start = (key: string, rec: object) => {
+    writeFileSync(join(dir, key + ".json"), JSON.stringify({ run: "2026-10-01-a", text: "a", cmd: "kzagent", sessionId: "sid-" + key, started: Date.now() - 5000, ...rec }));
+    return Bun.spawn(["sh", "-c", 'echo $$ > "$0"; exec "$@"', join(dir, key + ".pid"), "sh", "-c", "sleep 30; :", "kzagent", "sid-" + key], { stdout: "ignore", stderr: "ignore" });
+  };
+  // Killed by a signal, a process keeps exitCode null; signalCode says it died.
+  const alive = (pr: ReturnType<typeof Bun.spawn>) => pr.exitCode === null && pr.signalCode === null;
+  const procs: Record<string, ReturnType<typeof Bun.spawn>> = {
+    mine: start("mine", {}),
+    later: start("later", { started: Date.now() + 60_000 }),        // the decision's own successor
+    stranger: start("stranger", { cmd: "notkzagent" }),             // a PID that is not this agent
+    other: start("other", { run: "2026-10-01-b" }),                 // another run's
+  };
+  for (let i = 0; i < 100 && Object.keys(procs).some((k) => !existsSync(join(dir, k + ".pid"))); i++) await Bun.sleep(20);
+  writeFileSync(join(dir, "dead.json"), JSON.stringify({ run: "2026-10-01-a", text: "a", cmd: "kzagent", sessionId: null, started: 0 }));
+  writeFileSync(join(dir, "dead.pid"), "999999\n");
+  try {
+    expect(closeSessions(st, "2026-10-01-a", { before: Date.now() })).toBe(1);
+    expect(await procs.mine.exited).not.toBe(0);
+    for (const k of ["later", "stranger", "other"] as const) expect(alive(procs[k])).toBe(true);
+    expect(existsSync(join(dir, "mine.pid"))).toBe(false);
+    expect(existsSync(join(dir, "mine.json"))).toBe(true);       // its conversation id is still needed
+    expect(existsSync(join(dir, "dead.pid"))).toBe(false);
+    expect(existsSync(join(dir, "later.pid"))).toBe(true);
+
+    // Off: nothing is ended.
+    writeFileSync(join(st, "config.yml"), "agent:\n  default: claude\n  close: off\n");
+    expect(closeSessions(st, "2026-10-01-b")).toBe(0);
+    expect(alive(procs.other)).toBe(true);
+    writeFileSync(join(st, "config.yml"), "agent:\n  default: claude\n  close: on\n");
+
+    // The sweep: run b done within the grace keeps its window, past it loses it.
+    newRun(p, "2026-10-01-b", "/kaizen b", { stage: "done", awaiting: null });
+    sweepSessions(st, Date.now());
+    await Bun.sleep(100);
+    expect(alive(procs.other)).toBe(true);
+    sweepSessions(st, Date.now() + CLOSE_GRACE_MS);
+    expect(await procs.other.exited).not.toBe(0);
+    expect(alive(procs.later)).toBe(true);                     // run a is still waiting
+
+    // A fix launched on a done run, after it last moved, is doing the work: kept.
+    const fix = start("fix", { run: "2026-10-01-b", started: Date.now() + 1000 });
+    procs.fix = fix;
+    for (let i = 0; i < 100 && !existsSync(join(dir, "fix.pid")); i++) await Bun.sleep(20);
+    sweepSessions(st, Date.now() + 2 * CLOSE_GRACE_MS);
+    await Bun.sleep(100);
+    expect(alive(fix)).toBe(true);
+
+    // An abandoned run is left to abandonRun; the sweep does not close it, even a
+    // session launched long before the run last moved.
+    const gone = start("gone", { started: 0 });
+    procs.gone = gone;
+    for (let i = 0; i < 100 && !existsSync(join(dir, "gone.pid")); i++) await Bun.sleep(20);
+    writeFileSync(join(st, "runs", "2026-10-01-a", "state.json"), JSON.stringify({ stage: "abandoned", awaiting: null }));
+    sweepSessions(st, Date.now() + 2 * CLOSE_GRACE_MS);
+    await Bun.sleep(100);
+    expect(alive(gone)).toBe(true);
+  } finally {
+    for (const pr of Object.values(procs)) pr.kill();
+  }
+});
+
+test("abandonRun closes the run's recorded sessions", () => {
+  const p = sessionProject(), st = join(p, ".kaizen");
+  newRun(p, "2026-10-01-z", "/kaizen z");
+  mkdirSync(join(st, "sessions"));
+  writeFileSync(join(st, "sessions", "k.json"), JSON.stringify({ run: "2026-10-01-z", text: "z", cmd: "kzagent", sessionId: null, started: 0 }));
+  writeFileSync(join(st, "sessions", "k.pid"), "999999\n");
+  expect(abandonRun(st, "2026-10-01-z", "no")).toBe(null);
+  expect(existsSync(join(st, "sessions", "k.pid"))).toBe(false);
+});

package/cli/state.ts

@@ -80,7 +80,9 @@ const shq = (a: string) => `'${a.replace(/'/g, `'\\''`)}'`;
 // Windows PowerShell 5.1 writes `Set-Content -Encoding utf8` with a byte order mark,
 // and agents on Windows write run files that way. JSON.parse refuses a leading BOM
 // (the run vanished from the board) and it hides a first line from every ^ regex.
-export const readText = (file: string) => readFileSync(file, "utf8").replace(/^\uFEFF/, "");
+// PowerShell and Git for Windows clones (autocrlf) also write CRLF, which breaks
+// every `key:\n` regex the same silent way, so line endings are made LF here too.
+export const readText = (file: string) => readFileSync(file, "utf8").replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
 
 const onPath = (bin: string) => Bun.which(bin, { PATH: process.env.PATH });
 
@@ -98,13 +100,14 @@ function answers(cmd: string[]): boolean {
   const bin = onPath(cmd[0]);
   if (!bin) return false;
   try {
-    return Bun.spawnSync([bin, ...cmd.slice(1)], { stdin: "ignore", stdout: "ignore", stderr: "ignore", timeout: 2000 }).exitCode === 0;
+    return Bun.spawnSync([bin, ...cmd.slice(1)], { stdin: "ignore", stdout: "ignore", stderr: "ignore", timeout: 2000, windowsHide: true }).exitCode === 0;
   } catch {
     return false;
   }
 }
 
-export function findTerminal(cwd: string, fullCmd: string[]): { cmd: string[]; detached: boolean } | null {
+// pidFile: where the launched agent writes its own PID, so closeSessions can end it.
+export function findTerminal(cwd: string, fullCmd: string[], pidFile?: string): { cmd: string[]; detached: boolean } | null {
   const hasDisplay = Boolean(process.env.WAYLAND_DISPLAY || process.env.DISPLAY);
 
   // Windows has no xdg anything, and none of the terminals below exist there.
@@ -116,15 +119,17 @@ export function findTerminal(cwd: string, fullCmd: string[]): { cmd: string[]; d
   if (process.platform === "win32") {
     const q = (a: string) => `'${a.replace(/'/g, "''")}'`;
     const shell = powershellExe();
-    const ps = `Set-Location ${q(cwd)}; & ${fullCmd.map(q).join(" ")}`;
+    // This PowerShell's PID: ending its tree closes the -NoExit tab or window.
+    const ps = `${pidFile ? `$PID | Set-Content -LiteralPath ${q(pidFile)}; ` : ""}Set-Location ${q(cwd)}; & ${fullCmd.map(q).join(" ")}`;
     const enc = Buffer.from(ps, "utf16le").toString("base64");
     // herdr (beta on Windows) first, as elsewhere: a new tab, and the run typed into
     // its PowerShell. Typed text ends at a newline, so what is typed is one line, the
     // same encoded command; -EncodedCommand is also not a script file, so an
-    // execution policy that blocks .ps1 files does not stop it.
+    // execution policy that blocks .ps1 files does not stop it. The trailing exit
+    // closes the tab once the run's PowerShell ends.
     const herdr = onPath("herdr");
     if (herdr && answers([herdr, "workspace", "list"])) {
-      const typed = `& ${q(shell)} -NoProfile -EncodedCommand ${enc}`;
+      const typed = `& ${q(shell)} -NoProfile -EncodedCommand ${enc}; exit`;
       const launch = `$o = & ${q(herdr)} tab create --cwd ${q(cwd)} --label kaizen --focus | Out-String
 if ($o -match '"pane_id":"([^"]*)"') { & ${q(herdr)} pane run $Matches[1] ${q(typed)} } else { exit 1 }`;
       return { cmd: [shell, "-NoProfile", "-EncodedCommand", Buffer.from(launch, "utf16le").toString("base64")], detached: false };
@@ -146,11 +151,18 @@ if ($o -match '"pane_id":"([^"]*)"') { & ${q(herdr)} pane run $Matches[1] ${q(ty
   // in, so $TMUX or $HERDR_ENV only says what was running then. herdr has no "new tab
   // running this", and what it sends a pane is typed into an interactive shell, which
   // eats tabs and quotes its own way -- so the line goes into a one-shot script and
-  // only `sh <path>` is typed.
+  // only `exec sh <path>` is typed. The exec is what closes the tab when the agent
+  // ends: left behind, the pane's own shell would sit at a prompt.
   // ponytail: the mktemp path is typed unquoted; quote it if a TMPDIR with spaces shows up.
+  // The wrapper writes its PID and then becomes the agent, so the PID is the agent's
+  // on every branch below, whatever terminal or launcher sits in front of it.
+  if (pidFile) fullCmd = ["sh", "-c", 'echo $$ > "$0"; exec "$@"', pidFile, ...fullCmd];
   const line = fullCmd.map(shq).join(" ");
+  // The one-shot scripts below end the tab when the agent ends, but a launch that
+  // never started (126/127: not executable, not found) holds it open on its error.
+  const hold = 's=$?; [ $s = 126 ] || [ $s = 127 ] || exit $s; printf "kaizen: the agent did not start. Press Enter to close. "; read _';
   if (answers(["herdr", "workspace", "list"])) {
-    const script = `f=$(mktemp) && printf 'rm -f "$0"\\nexec %s\\n' "$2" > "$f" && p=$(herdr tab create --cwd "$1" --label kaizen --focus | sed -n 's/.*"pane_id":"\\([^"]*\\)".*/\\1/p') && [ -n "$p" ] && herdr pane run "$p" "sh $f"`;
+    const script = `f=$(mktemp) && printf 'rm -f "$0"\\n%s\\n${hold}\\n' "$2" > "$f" && p=$(herdr tab create --cwd "$1" --label kaizen --focus | sed -n 's/.*"pane_id":"\\([^"]*\\)".*/\\1/p') && [ -n "$p" ] && herdr pane run "$p" "exec sh $f"`;
     return { cmd: ["sh", "-c", script, "sh", cwd, line], detached: false };
   }
   if (answers(["tmux", "has-session"])) {
@@ -186,8 +198,17 @@ if ($o -match '"pane_id":"([^"]*)"') { & ${q(herdr)} pane run $Matches[1] ${q(ty
 
   if (process.platform === "darwin") {
     // Terminal types what it is given into the login shell, so, as with herdr, the
-    // line goes into a one-shot script and only `sh <path>` is typed.
-    const script = `f=$(mktemp) && printf 'rm -f "$0"\\ncd %s && exec %s\\n' "$1" "$2" > "$f" && osascript -e "tell application \\"Terminal\\" to do script \\"sh $f\\"" -e 'tell application "Terminal" to activate'`;
+    // line goes into a one-shot script and only `exec sh <path>` is typed. Whether the
+    // window closes when that ends is a profile setting kaizen cannot reach, so the
+    // launcher waits for the tab to run something, then to run nothing, and closes it:
+    // a tab with nothing running closes without Terminal asking first.
+    // ponytail: untested on a real Mac; the try leaves the window as it was if any step fails.
+    const close = ["tell application \"Terminal\"", "set t to do script \"exec sh $f\"", "activate", "try",
+      "repeat 150 times", "if busy of t then exit repeat", "delay 0.2", "end repeat",
+      "repeat while busy of t", "delay 1", "end repeat",
+      "repeat with w in windows", "if tabs of w contains t then close w", "end repeat",
+      "end try", "end tell"].map((l) => `-e ${JSON.stringify(l)}`).join(" ");
+    const script = `f=$(mktemp) && printf 'rm -f "$0"\\n{ cd %s || (exit 127); } && %s\\n${hold}\\n' "$1" "$2" > "$f" && osascript ${close}`;
     return { cmd: ["/bin/sh", "-c", script, "sh", shq(cwd), line], detached: true };
   }
 
@@ -236,6 +257,7 @@ export function nativePath(p: string) {
 // dashboard to stop opening.
 export function remember(projectDir: string) {
   try {
+    projectDir = nativePath(projectDir);
     if (knownProjects().includes(projectDir)) return;
     mkdirSync(dirname(REGISTRY), { recursive: true });
     appendFileSync(REGISTRY, projectDir + "\n");
@@ -275,13 +297,15 @@ export function findProjects(root: string, depth = 4): string[] {
   return found;
 }
 
+// The same spelling knownProjects() gives: a terminal handing out c:\... (lower-case
+// drive) would otherwise make every POST from the board fail "unknown state dir".
 export function locate() {
-  let dir = process.cwd();
+  let dir = nativePath(process.cwd());
   for (;;) {
     if (existsSync(join(dir, ".kaizen"))) return join(dir, ".kaizen");
     if (existsSync(join(dir, ".git"))) return null;
     const up = dirname(dir);
-    if (up === dir) return existsSync(join(home, ".kaizen")) ? join(home, ".kaizen") : null;
+    if (up === dir) return existsSync(join(home, ".kaizen")) ? nativePath(join(home, ".kaizen")) : null;
     dir = up;
   }
 }
@@ -419,6 +443,23 @@ export function fixPrompt(id: string, nums: number[]) {
     + `Leave every other finding alone, and mark the fixed ones done in its 06-backlog.md.`;
 }
 
+// The board's answer to an approval the run is waiting on. The comment is collapsed to
+// one line: where the prompt is typed into a shell (herdr), a newline sends it early.
+// Answers are the plan's open questions answered at the approval, one per question.
+export function approvalPrompt(id: string, awaiting: string, why?: string, answers?: string[]) {
+  const plan = awaiting === "approvals.plan";
+  const one = (t: string) => t.replace(/\s+/g, " ").trim();
+  const note = why === undefined ? undefined : one(why);
+  if (plan && !note && answers?.length) return `run ${id}: the plan is approved from the board, with answers to its open questions: `
+    + answers.map((a, i) => `${i + 1}) ${one(a).replace(/[.;]$/, "")}`).join("; ") + `. Record them in 02-approval.md and build the plan with them.`;
+  if (!note) return plan
+    ? `run ${id}: the plan is approved from the board. Record it in 02-approval.md and build it, first asking any of its open questions still unanswered.`
+    : `run ${id}: the work is approved from the board at the final approval. Record it, write the backlog and finish the run.`;
+  return plan
+    ? `run ${id}: the plan is sent back from the board to revise: "${note}". Record it in 02-approval.md, revise 01-plan.md with it, and stop at the plan approval again.`
+    : `run ${id}: the work is sent back from the board at the final approval: "${note}". Record it in 02-approval.md, change the work to address it, recheck, and stop at the final approval again.`;
+}
+
 // Backlog items are often a reviewer's finding pasted verbatim -- a backticked
 // path, a severity, then the sentence. Split those apart so a list can show the
 // severity and the place as columns and leave the prose to speak for itself.
@@ -716,6 +757,7 @@ export function abandonRun(st: string, id: string, why: string): string | null {
     // resume contract every kaizen tool reads.
     appendFileSync(join(st, "runs", id, "02-approval.md"),
       `\n---\n\n## Abandoned\n\n${new Date().toISOString()} — abandoned from the board.\n\n${why}\n`);
+    closeSessions(st, id);
     return null;
   } catch (err: any) {
     return err?.message ?? String(err);
@@ -851,7 +893,158 @@ export function manualCommand(projectDir: string, agentCmd: string, prompt: stri
     : `cd ${q(projectDir)} && ${bin} ${q(prompt)}`;
 }
 
-export function launchRun(it: Item, from: string): Launch {
+// Agent sessions kaizen opened. Each launch leaves `sessions/<key>.json` in the
+// project's state dir ({run, text, cmd, sessionId, started}) and `<key>.pid`, which
+// the agent writes itself. Only these are ever closed or resumed: a session the user
+// opened by hand has no record.
+export type Session = { key: string; run: string | null; text: string; cmd: string; sessionId: string | null; started: number };
+
+// Tools that take a conversation id at launch and resume it by that id. Every other
+// tool gets a fresh session on each decision, as before.
+const SESSION_FLAGS: Record<string, { start: (id: string) => string[]; resume: (id: string) => string[]; transcript: (cwd: string, id: string) => string }> = {
+  claude: {
+    start: (id) => ["--session-id", id],
+    resume: (id) => ["--resume", id],
+    transcript: (cwd, id) => join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), "projects", cwd.replace(/[^A-Za-z0-9]/g, "-"), `${id}.jsonl`),
+  },
+};
+
+export const CLOSE_GRACE_MS = 2 * 60_000;
+const sessionsDir = (st: string) => join(st, "sessions");
+
+export function readSessions(st: string): Session[] {
+  const dir = sessionsDir(st);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((f) => f.endsWith(".json")).flatMap((f) => {
+    try { return [{ ...JSON.parse(readText(join(dir, f))), key: f.slice(0, -5) }]; } catch { return []; }
+  }).sort((a, b) => a.started - b.started);
+}
+
+// Whose session a record is. A decision's launch names its run. An idea's launch came
+// before its run existed, so it belongs to the first run created after it whose
+// request holds the idea's text: one run per record, never every run that mentions it.
+export function ownerOf(st: string, s: Session): string | null {
+  if (s.run) return s.run;
+  const t = normalise(s.text);
+  let best: string | null = null, at = Infinity;
+  try {
+    for (const id of readdirSync(join(st, "runs"))) {
+      try {
+        const f = join(st, "runs", id, "00-request.md");
+        const st2 = statSync(f), born = st2.birthtimeMs || st2.mtimeMs;
+        // A second of slack: file times come from a coarser clock than Date.now().
+        if (born >= s.started - 1000 && born < at && normalise(readText(f)).includes(t)) { best = id; at = born; }
+      } catch { /* no request yet */ }
+    }
+  } catch { /* no runs dir */ }
+  return best;
+}
+
+// agent.close in the config chain: on unless it says off.
+export function closeEnabled(projectDir: string) {
+  for (const f of [join(projectDir, ".kaizen", "config.yml"), join(home, ".kaizen", "config.yml")]) {
+    try {
+      const m = /^agent:\n(?:[ \t]+.*\n)*?[ \t]+close:[ \t]*(\S+)/m.exec(readText(f));
+      if (m) return !/^(off|false|no)$/i.test(m[1]);
+    } catch { /* absent */ }
+  }
+  return true;
+}
+
+// Whether a live PID is still the agent a record launched, not a stranger that reused
+// the number: the tool's name (and conversation id) in its arguments, started no
+// earlier than the record. On Windows the PID is the PowerShell kaizen opened.
+function isSession(pid: number, s: Session): boolean {
+  try {
+    if (process.platform === "win32") {
+      const out = Bun.spawnSync([sysExe("tasklist.exe"), "/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], { stdin: "ignore", timeout: 5000, windowsHide: true }).stdout.toString();
+      return /^"(powershell|pwsh)\.exe"/i.test(out.trim());
+    }
+    const ps = onPath("ps");
+    if (!ps) return false;
+    const m = /^\s*(\S+)\s+(.*)$/.exec(Bun.spawnSync([ps, "-o", "etime=,args=", "-p", String(pid)], { stdin: "ignore", timeout: 5000 }).stdout.toString().trim());
+    if (!m) return false;
+    // etime is [[dd-]hh:]mm:ss
+    const [d, rest] = m[1].includes("-") ? m[1].split("-") : ["0", m[1]];
+    const secs = rest.split(":").reduce((a, n) => a * 60 + Number(n), 0) + Number(d) * 86400;
+    return Date.now() - secs * 1000 >= s.started - 2000 && m[2].includes(s.cmd) && (!s.sessionId || m[2].includes(s.sessionId));
+  } catch {
+    return false;
+  }
+}
+
+// End one recorded session if it is still running, and drop its PID file either way:
+// without one, the record is never looked at for closing again.
+function closeOne(st: string, s: Session): boolean {
+  const pidFile = join(sessionsDir(st), s.key + ".pid");
+  let closed = false;
+  try {
+    const pid = parseInt(readText(pidFile));
+    if (pid > 0 && isSession(pid, s)) {
+      if (process.platform === "win32") Bun.spawnSync([sysExe("taskkill.exe"), "/T", "/F", "/PID", String(pid)], { stdin: "ignore", stdout: "ignore", stderr: "ignore", timeout: 5000, windowsHide: true });
+      else process.kill(pid, "SIGTERM");
+      closed = true;
+    }
+  } catch { /* already gone */ }
+  rmSync(pidFile, { force: true });
+  return closed;
+}
+
+const openSessions = (st: string) => readSessions(st).filter((s) => existsSync(join(sessionsDir(st), s.key + ".pid")));
+
+// Close every session kaizen opened for a run, those launched before `before` only,
+// so a decision's own successor is never caught. The record stays: it holds the
+// conversation id the next decision resumes. Never throws.
+export function closeSessions(st: string, id: string, opts: { before?: number } = {}): number {
+  try {
+    if (!closeEnabled(dirname(st))) return 0;
+    return openSessions(st).filter((s) => s.started < (opts.before ?? Infinity) && ownerOf(st, s) === id).filter((s) => closeOne(st, s)).length;
+  } catch { return 0; }
+}
+
+// The board's minute sweep: sessions of runs done for longer than the grace, so the
+// final summary can still be read first. Only sessions launched before the run last
+// moved: a fix started on a done run leaves it done until that agent writes, and is
+// the one doing the work. Abandoned runs are closed by abandonRun, not here.
+export function sweepSessions(st: string, now: number) {
+  try {
+    const live = openSessions(st);
+    if (!live.length || !closeEnabled(dirname(st))) return;
+    const runs = new Map(readRuns(st).map((r) => [r.id, r]));
+    for (const s of live) {
+      const r = runs.get(ownerOf(st, s) ?? "");
+      if (r && r.stage === "done" && s.started <= r.moved && now - r.moved >= CLOSE_GRACE_MS) closeOne(st, s);
+    }
+  } catch { /* the next sweep tries again */ }
+}
+
+// The run's conversation to continue: its first recorded one, on this tool, whose
+// transcript is still on disk. None means a fresh session, never a guess.
+export function firstSession(st: string, id: string, cmd: string, cwd: string): Session | null {
+  const f = SESSION_FLAGS[cmd];
+  if (!f) return null;
+  return readSessions(st).find((s) => s.sessionId && s.cmd === cmd && ownerOf(st, s) === id && existsSync(f.transcript(cwd, s.sessionId))) ?? null;
+}
+
+// The agent's argv for a launch, and its record. With a run, a decision: it resumes
+// the run's conversation when there is one. A project without a state dir gets no
+// record; making one here would shadow the user's.
+export function sessionLaunch(projectDir: string, cmd: string, base: string[], prompt: string, text: string, run?: string) {
+  const st = join(projectDir, ".kaizen");
+  if (!existsSync(st)) return { fullCmd: [...base, prompt], pidFile: undefined, record: undefined };
+  const f = SESSION_FLAGS[cmd];
+  const prev = run ? firstSession(st, run, cmd, projectDir) : null;
+  const sessionId = f ? prev?.sessionId ?? crypto.randomUUID() : null;
+  const fullCmd = [...base, ...(f && sessionId ? (prev ? f.resume(sessionId) : f.start(sessionId)) : []), prompt];
+  const key = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  mkdirSync(sessionsDir(st), { recursive: true });
+  const record = join(sessionsDir(st), key + ".json");
+  writeFileSync(record, JSON.stringify({ run: run ?? null, text, cmd, sessionId, started: Date.now() }) + "\n");
+  return { fullCmd, pidFile: join(sessionsDir(st), key + ".pid"), record };
+}
+
+// run: the run a decision is for. Without it, an idea starting a new run.
+export function launchRun(it: Item, from: string, run?: string): Launch {
   const projectDir = projectOf(from);
   // The run will be born here; the board must know the dir or the idea never retires.
   remember(projectDir);
@@ -859,11 +1052,14 @@ export function launchRun(it: Item, from: string): Launch {
   const agentBin = Bun.which(agent.cmd) ?? agent.cmd;
   const prompt = requestOf(it.where ? `/kaizen ${it.text} (${it.where})` : `/kaizen ${it.text}`, it.notes, from);
   const flags = agentFlags(projectDir, agent.cmd);
-  const fullCmd = [agentBin, ...flags, prompt];
+  // 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);
   const manual = manualCommand(projectDir, agent.cmd, prompt, flags);
+  const drop = () => { if (s.record) rmSync(s.record, { force: true }); };
 
-  const term = findTerminal(projectDir, fullCmd);
+  const term = findTerminal(projectDir, s.fullCmd, s.pidFile);
   if (!term) {
+    drop();
     return {
       ok: false, agent, prompt, projectDir, manual,
       why: process.platform === "darwin"
@@ -878,10 +1074,14 @@ export function launchRun(it: Item, from: string): Launch {
       stdout: "ignore",
       stderr: "ignore",
       detached: term.detached,
+      // A detached launch is the terminal window itself; anything else (herdr's
+      // launcher) is plumbing, and must not flash a console on Windows.
+      windowsHide: !term.detached,
     });
     if (term.detached) proc.unref();
     return { ok: true, agent, prompt, projectDir, cmd: term.cmd };
   } catch (err: any) {
+    drop();
     return { ok: false, agent, prompt, projectDir, manual, why: err?.message ?? String(err) };
   }
 }
@@ -902,7 +1102,9 @@ export async function pidOnPort(port: number): Promise<number | null> {
 // ---- git, for the board's commit and push. Always argv, never a shell: the commit
 // message is whatever the user typed. A credential prompt has no terminal to appear
 // in, so git is told not to ask and is given a minute at most.
-const gitOpts = () => ({ env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }, stdin: "ignore" as const, timeout: 60_000 });
+// windowsHide: a board started from the Windows shortcut has no console, so each
+// git it runs would open one of its own -- a window flashing on every refresh.
+const gitOpts = () => ({ env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }, stdin: "ignore" as const, timeout: 60_000, windowsHide: true });
 const gitDone = (code: number | null, stdout: string, stderr: string) => {
   const out = stdout.trimEnd(), err = stderr.trim();
   return { ok: code === 0, out, why: (err || out).split("\n").pop() || "git did not finish" };