kaizen-agent 1.10.0 → 1.11.1

package/cli/board.test.ts

@@ -101,3 +101,70 @@ test("planQuestions: a bullet after a blank line is not one more option", () =>
   const qs = planQuestions("## Open questions\nQ: One?\n   - A (recommended)\n   - B\n\n- Note: aside\n")!;
   expect(qs[0]!.options.map((o) => o.label)).toEqual(["A", "B"]);
 });
+
+test("card menu items: appropriate actions and distinct icons across phases", () => {
+  expect(html).toContain('<symbol id="i-open"');
+  expect(html).toContain('<symbol id="i-archive"');
+  expect(html).toContain('<symbol id="i-restore"');
+
+  const ico = (n: string) => `<svg><use href="#i-${n}"/></svg>`;
+  const menuSnippet = (html.slice(html.indexOf("if(k===menuKey){"), html.indexOf("el.innerHTML+=`<div class=\"menu-pop\"", html.indexOf("if(k===menuKey){"))) + "}").replace("const items=[];", "items=[];");
+  const getItems = new Function("c", "archive", `const ico = ${ico.toString()};\nlet k = 1, menuKey = 1, items = [];\n${menuSnippet}\nreturn items;`);
+
+  // Phase 0: Ideas (idea card)
+  const idea = { kind: "idea", status: "idea", column: 0 };
+  const ideaItems = getItems(idea, false);
+  expect(ideaItems.map((i: any) => i ? i[1] : null)).toEqual(["Run", "Edit", "Archive", null, "Reject", "Delete"]);
+  expect(ideaItems[0][2]).toBe(ico("play"));
+  expect(ideaItems[1][2]).toBe(ico("pen"));
+  expect(ideaItems[2][2]).toBe(ico("archive"));
+  expect(ideaItems[4][2]).toBe(ico("x"));
+  expect(ideaItems[5][2]).toBe(ico("trash"));
+
+  // Phase 1: Planning (starting idea)
+  const startingIdea = { kind: "idea", status: "starting", column: 1 };
+  const startItems = getItems(startingIdea, false);
+  expect(startItems.map((i: any) => i ? i[1] : null)).toEqual(["Open", "Run again", "Archive", null, "Remove"]);
+
+  // Phase 1: Planning (run waiting for plan approval)
+  const planWaiting = { kind: "run", status: "waiting", awaiting: "approvals.plan", column: 1 };
+  const planItems = getItems(planWaiting, false);
+  expect(planItems.map((i: any) => i ? i[1] : null)).toEqual(["Review plan", "Archive", null, "Abandon"]);
+  expect(planItems[0][2]).toBe(ico("open"));
+  expect(planItems[1][2]).toBe(ico("archive"));
+  expect(planItems[3][2]).toBe(ico("x"));
+
+  // Phase 2: Building (running run)
+  const buildingRun = { kind: "run", status: "running", column: 2 };
+  const buildItems = getItems(buildingRun, false);
+  expect(buildItems.map((i: any) => i ? i[1] : null)).toEqual(["Open", "Archive", null, "Abandon"]);
+
+  // Phase 3: Review (run waiting for review approval)
+  const reviewWaiting = { kind: "run", status: "waiting", awaiting: "approvals.review", column: 3 };
+  const reviewItems = getItems(reviewWaiting, false);
+  expect(reviewItems.map((i: any) => i ? i[1] : null)).toEqual(["Review work", "Archive", null, "Abandon"]);
+
+  // Phase 3: Review (run waiting on findings)
+  const findingsWaiting = { kind: "run", status: "waiting", awaiting: "findings", column: 3 };
+  const findingsItems = getItems(findingsWaiting, false);
+  expect(findingsItems.map((i: any) => i ? i[1] : null)).toEqual(["See findings", "Archive", null, "Abandon"]);
+
+  // Phase 4: Done (done run - no Abandon)
+  const doneRun = { kind: "run", status: "done", column: 4 };
+  const doneItems = getItems(doneRun, false);
+  expect(doneItems.map((i: any) => i ? i[1] : null)).toEqual(["Open", "Archive"]);
+
+  // Phase 4: Done (abandoned run - no Abandon)
+  const abandonedRun = { kind: "run", status: "abandoned", column: 4 };
+  const abandItems = getItems(abandonedRun, false);
+  expect(abandItems.map((i: any) => i ? i[1] : null)).toEqual(["Open", "Archive"]);
+
+  // Archive view
+  const archRun = getItems(doneRun, true);
+  expect(archRun.map((i: any) => i ? i[1] : null)).toEqual(["Restore", "Open"]);
+  expect(archRun[0][2]).toBe(ico("restore"));
+  expect(archRun[1][2]).toBe(ico("open"));
+
+  const archIdea = getItems(idea, true);
+  expect(archIdea.map((i: any) => i ? i[1] : null)).toEqual(["Restore", "Open", null, "Delete"]);
+});

package/cli/dashboard.ts

@@ -911,6 +911,7 @@ export async function dashboard(
       c.bold(r.cmd[0] === "sh" && r.cmd[2]?.includes("herdr tab create") ? "Started in a new herdr tab" : r.cmd[0] === "tmux" ? "Started in a new tmux window" : "Started in new terminal"),
       "",
       `  ${c.cyan("Agent")}     ${r.agent.name} (${c.bold(r.agent.cmd)})`,
+      ...(r.agent.note ? [`  ${c.amber(r.agent.note)}`] : []),
       `  ${c.cyan("Project")}   ${tilde(r.projectDir)}`,
       `  ${c.cyan("Task")}      ${it.text}`,
       ...(it.where ? [`  ${c.cyan("File")}      ${it.where}`] : []),

package/cli/install.ts

@@ -115,6 +115,20 @@ if (Bun.argv[2] === "sources" || Bun.argv[2] === "gather") {
   process.exit(0);
 }
 
+// `kaizen issue [what happened]` opens kaizen's GitHub bug form with this machine's
+// details filled in; `--env` only prints them.
+if (Bun.argv[2] === "issue") {
+  const { issueUrl, systemInfo } = await import("./state.ts");
+  if (args.has("--env")) { console.log(systemInfo()); process.exit(0); }
+  const what = Bun.argv.slice(3).join(" ");
+  const url = issueUrl({ title: what.split("\n")[0], what });
+  console.log(`\n  ${c.cyan(url)}\n`);
+  console.log(await openUrl(url)
+    ? `  ${c.dim("Opened in your browser. Check it, then submit it on GitHub.")}\n`
+    : `  ${c.dim("Open that link to file the issue.")}\n`);
+  process.exit(0);
+}
+
 if (args.has("--version") || args.has("-v") || args.has("version")) {
   console.log(versionOf(dirname(import.meta.dir)));
   process.exit(0);

package/cli/settings.ts

@@ -6,7 +6,7 @@ import { homedir } from "node:os";
 import { readText } from "./state.ts";
 
 // `text` is a value typed rather than chosen: a path. It has no values to cycle.
-type Setting = { key: string; label: string; group: string; values: string[]; help: string; text?: boolean };
+type Setting = { key: string; label: string; group: string; values: string[]; help: string; text?: boolean; folder?: boolean };
 
 export type PresetName = "low" | "medium" | "ultra";
 
@@ -116,7 +116,7 @@ const SETTINGS: Setting[] = [
   { key: "state.keep_runs", label: "Runs to keep", group: "Project", values: ["5", "10", "20", "50"], help: "Finished runs kept before the oldest is pruned. Open backlog items are rescued first" },
   { key: "dictation.model", label: "Dictation model", group: "Board", values: ["tiny", "base", "small", "large-v3-turbo"], help: "Whisper model the web board dictates with, in the browser. tiny ~60 MB rough; base ~165 MB English-leaning; small ~410 MB accurate across languages; large-v3-turbo ~1.5 GB best, needs a capable GPU. Downloaded once on the next mic press" },
   { key: "sources.every", label: "Gather requests", group: "Board", values: ["off", "1h", "6h", "24h"], help: "How often the board checks your request sources for new ideas while it is running. off: only when you press Gather now" },
-  { key: "board.projects_dir", label: "Projects folder", group: "Board", values: [], text: true, help: `A folder your projects live in, e.g. ${process.platform === "win32" ? join(homedir(), "Projects") : "~/Projects"}. Every folder inside it appears in the board's project list, ready to choose; choosing one sets it up. Empty: only projects kaizen already knows` },
+  { key: "board.projects_dir", label: "Projects folder", group: "Board", values: [], text: true, folder: true, help: `A folder your projects live in, e.g. ${process.platform === "win32" ? join(homedir(), "Projects") : "~/Projects"}. Every folder inside it appears in the board's project list, ready to choose; choosing one sets it up. Empty: only projects kaizen already knows` },
   { key: "ui.mouse", label: "Enable mouse", group: "Terminal", values: ["false", "true"], help: "Click to select, click again to act. While on, the terminal cannot select text with the mouse" },
 ];
 

package/cli/state.test.ts

@@ -4,10 +4,11 @@ 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,
+  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";
 
@@ -246,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 });
@@ -687,3 +753,48 @@ test("abandonRun closes the run's recorded sessions", () => {
   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");
+});

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, `'\\''`)}'`;
@@ -522,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
 };
 
@@ -852,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,
@@ -859,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,
       });
     }
@@ -874,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")
@@ -884,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 === "'" ? `'"'"'` : `'"\\\\"'`))}'`;
@@ -894,10 +937,10 @@ export function manualCommand(projectDir: string, agentCmd: string, prompt: stri
 }
 
 // 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
+// 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; sessionId: string | null; started: number };
+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.
@@ -1026,34 +1069,53 @@ export function firstSession(st: string, id: string, cmd: string, cwd: string):
   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) {
+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, prompt], pidFile: undefined, record: undefined };
+  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)) : []), prompt];
+  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, sessionId, started: Date.now() }) + "\n");
+  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.
-export function launchRun(it: Item, from: string, run?: string): Launch {
+// 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 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);
+  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 }); };
 
@@ -1249,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;
+}