kaizen-agent 1.9.4 → 1.11.0

package/cli/state.ts

@@ -3,7 +3,7 @@
 // board (`web.ts`) both import this and draw it their own way.
 import { existsSync, readFileSync, readdirSync, appendFileSync, writeFileSync, mkdirSync, statSync, realpathSync, rmSync } from "node:fs";
 import { join, dirname, win32 } from "node:path";
-import { homedir } from "node:os";
+import { homedir, arch, cpus, release, totalmem, version as osVersion } from "node:os";
 
 // The real path: process.cwd() is always physical, so a raw $HOME that crosses a
 // symlink (/home -> var/home) would never compare equal to it.
@@ -20,25 +20,34 @@ export const KNOWN_AGENTS = [
   { name: "Cursor", dir: ".cursor", cmd: "cursor" },
 ];
 
-export function detectDefaultAgent(projectDir: string): { name: string; cmd: string } {
-  const cfgFile = existsSync(join(projectDir, ".kaizen", "config.yml"))
-    ? join(projectDir, ".kaizen", "config.yml")
-    : join(home, ".kaizen", "config.yml");
-  if (existsSync(cfgFile)) {
-    const text = readText(cfgFile);
-    const m = /^\s*agent:\s*\n\s*default:\s*(\S+)/m.exec(text) || /^\s*agent\.default:\s*(\S+)/m.exec(text);
-    if (m && m[1] && m[1] !== "auto") {
-      const found = KNOWN_AGENTS.find((a) => a.cmd === m[1] || a.name.toLowerCase() === m[1].toLowerCase());
-      if (found && Bun.which(found.cmd)) return found;
-    }
+export type Agent = { name: string; cmd: string; note?: string };
+
+// Each config.yml in the chain, project first: the first one that sets a key decides
+// it, so a project file that is silent about `agent` leaves the global one in force.
+const configTexts = (projectDir: string) =>
+  [join(projectDir, ".kaizen", "config.yml"), join(home, ".kaizen", "config.yml")].filter(existsSync).map(readText);
+
+// `want` is a per-run pick; without one, agent.default from the config chain. A
+// wanted tool that is not installed is swapped for the auto choice, and said so.
+export function detectDefaultAgent(projectDir: string, want?: string): Agent {
+  if (!want) for (const t of configTexts(projectDir)) {
+    const m = /^agent:\n(?:[ \t]+.*\n)*?[ \t]+default:[ \t]*["']?([^"'\s]+)/m.exec(t) || /^agent\.default:[ \t]*["']?([^"'\s]+)/m.exec(t);
+    if (m) { want = m[1]; break; }
   }
+  if (!want || want === "auto") return autoAgent(projectDir);
+  const found = KNOWN_AGENTS.find((a) => a.cmd === want || a.name.toLowerCase() === want!.toLowerCase());
+  if (found && onPath(found.cmd)) return found;
+  const a = autoAgent(projectDir);
+  return { ...a, note: `${found?.name ?? want} is not installed; opened ${a.name} instead` };
+}
 
+function autoAgent(projectDir: string): Agent {
   for (const a of KNOWN_AGENTS) {
-    if (existsSync(join(projectDir, a.dir)) && Bun.which(a.cmd)) return a;
+    if (existsSync(join(projectDir, a.dir)) && onPath(a.cmd)) return a;
   }
-  if (Bun.which("claude")) return { name: "Claude Code", cmd: "claude" };
+  if (onPath("claude")) return { name: "Claude Code", cmd: "claude" };
   for (const a of KNOWN_AGENTS) {
-    if (Bun.which(a.cmd)) return a;
+    if (onPath(a.cmd)) return a;
   }
   return { name: "Claude Code", cmd: "claude" };
 }
@@ -56,22 +65,53 @@ const EFFORT_FLAGS: Record<string, (e: string) => string[]> = {
   codex: (e) => ["-c", `model_reasoning_effort=${e}`],
 };
 
-export function agentFlags(projectDir: string, cmd: string, configText?: string): string[] {
-  if (configText === undefined) {
-    const f = [join(projectDir, ".kaizen", "config.yml"), join(home, ".kaizen", "config.yml")].find(existsSync);
-    configText = f ? readText(f) : "";
-  }
+// Each tool's own skip-every-permission-prompt mode, taken only when the Run form's
+// Yolo is picked for that launch. Flags as each tool's --help spells them.
+export const YOLO_FLAGS: Record<string, string[]> = {
+  claude: ["--dangerously-skip-permissions"], agy: ["--dangerously-skip-permissions"],
+  codex: ["--dangerously-bypass-approvals-and-sandbox"], gemini: ["--yolo"], opencode: ["--auto"],
+};
+
+// How each tool takes the opening prompt and stays interactive. agy refuses a bare
+// argument and exits; opencode reads one as the project folder to open.
+const PROMPT_FLAGS: Record<string, string[]> = { agy: ["-i"], opencode: ["--prompt"] };
+export const promptArgs = (cmd: string, prompt: string) => [...(PROMPT_FLAGS[cmd] ?? []), prompt];
+
+// A model typed on the board reaches launch lines and the manual command as text, so
+// only a plain name is taken: no spaces, quotes, `$`, `;`, backticks or globs.
+export const plainModel = (m: string) => /^[A-Za-z0-9][\w.:\/@-]{0,79}$/.test(m);
+
+// The tool's own block in the first config.yml of the chain that has one.
+function agentConfig(projectDir: string, cmd: string, configText?: string) {
   // ponytail: regex over the yaml, like detectDefaultAgent; a parser when a third key needs it
-  const block = new RegExp(`^agent:\\n(?:[ \\t]+.*\\n)*?[ \\t]+${cmd}:[ \\t]*(\\{[^}]*\\}|\\n(?:[ \\t]+[a-z]+:.*\\n?)+)`, "m").exec(configText);
-  if (!block) return [];
-  const get = (k: string) => new RegExp(`\\b${k}:[ \\t]*["']?([^"',}\\s]+)`).exec(block[1])?.[1];
-  const model = get("model"), effort = get("effort");
+  const re = new RegExp(`^agent:\\n(?:[ \\t]+.*\\n)*?[ \\t]+${cmd}:[ \\t]*(\\{[^}]*\\}|\\n(?:[ \\t]+[a-z]+:.*\\n?)+)`, "m");
+  let block: RegExpExecArray | null = null;
+  for (const t of configText === undefined ? configTexts(projectDir) : [configText]) if ((block = re.exec(t))) break;
+  const get = (k: string) => block && new RegExp(`\\b${k}:[ \\t]*["']?([^"',}\\s]+)`).exec(block[1])?.[1];
+  return { model: get("model") || undefined, effort: get("effort") || undefined };
+}
+
+// `model`: a per-run pick, in place of the configured one. Effort stays configured.
+export function agentFlags(projectDir: string, cmd: string, configText?: string, model?: string): string[] {
+  const cfg = agentConfig(projectDir, cmd, configText);
+  const m = model || cfg.model;
   return [
-    ...(model && MODEL_FLAGS[cmd] ? MODEL_FLAGS[cmd](model) : []),
-    ...(effort && EFFORT_FLAGS[cmd] ? EFFORT_FLAGS[cmd](effort) : []),
+    ...(m && MODEL_FLAGS[cmd] ? MODEL_FLAGS[cmd](m) : []),
+    ...(cfg.effort && EFFORT_FLAGS[cmd] ? EFFORT_FLAGS[cmd](cfg.effort) : []),
   ];
 }
 
+// What the board's Run form offers: the installed tools, the one it would pick, and
+// each one's configured model to start the field from.
+export function agentChoices(projectDir: string) {
+  return {
+    default: detectDefaultAgent(projectDir).cmd,
+    agents: KNOWN_AGENTS.filter((a) => onPath(a.cmd)).map((a) => ({
+      name: a.name, cmd: a.cmd, model: agentConfig(projectDir, a.cmd).model ?? "", models: !!MODEL_FLAGS[a.cmd], yolo: !!YOLO_FLAGS[a.cmd],
+    })),
+  };
+}
+
 // One argument as a POSIX shell reads it literally: a prompt carries quotes, `$`,
 // backticks and, with notes, newlines.
 const shq = (a: string) => `'${a.replace(/'/g, `'\\''`)}'`;
@@ -80,7 +120,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 });
 
@@ -104,7 +146,8 @@ function answers(cmd: string[]): boolean {
   }
 }
 
-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 +159,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 +191,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 +238,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 +297,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 +337,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 +483,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.
@@ -481,7 +562,7 @@ export type Card = {
   moved?: number;                                  // runs only: state.json mtime
   title?: string;                                  // runs only: first line of the request
   archived: boolean;                               // hidden from the board unless asked for
-  tags?: string[];                                 // runs only: runner, agent, "unrechecked"
+  tags?: string[];                                 // runs only: runner, agent, "yolo", "unrechecked"
   notes?: string;                                  // inbox notes, or runs/<id>/notes.md
 };
 
@@ -716,6 +797,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);
@@ -810,6 +892,9 @@ export function boardCards(states: string[], now: number): Card[] {
         ? { kind: "idea", status: "starting", text: it.text, state: st, where, column: 1, awaiting: null, dim: true, archived: false, notes: it.notes }
         : { kind: "idea", status: "idea", text: it.text, state: st, where, column: 0, awaiting: null, dim: false, archived: it.status === "archived", notes: it.notes });
     }
+    // Runs started in Yolo. Only yolo records are matched to runs, so a project that
+    // never used it pays one directory read.
+    const yolos = new Set(readSessions(st).filter((s) => s.yolo).map((s) => ownerOf(st, s)));
     for (const r of readRuns(st)) {
       next.push({
         kind: "run", id: r.id, status: statusOf(r, now), text: short(r.id), state: st, where, column: columnOf(r.stage, r.awaiting), moved: r.moved,
@@ -817,7 +902,7 @@ export function boardCards(states: string[], now: number): Card[] {
         awaiting: r.stage === "abandoned" ? null : r.awaiting,
         dim: r.stage === "abandoned",
         archived: archive.has(r.id),
-        tags: [r.runner, r.agent, unrechecked(st, r.id) ? "unrechecked" : undefined].filter((t): t is string => !!t),
+        tags: [r.runner, r.agent, yolos.has(r.id) ? "yolo" : undefined, unrechecked(st, r.id) ? "unrechecked" : undefined].filter((t): t is string => !!t),
         notes: readNotes(st, r.id) || undefined,
       });
     }
@@ -832,8 +917,8 @@ export function boardCards(states: string[], now: number): Card[] {
 // What starting a run needs, minus the screens: the TUI and the web board both
 // launch the same way and only differ in how they tell the user.
 export type Launch =
-  | { ok: true; agent: { name: string; cmd: string }; prompt: string; projectDir: string; cmd: string[] }
-  | { ok: false; agent: { name: string; cmd: string }; prompt: string; projectDir: string; manual: string; why: string };
+  | { ok: true; agent: Agent; prompt: string; projectDir: string; cmd: string[] }
+  | { ok: false; agent: Agent; prompt: string; projectDir: string; manual: string; why: string };
 
 export function projectOf(from: string) {
   return from === join(home, ".kaizen")
@@ -842,7 +927,7 @@ export function projectOf(from: string) {
 }
 
 export function manualCommand(projectDir: string, agentCmd: string, prompt: string, flags: string[] = []) {
-  const bin = [agentCmd, ...flags].join(" ");
+  const bin = [agentCmd, ...flags, ...(PROMPT_FLAGS[agentCmd] ?? [])].join(" ");
   // Pasted into whatever shell the user has. fish reads \' and \\ inside single
   // quotes as escapes, so ' and \ each go in double quotes, which sh and fish read alike.
   const q = (a: string) => `'${a.replace(/['\\]/g, (ch) => (ch === "'" ? `'"'"'` : `'"\\\\"'`))}'`;
@@ -851,19 +936,192 @@ 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, model, 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; model?: string | null; yolo?: boolean; 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 tool and model a run was started with: its latest recorded launch, else the
+// agent its state.json names. A decision continues on these whatever the config says now.
+export function runAgent(st: string, id: string): { cmd: string; model: string | null } | null {
+  const s = readSessions(st).filter((x) => ownerOf(st, x) === id).pop();
+  if (s) return { cmd: s.cmd, model: s.model ?? null };
+  try {
+    const a = JSON.parse(readText(join(st, "runs", id, "state.json"))).agent;
+    if (typeof a === "string" && a) return { cmd: a, model: null };
+  } catch { /* no run */ }
+  return 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, model?: string, yolo?: boolean) {
+  const st = join(projectDir, ".kaizen");
+  if (!existsSync(st)) return { fullCmd: [...base, ...promptArgs(cmd, 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)) : []), ...promptArgs(cmd, 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, model: model ?? null, ...(yolo ? { yolo: true } : {}), 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.
+// pick: the tool, model and yolo chosen for a new run; a decision takes the run's own
+// tool and model, and never yolo.
+export function launchRun(it: Item, from: string, run?: string, pick: { agent?: string; model?: string; yolo?: boolean } = {}): Launch {
   const projectDir = projectOf(from);
   // The run will be born here; the board must know the dir or the idea never retires.
   remember(projectDir);
-  const agent = detectDefaultAgent(projectDir);
+  const own = run && !pick.agent ? runAgent(join(projectDir, ".kaizen"), run) : null;
+  const agent = detectDefaultAgent(projectDir, pick.agent ?? own?.cmd);
   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];
+  const wanted = pick.model ?? (own?.cmd === agent.cmd ? own.model : null) ?? undefined;
+  const model = wanted && plainModel(wanted) ? wanted : undefined;
+  // Yolo was picked for one tool; a fallback to another opens in its normal mode.
+  const yolo = !!pick.yolo && agent.cmd === pick.agent && !!YOLO_FLAGS[agent.cmd];
+  const flags = [...agentFlags(projectDir, agent.cmd, undefined, model), ...(yolo ? YOLO_FLAGS[agent.cmd] : [])];
+  // The idea as its run's request will hold it: without the runner word in front.
+  const s = sessionLaunch(projectDir, agent.cmd, [agentBin, ...flags], prompt, it.text.replace(/^(lite|full|auto|plan)\s+/i, ""), run, model, yolo);
   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"
@@ -885,6 +1143,7 @@ export function launchRun(it: Item, from: string): Launch {
     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) };
   }
 }
@@ -1052,3 +1311,58 @@ export async function commitPush(state: string, id: string, message: string, sho
   record(true);
   return { ok: true, sha };
 }
+
+// ---- issue reports
+
+// Where a bug report goes: package.json's repository, so a fork reports to itself.
+export const REPO_URL = (() => {
+  try {
+    const u = JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf8")).repository.url as string;
+    return u.replace(/^git\+/, "").replace(/\.git$/, "");
+  } catch { return "https://github.com/hfadhlullah/kaizen"; }
+})();
+
+// The machine, as an issue's Environment field. Nothing that names the person: no
+// hostname, no username, no paths.
+export function systemInfo(): string {
+  let osName = osVersion();
+  try {
+    if (process.platform === "linux") osName = /^PRETTY_NAME="?([^"\n]*)/m.exec(readFileSync("/etc/os-release", "utf8"))?.[1] || osName;
+    else if (process.platform === "darwin") osName = `macOS ${Bun.spawnSync(["sw_vers", "-productVersion"]).stdout.toString().trim()}`;
+  } catch { /* the kernel's own version string is still an answer */ }
+  let kaizen = "?";
+  try { kaizen = JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf8")).version; } catch {}
+  const cpu = cpus();
+  return [
+    `kaizen: ${kaizen}`,
+    `OS: ${osName} (${process.platform} ${release()}, ${arch()})`,
+    `CPU: ${cpu[0]?.model.trim() ?? "?"} × ${cpu.length}`,
+    `RAM: ${Math.round(totalmem() / 2 ** 30)} GB`,
+    `bun: ${Bun.version}`,
+    `terminal: ${process.env.TERM_PROGRAM ?? process.env.TERM ?? "?"}`,
+  ].join("\n");
+}
+
+// The home folder as `~`, so a pasted error does not carry the username. Windows paths
+// also arrive JSON-escaped (`C:\\Users\\x`) or with forward slashes, in any case.
+export function scrubHome(s: string, homes = [home, homedir()], win = process.platform === "win32"): string {
+  const forms = [...new Set(homes.filter((h) => h.length > 1).flatMap((h) => [h, h.replaceAll("\\", "\\\\"), h.replaceAll("\\", "/")]))]
+    .sort((a, b) => b.length - a.length);
+  return forms.reduce((t, h) => t.replace(new RegExp(h.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), win ? "gi" : "g"), "~"), s);
+}
+
+// A new-issue link with the bug form filled in. The user reads and submits it on
+// GitHub; nothing is sent from here. GitHub refuses URLs much past 8 KB, so the error
+// text gives way first.
+export function issueUrl(o: { title?: string; what?: string } = {}): string {
+  let what = scrubHome(o.what ?? "");
+  const title = scrubHome(o.title ?? "").slice(0, 120), env = systemInfo();
+  // `what` and `env` fill the form's fields; `body` carries the same text for when GitHub
+  // has no bug.yml (not pushed yet, a fork without it) and ignores the field params.
+  const build = () => `${REPO_URL}/issues/new?` + new URLSearchParams({
+    template: "bug.yml", title, what, env, body: `### What happened\n\n${what}\n\n### Environment\n\n\`\`\`text\n${env}\n\`\`\``,
+  }).toString();
+  let url = build();
+  while (url.length > 7500 && what) { what = what.slice(0, Math.floor(what.length * 0.8)) + "\n…(cut)"; url = build(); if (what.length < 20) what = ""; }
+  return url;
+}