kaizen-agent 1.9.4 → 1.11.0

package/cli/state.test.ts

@@ -4,11 +4,12 @@ import { test, expect, beforeAll, afterAll } from "bun:test";
 import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, utimesSync, existsSync, readdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
+import { issueUrl, systemInfo, scrubHome, REPO_URL, home as realHome } from "./state.ts";
 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,
+  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,
 } from "./state.ts";
 
 let state: string;
@@ -129,6 +130,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"]);
 });
@@ -230,6 +247,71 @@ test("agentFlags: per-tool model and effort from the agent block, inline or nest
   expect(agentFlags("/p", "codex", "agent:\n  default: codex\n")).toEqual([]);
 });
 
+test("plainModel: a typed model reaches launch lines only as a plain name", () => {
+  for (const m of ["opus", "gpt-5.1", "gemini-2.5-pro", "anthropic/claude-sonnet-4", "o3:high", "x@y"]) expect(plainModel(m)).toBe(true);
+  for (const m of ["", "x; rm -rf ~", "$(id)", "`id`", "a b", "'q'", "\"q\"", "opus[1m]", "-rf", "x".repeat(81)]) expect(plainModel(m)).toBe(false);
+});
+
+test("each tool gets the opening prompt the way it takes one: agy -i, opencode --prompt, the rest bare", () => {
+  const p = mkdtempSync(join(tmpdir(), "kz-"));   // no .kaizen: no session record
+  const argv = (cmd: string) => sessionLaunch(p, cmd, [cmd], "/kaizen x", "x").fullCmd;
+  expect(argv("agy")).toEqual(["agy", "-i", "/kaizen x"]);
+  expect(argv("opencode")).toEqual(["opencode", "--prompt", "/kaizen x"]);
+  expect(argv("codex")).toEqual(["codex", "/kaizen x"]);
+  expect(argv("gemini")).toEqual(["gemini", "/kaizen x"]);
+  if (process.platform !== "win32") expect(manualCommand("/p", "agy", "/kaizen x", ["--model", "m"])).toBe("cd '/p' && agy --model m -i '/kaizen x'");
+});
+
+test.skipIf(process.platform === "win32")("agent choice: project then global config, a note for a missing tool, a pick, and a run keeps its own", () => {
+  // The global config sits at the home bound at import, so this runs in a child with a scratch HOME.
+  const home = mkdtempSync(join(tmpdir(), "kz-home-")), bin = mkdtempSync(join(tmpdir(), "kz-bin-"));
+  for (const t of ["claude", "codex"]) writeFileSync(join(bin, t), "#!/bin/sh\nexit 0\n", { mode: 0o755 });
+  const script = `const S = await import(${JSON.stringify(join(dirname(import.meta.path), "state.ts"))});
+const fs = require("node:fs"), { join } = require("node:path");
+const P = join(process.env.HOME, "proj"), st = join(P, ".kaizen"), G = join(process.env.HOME, ".kaizen");
+fs.mkdirSync(join(st, "runs", "r1"), { recursive: true }); fs.mkdirSync(G, { recursive: true });
+fs.writeFileSync(join(G, "config.yml"), "agent:\\n  default: codex\\n  codex: { model: gpt-5, effort: low }\\n");
+fs.writeFileSync(join(st, "config.yml"), "mode: approve\\n");
+const out = { chain: [S.detectDefaultAgent(P).cmd, S.agentFlags(P, "codex")] };
+fs.writeFileSync(join(st, "config.yml"), "agent:\\n  default: claude\\n  codex:\\n    model: o3\\n");
+out.project = [S.detectDefaultAgent(P).cmd, S.agentFlags(P, "codex")];
+out.missing = S.detectDefaultAgent(P, "gemini");
+out.pick = [S.detectDefaultAgent(P, "codex").cmd, S.agentFlags(P, "codex", undefined, "gpt-5.1")];
+out.choices = S.agentChoices(P);
+// No terminal on PATH or display in env: the launch fails and hands back its manual line.
+const idea = { severity: null, where: null, text: "x", raw: "x" };
+// macOS always drives Terminal.app, which would open a real window: Linux only.
+if (process.platform === "linux") out.yolo = [S.launchRun(idea, P, undefined, { agent: "codex", yolo: true }), S.launchRun(idea, P, undefined, { agent: "codex" }), S.launchRun(idea, P, undefined, { agent: "gemini", yolo: true })].map((r) => [r.ok, r.agent.cmd, /--dangerously-bypass|--dangerously-skip|--yolo/.test(r.manual)]);
+fs.writeFileSync(join(st, "runs", "r1", "state.json"), JSON.stringify({ agent: "codex" }));
+out.fromState = S.runAgent(st, "r1");
+S.sessionLaunch(P, "codex", ["codex"], "/kaizen x", "x", "r1", "gpt-5.1");
+out.fromRecord = S.runAgent(st, "r1");
+out.tags = [S.boardCards([st], Date.now()).find((c) => c.id === "r1")?.tags];
+S.sessionLaunch(P, "codex", ["codex"], "/kaizen x", "x", "r1", undefined, true);
+out.tags.push(S.boardCards([st], Date.now()).find((c) => c.id === "r1")?.tags);
+console.log(JSON.stringify(out));`;
+  try {
+    const p = Bun.spawnSync(["bun", "-e", script], { cwd: home, env: { ...process.env, HOME: home, PATH: bin + ":" + dirname(process.execPath), DISPLAY: "", WAYLAND_DISPLAY: "", TERMINAL: "", TMUX: "", HERDR_ENV: "" } });
+    if (p.exitCode !== 0) throw new Error(p.stderr.toString());
+    expect(JSON.parse(p.stdout.toString())).toEqual({
+      // A project config.yml with no agent block leaves the global one in force.
+      chain: ["codex", ["-m", "gpt-5", "-c", "model_reasoning_effort=low"]],
+      project: ["claude", ["-m", "o3"]],
+      missing: { name: "Claude Code", cmd: "claude", note: "Gemini CLI is not installed; opened Claude Code instead" },
+      pick: ["codex", ["-m", "gpt-5.1"]],
+      choices: { default: "claude", agents: [
+        { name: "Claude Code", cmd: "claude", model: "", models: true, yolo: true },
+        { name: "Codex", cmd: "codex", model: "o3", models: true, yolo: true },
+      ] },
+      // Yolo adds the tool's bypass flag only when asked for, and not to a fallback tool.
+      ...(process.platform === "linux" ? { yolo: [[false, "codex", true], [false, "codex", false], [false, "claude", false]] } : {}),
+      tags: [["codex"], ["codex", "yolo"]],
+      fromState: { cmd: "codex", model: null },
+      fromRecord: { cmd: "codex", model: "gpt-5.1" },
+    });
+  } finally { rmSync(home, { recursive: true, force: true }); rmSync(bin, { recursive: true, force: true }); }
+});
+
 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 });
@@ -346,6 +428,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 +472,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 +560,241 @@ 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);
+});
+
+// The folder dialog cannot be opened in a test, but its script can be checked without
+// showing it: compiled on a Mac, parsed on Windows. Elsewhere only the shape is pinned.
+test("folder dialog: each platform's script is well formed", async () => {
+  const { folderDialog } = await import("./web.ts");
+  const mac = folderDialog("darwin")!, win = folderDialog("win32")!;
+  expect(mac.slice(0, 3)).toEqual(["osascript", "-e", "activate"]);
+  expect(win.at(-1)).toContain("FolderBrowserDialog");
+  if (process.platform === "darwin") {
+    const out = join(mkdtempSync(join(tmpdir(), "kaizen-osa-")), "x.scpt");
+    expect(Bun.spawnSync(["osacompile", ...mac.slice(1), "-o", out]).exitCode).toBe(0);
+  }
+  if (process.platform === "win32") {
+    const check = `$e=$null;[void][System.Management.Automation.Language.Parser]::ParseInput($env:KZ_PS,[ref]$null,[ref]$e);exit $e.Count`;
+    expect(Bun.spawnSync([win[0], "-NoProfile", "-Command", check], { env: { ...process.env, KZ_PS: win.at(-1)! } }).exitCode).toBe(0);
+  }
+});
+
+test("issueUrl prefills the bug form's fields, without the home path", () => {
+  const u = new URL(issueUrl({ title: "boom", what: `ENOENT ${realHome}/Projects/x/.kaizen/state.json` }));
+  expect(`${u.origin}${u.pathname}`).toBe(`${REPO_URL}/issues/new`);
+  expect(u.searchParams.get("what")).toBe("ENOENT ~/Projects/x/.kaizen/state.json");
+  expect(u.searchParams.get("env")).toBe(systemInfo());
+  // Every key but GitHub's own must be a field id in the form, or it is dropped silently.
+  const ids = [...readFileSync(join(import.meta.dir, "..", ".github", "ISSUE_TEMPLATE", "bug.yml"), "utf8").matchAll(/^\s+id: (\S+)/gm)].map((m) => m[1]);
+  for (const k of u.searchParams.keys()) if (!["template", "title", "body"].includes(k)) expect(ids).toContain(k);
+  // Without the form on GitHub only `body` is read, so it must hold the machine too.
+  expect(u.searchParams.get("body")).toContain(systemInfo());
+  expect(u.searchParams.get("body")).toContain("ENOENT ~/Projects/x/.kaizen/state.json");
+  expect(systemInfo()).toMatch(/^kaizen: .+\nOS: .+\nCPU: .+\nRAM: \d+ GB\nbun: /);
+});
+
+test("issueUrl stays under GitHub's URL limit for a huge error", () => {
+  const u = issueUrl({ title: "x".repeat(500), what: "é".repeat(20000) });
+  expect(u.length).toBeLessThan(8000);
+  expect(new URL(u).searchParams.get("what")).toContain("…(cut)");
+});
+
+test("scrubHome hides a Windows home however the error spells it", () => {
+  const h = ["C:\\Users\\Firman"];
+  expect(scrubHome(`open C:\\Users\\Firman\\x, "c:\\\\users\\\\firman\\\\y", C:/Users/Firman/z`, h, true))
+    .toBe(`open ~\\x, "~\\\\y", ~/z`);
+  // Case matters off Windows: /home/Ann is not /home/ann.
+  expect(scrubHome("/home/ann/a /home/Ann/b", ["/home/ann"], false)).toBe("~/a /home/Ann/b");
+});