kaizen-agent 1.9.1 → 1.9.3

package/cli/install.ts

@@ -244,7 +244,7 @@ async function noAgent() {
 async function openUrl(url: string) {
   // `start` is a cmd builtin, not a program, so it has to go through cmd.
   if (process.platform === "win32") {
-    try { await Bun.$`cmd /c start "" ${url}`.quiet(); return true; } catch { return false; }
+    try { const { cmdExe } = await import("./state.ts"); await Bun.$`${cmdExe()} /c start "" ${url}`.quiet(); return true; } catch { return false; }
   }
   const opener = process.platform === "darwin" ? "open" : "xdg-open";
   if (!Bun.which(opener)) return false;

package/cli/notes.ts

@@ -1,9 +1,9 @@
 // The notebook's files: plain markdown under <state>/notes/, folders and all, so any
 // editor (Obsidian included) can open the same folder. Every name that arrives from
 // the page goes through safeName before it becomes a path.
-import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmdirSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, realpathSync, renameSync, rmdirSync, statSync, writeFileSync } from "node:fs";
 import { join, dirname, resolve, sep } from "node:path";
-import { boardCards, reviewFindings } from "./state.ts";
+import { boardCards, reviewFindings, readText } from "./state.ts";
 import { wikilinks, boardLink, resolveRun } from "../web/notes-lib.ts";
 
 export type Note = { name: string; mtime: number; text: string };
@@ -49,7 +49,7 @@ export function listNotes(state: string): Note[] {
       try { st = statSync(p); } catch { continue; }
       if (st.isDirectory()) walk(p, prefix + n + "/");
       else if (n.toLowerCase().endsWith(".md") && safeName(prefix + n) === prefix + n.slice(0, -3)) {
-        try { out.push({ name: prefix + n.slice(0, -3), mtime: st.mtimeMs, text: readFileSync(p, "utf8") }); } catch { /* vanished */ }
+        try { out.push({ name: prefix + n.slice(0, -3), mtime: st.mtimeMs, text: readText(p) }); } catch { /* vanished */ }
       }
     }
   };
@@ -65,7 +65,7 @@ export function saveNote(state: string, name: unknown, text: string, base: numbe
   if (!t) return { ok: false, why: "bad name" };
   if (existsSync(t.file)) {
     const now = statSync(t.file).mtimeMs;
-    if (now !== base) return { ok: false, why: "conflict", text: readFileSync(t.file, "utf8"), mtime: now };
+    if (now !== base) return { ok: false, why: "conflict", text: readText(t.file), mtime: now };
   } else if (base) return { ok: false, why: "conflict", text: "", mtime: 0 };
   mkdirSync(dirname(t.file), { recursive: true });
   writeFileSync(t.file, text);
@@ -116,7 +116,7 @@ export function boardIndex(state: string) {
   const cards = boardCards([state], Date.now());
   const backlog = (id: string) => {
     let text = "";
-    try { text = readFileSync(join(state, "runs", id, "06-backlog.md"), "utf8"); } catch { /* none */ }
+    try { text = readText(join(state, "runs", id, "06-backlog.md")); } catch { /* none */ }
     return [...text.matchAll(/^\s*-\s*(open|done|rejected):\s*(.*)$/gm)].map((m, i) => ({ n: i + 1, status: m[1]!, text: m[2]!.trim() }));
   };
   return {

package/cli/settings.ts

@@ -1,8 +1,9 @@
 // Full-screen settings browser for .kaizen/config.yml.
 // Arrow keys move and change; every change is written straight to the file.
-import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync } from "node:fs";
+import { existsSync, writeFileSync, copyFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 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 };
@@ -123,8 +124,8 @@ const SETTINGS: Setting[] = [
 // one place decides what a setting is called, what it may be, and how it is saved.
 export function listSettings(repoRoot: string) {
   const file = locate();
-  const defaults = readFileSync(join(repoRoot, "skills/kaizen/config.default.yml"), "utf8");
-  const text = existsSync(file) ? readFileSync(file, "utf8") : "";
+  const defaults = readText(join(repoRoot, "skills/kaizen/config.default.yml"));
+  const text = existsSync(file) ? readText(file) : "";
   const preset = detectPreset(text, defaults);
   return {
     file: tilde(file),
@@ -141,8 +142,8 @@ export function setSetting(repoRoot: string, key: string, value: string) {
   const file = locate();
   const defaultsPath = join(repoRoot, "skills/kaizen/config.default.yml");
   if (!existsSync(file)) { mkdirSync(dirname(file), { recursive: true }); copyFileSync(defaultsPath, file); }
-  const defaults = readFileSync(defaultsPath, "utf8");
-  const text = readFileSync(file, "utf8");
+  const defaults = readText(defaultsPath);
+  const text = readText(file);
   let updated: string;
   if (key === "preset") {
     if (value === "custom") return { error: "custom is what any other change makes" };
@@ -180,12 +181,12 @@ export async function settings(repoRoot: string, standalone = true) {
   const { stdin, stdout } = process;
   if (!stdin.isTTY) { console.log(`Settings live in ${file}`); return; }
 
-  const defaults = readFileSync(join(repoRoot, "skills/kaizen/config.default.yml"), "utf8");
+  const defaults = readText(join(repoRoot, "skills/kaizen/config.default.yml"));
   let active = 0, saved = "";
   // Screen line -> setting index, rebuilt on every draw; the mouse clicks by line.
   let rowAt: number[] = [];
   const draw = () => {
-    const text = readFileSync(file, "utf8");
+    const text = readText(file);
     const currentPreset = detectPreset(text, defaults);
     // Booleans as a checkbox, numeric scales as a level bar; the file still holds the words.
     const show = (s: Setting, v: string) => {
@@ -227,7 +228,7 @@ export async function settings(repoRoot: string, standalone = true) {
   };
 
   stdout.write("\x1b[?1049h\x1b[?25l");      // alternate screen, hide cursor
-  const mouse = /^\s*ui:\s*\n(?:\s*#.*\n)*\s*mouse:\s*(\S+)/m.exec(readFileSync(file, "utf8"));
+  const mouse = /^\s*ui:\s*\n(?:\s*#.*\n)*\s*mouse:\s*(\S+)/m.exec(readText(file));
   const mouseOn = mouse?.[1] === "true";
   if (mouseOn) { stdout.write("\x1b[?1000h\x1b[?1006h"); mouseArmed = true; }
   stdin.setRawMode(true);
@@ -238,7 +239,7 @@ export async function settings(repoRoot: string, standalone = true) {
     const s = SETTINGS[active]!;
     const wasMouse = s.key === "ui.mouse";
     if (s.text) { saved = c.dim(`type ${s.key} in the board's settings, or in ${tilde(file)}`); return; }
-    const text = readFileSync(file, "utf8");
+    const text = readText(file);
     if (s.key === "preset") {
       const current = detectPreset(text, defaults);
       const presets: PresetName[] = ["low", "medium", "ultra"];

package/cli/state.test.ts

@@ -8,7 +8,7 @@ import {
   readRuns, readInbox, writeInbox, replaceIdea, abandonRun, allBacklog, backlog,
   statusOf, columnOf, parseItem, startedRuns, boardCards, readArchive, setArchived,
   requestOf, agentFlags, readNotes, writeNotes, manualCommand, parseNotes, formatNote, appendNote, saveAttachment,
-  reviewFindings, pickFindings, fixPrompt, gitStatus, runGit, cardsGit, commitPush, readCommit, findTerminal, pruneRuns, unrechecked, notice, notifier, notifyArgs, LOGO, type Card,
+  reviewFindings, pickFindings, fixPrompt, gitStatus, runGit, cardsGit, commitPush, readCommit, findTerminal, nativePath, pruneRuns, unrechecked, notice, notifier, notifyArgs, LOGO, type Card,
 } from "./state.ts";
 
 let state: string;
@@ -355,6 +355,47 @@ test.skipIf(process.platform === "win32")("findTerminal: a running herdr wins, t
   }
 });
 
+test("nativePath on Windows reads the spellings Git Bash writes into the projects registry as one folder", () => {
+  const platform = Object.getOwnPropertyDescriptor(process, "platform")!;
+  try {
+    Object.defineProperty(process, "platform", { value: "win32" });
+    for (const p of ["/c/Users/me/proj", "C:/Users/me/proj", "c:\\Users\\me\\proj\\", "C:\\Users\\me\\proj"])
+      expect(nativePath(p)).toBe("C:\\Users\\me\\proj");
+    expect(nativePath("/d")).toBe("D:\\");
+  } finally { Object.defineProperty(process, "platform", platform); }
+  expect(nativePath("/c/Users/me")).toBe("/c/Users/me");   // elsewhere a path is left alone
+});
+
+test("findTerminal on Windows names cmd and PowerShell by full path, so a PATH without System32 still launches", () => {
+  const keys = ["PATH", "ComSpec", "SystemRoot", "windir"];
+  const saved = keys.map((k) => process.env[k]);
+  const platform = Object.getOwnPropertyDescriptor(process, "platform")!;
+  try {
+    Object.defineProperty(process, "platform", { value: "win32" });
+    process.env.PATH = mkdtempSync(join(tmpdir(), "kz-empty-"));
+    for (const k of keys.slice(1)) delete process.env[k];
+    process.env.SystemRoot = "D:\\Win";
+    const t = findTerminal("C:\\p", ["claude", "/kaizen x"])!;
+    expect(t.cmd[0]).toBe("D:\\Win\\System32\\cmd.exe");
+    expect(t.cmd[6]).toBe("D:\\Win\\System32\\WindowsPowerShell\\v1.0\\powershell.exe");
+    process.env.ComSpec = "E:\\cmd.exe";
+    expect(findTerminal("C:\\p", ["claude"])!.cmd[0]).toBe("E:\\cmd.exe");
+    // A running herdr: a tab, and the run typed into it as one encoded line.
+    writeFileSync(join(process.env.PATH, "herdr"), "#!/bin/sh\nexit 0\n", { mode: 0o755 });
+    const h = findTerminal("C:\\p", ["claude", "/kaizen it's\nnote"])!;
+    expect([h.cmd[0], h.cmd[1], h.cmd[2], h.detached]).toEqual(["D:\\Win\\System32\\WindowsPowerShell\\v1.0\\powershell.exe", "-NoProfile", "-EncodedCommand", false]);
+    const launch = Buffer.from(h.cmd[3], "base64").toString("utf16le");
+    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(run).toBe("Set-Location 'C:\\p'; & 'claude' '/kaizen it''s\nnote'");
+  } finally {
+    Object.defineProperty(process, "platform", platform);
+    keys.forEach((k, i) => (saved[i] === undefined ? delete process.env[k] : (process.env[k] = saved[i])));
+  }
+});
+
 test("prune: only finished runs beyond keep go, open items are rescued, a dry run deletes nothing", () => {
   const st = join(mkdtempSync(join(tmpdir(), "kaizen-prune-")), ".kaizen");
   const mk = (id: string, stage: string, backlog = "") => {
@@ -425,3 +466,12 @@ test("notifier: only a run seen before, saying something new, and not a done the
   expect(notifier.toString()).toStartWith("function notifier(");
   expect(readFileSync(join(import.meta.dir, "..", "web", "board.html"), "utf8")).toContain("(/*notifier*/)()");
 });
+
+test("files written by Windows PowerShell, with a byte order mark, still read: the run shows, the first idea is an idea", () => {
+  const st = join(mkdtempSync(join(tmpdir(), "kaizen-bom-")), ".kaizen");
+  mkdirSync(join(st, "runs", "r1"), { recursive: true });
+  writeFileSync(join(st, "runs", "r1", "state.json"), "" + JSON.stringify({ id: "r1", stage: "plan", awaiting: "approvals.plan" }));
+  writeFileSync(join(st, "inbox.md"), "- open: first idea\n");
+  expect(readRuns(st).map((r) => [r.id, r.stage])).toEqual([["r1", "plan"]]);
+  expect(readInbox(st)).toEqual([{ status: "open", text: "first idea" }]);
+});

package/cli/state.ts

@@ -2,7 +2,7 @@
 // `.kaizen/` directory. No terminal, no HTTP: the TUI (`dashboard.ts`) and the web
 // 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 } from "node:path";
+import { join, dirname, win32 } from "node:path";
 import { homedir } from "node:os";
 
 // The real path: process.cwd() is always physical, so a raw $HOME that crosses a
@@ -25,7 +25,7 @@ export function detectDefaultAgent(projectDir: string): { name: string; cmd: str
     ? join(projectDir, ".kaizen", "config.yml")
     : join(home, ".kaizen", "config.yml");
   if (existsSync(cfgFile)) {
-    const text = readFileSync(cfgFile, "utf8");
+    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());
@@ -59,7 +59,7 @@ const EFFORT_FLAGS: Record<string, (e: string) => string[]> = {
 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 ? readFileSync(f, "utf8") : "";
+    configText = f ? readText(f) : "";
   }
   // 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);
@@ -77,8 +77,21 @@ export function agentFlags(projectDir: string, cmd: string, configText?: string)
 const shq = (a: string) => `'${a.replace(/'/g, `'\\''`)}'`;
 
 // Bun.which reads the PATH the process started with unless handed the current one.
+// 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/, "");
+
 const onPath = (bin: string) => Bun.which(bin, { PATH: process.env.PATH });
 
+// Windows' own programs by full path: a board started from the shortcut or a
+// stripped-down environment can have a PATH without System32, and a bare "cmd.exe"
+// then fails with "Executable not found in $PATH".
+const sysRoot = () => process.env.SystemRoot ?? process.env.windir ?? "C:\\Windows";
+export const sysExe = (name: string) => `${sysRoot()}\\System32\\${name}`;
+export const cmdExe = () => process.env.ComSpec ?? sysExe("cmd.exe");
+export const powershellExe = () => onPath("pwsh.exe") ?? onPath("powershell.exe") ?? sysExe("WindowsPowerShell\\v1.0\\powershell.exe");
+
 // Whether a multiplexer's server is up: its own CLI says so by exit code. spawnSync
 // throws on a missing binary, so the path is resolved first.
 function answers(cmd: string[]): boolean {
@@ -102,16 +115,28 @@ export function findTerminal(cwd: string, fullCmd: string[]): { cmd: string[]; d
   // Terminal hosts the shell when installed; otherwise `start` gives it a window.
   if (process.platform === "win32") {
     const q = (a: string) => `'${a.replace(/'/g, "''")}'`;
-    const shell = Bun.which("pwsh.exe") ? "pwsh.exe" : "powershell.exe";
+    const shell = powershellExe();
     const ps = `Set-Location ${q(cwd)}; & ${fullCmd.map(q).join(" ")}`;
     const enc = Buffer.from(ps, "utf16le").toString("base64");
-    if (Bun.which("wt.exe")) {
-      return { cmd: ["wt.exe", "-d", cwd, shell, "-NoExit", "-EncodedCommand", enc], detached: true };
+    // 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.
+    const herdr = onPath("herdr");
+    if (herdr && answers([herdr, "workspace", "list"])) {
+      const typed = `& ${q(shell)} -NoProfile -EncodedCommand ${enc}`;
+      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 };
+    }
+    const wt = onPath("wt.exe");
+    if (wt) {
+      return { cmd: [wt, "-d", cwd, shell, "-NoExit", "-EncodedCommand", enc], detached: true };
     }
     // `start` reads a title only when quoted; an unquoted word is the command, so
     // "kaizen" here ran kaizen's own launcher. The empty title is what Bun quotes.
     return {
-      cmd: ["cmd.exe", "/c", "start", "", "/D", cwd, shell, "-NoExit", "-EncodedCommand", enc],
+      cmd: [cmdExe(), "/c", "start", "", "/D", cwd, shell, "-NoExit", "-EncodedCommand", enc],
       detached: true,
     };
   }
@@ -191,9 +216,20 @@ export function searchRoots(extra: string[] = []): string[] {
 
 export function knownProjects(): string[] {
   if (!existsSync(REGISTRY)) return [];
-  return readFileSync(REGISTRY, "utf8").split("\n")
+  return readText(REGISTRY).split("\n")
     .map((l) => l.trim())
-    .filter((l) => l && !l.startsWith("#"));
+    .filter((l) => l && !l.startsWith("#"))
+    .map(nativePath)
+    .filter((d, i, all) => all.indexOf(d) === i);
+}
+
+// On Windows the registry is also written by agents running Git Bash, which says
+// /c/Users/me/proj or C:/Users/me/proj. Read as is, the first is C:\c\Users\..., a
+// folder that does not exist, and the project drops off the board. One spelling
+// per folder, drive letter upper case, so the same project is not listed twice.
+export function nativePath(p: string) {
+  if (process.platform !== "win32") return p;
+  return win32.resolve(p.replace(/^\/([a-zA-Z])(?=\/|$)/, "$1:/")).replace(/^[a-z]:/, (d) => d.toUpperCase());
 }
 
 // Never fails the command that triggered it: a read-only home is not a reason for a
@@ -258,7 +294,7 @@ export function readRuns(state: string): Run[] {
   return readdirSync(dir).sort().flatMap((id) => {
     try {
       const file = join(dir, id, "state.json");
-      const s = JSON.parse(readFileSync(file, "utf8"));
+      const s = JSON.parse(readText(file));
       // When the run last moved. Kaizen records no liveness signal, so the file's
       // own mtime is the only evidence that anything is still working on it.
       let moved = 0;
@@ -279,7 +315,7 @@ export function pruneRuns(state: string, keep: number, apply = false): { id: str
     const open = r.stage === "done" ? readBacklog(join(dir, "06-backlog.md")) : [];
     if (apply) {
       const orphanage = join(state, "backlog.md");
-      const gap = existsSync(orphanage) && !readFileSync(orphanage, "utf8").endsWith("\n") ? "\n" : "";
+      const gap = existsSync(orphanage) && !readText(orphanage).endsWith("\n") ? "\n" : "";
       if (open.length) appendFileSync(orphanage, gap + open.map((i) => `- open: ${i} | from ${r.id}\n`).join(""));
       rmSync(dir, { recursive: true, force: true });
     }
@@ -305,13 +341,13 @@ export function backlog(state: string) {
   let n = 0;
   for (const f of files) {
     if (!existsSync(f)) continue;
-    n += (readFileSync(f, "utf8").match(/^\s*-\s*open:/gm) ?? []).length;
+    n += (readText(f).match(/^\s*-\s*open:/gm) ?? []).length;
   }
   return n;
 }
 
 export function version(repo: string) {
-  try { return JSON.parse(readFileSync(join(repo, "package.json"), "utf8")).version; } catch { return ""; }
+  try { return JSON.parse(readText(join(repo, "package.json"))).version; } catch { return ""; }
 }
 // The global state directory is not a project and has no parent worth naming.
 export function label(stateDir: string) {
@@ -323,7 +359,7 @@ export function tilde(p: string) { return p.startsWith(home) ? "~" + p.slice(hom
 // The first few real lines of a file's body, blank lines and headings dropped.
 export function section(file: string, n: number) {
   if (!existsSync(file)) return [];
-  return readFileSync(file, "utf8").split("\n")
+  return readText(file).split("\n")
     .map((l) => l.trim())
     .filter((l) => l && !l.startsWith("#"))
     .slice(0, n);
@@ -331,7 +367,7 @@ export function section(file: string, n: number) {
 
 export function readFindings(file: string) {
   if (!existsSync(file)) return [];
-  return readFileSync(file, "utf8").split("\n")
+  return readText(file).split("\n")
     .map((l) => l.trim())
     .filter((l) => /^\d+\.\s/.test(l) || /\b(critical|high|medium|low)\b:/.test(l));
 }
@@ -346,7 +382,7 @@ export function reviewFindings(state: string, id: string) {
   const base = join(state, "runs", id);
   const read = (f: string) => {
     const p = join(base, f);
-    return existsSync(p) ? readFileSync(p, "utf8").split("\n").map((l) => l.trim()) : [];
+    return existsSync(p) ? readText(p).split("\n").map((l) => l.trim()) : [];
   };
   let lines = read("04-review.md");
   const at = lines.findIndex((l) => /^#+\s*findings/i.test(l));
@@ -359,7 +395,7 @@ export function reviewFindings(state: string, id: string) {
   const closed = read("06-backlog.md").flatMap((l) => /^-\s*(?:done|rejected):\s*(.*)$/.exec(l)?.[1] ?? []);
   const iter = join(base, "05-iterations");
   const rechecked = new Set((existsSync(iter) ? readdirSync(iter) : []).filter((f) => f.endsWith("-recheck.md"))
-    .flatMap((f) => [...readFileSync(join(iter, f), "utf8").matchAll(/finding\s+(\d+)\W{1,8}closed/gi)].map((m) => Number(m[1]))));
+    .flatMap((f) => [...readText(join(iter, f)).matchAll(/finding\s+(\d+)\W{1,8}closed/gi)].map((m) => Number(m[1]))));
   return lines.flatMap((l) => {
     const m = /^(\d+)\.\s+(.+)$/.exec(l);
     if (!m) return [];
@@ -408,7 +444,7 @@ export function tidy(text: string) {
 
 export function readBacklog(file: string) {
   if (!existsSync(file)) return [];
-  return readFileSync(file, "utf8").split("\n")
+  return readText(file).split("\n")
     .map((l) => l.trim())
     .filter((l) => /^-\s*open:/.test(l))
     .map((l) => l.replace(/^-\s*open:\s*/, ""));
@@ -462,7 +498,7 @@ export function startedRuns(state: string): string[] {
   if (!existsSync(dir)) return [];
   const out: string[] = [];
   for (const id of readdirSync(dir)) {
-    try { out.push(normalise(readFileSync(join(dir, id, "00-request.md"), "utf8"))); }
+    try { out.push(normalise(readText(join(dir, id, "00-request.md")))); }
     catch { /* no request file, or unreadable */ }
   }
   return out;
@@ -508,7 +544,7 @@ export function readInbox(state: string): InboxLine[] {
   const f = join(state, "inbox.md");
   if (!existsSync(f)) return [];
   const out: InboxLine[] = [];
-  for (const raw of readFileSync(f, "utf8").split("\n")) {
+  for (const raw of readText(f).split("\n")) {
     const m = /^-\s*(open|started|done|rejected|archived):\s*(.+)$/.exec(raw.trim());
     if (m) { out.push({ status: m[1]!, text: m[2]!.trim() }); continue; }
     // An indented line belongs to the bullet above it; anything else is noise.
@@ -548,7 +584,7 @@ export function requestOf(text: string, notes?: string, state?: string) {
 // Free text beside a run -- what the user learned after the idea became a run.
 // Its own file, never state.json: that shape is the resume contract.
 export function readNotes(state: string, id: string) {
-  try { return readFileSync(join(state, "runs", id, "notes.md"), "utf8"); } catch { return ""; }
+  try { return readText(join(state, "runs", id, "notes.md")); } catch { return ""; }
 }
 
 export function writeNotes(state: string, id: string, text: string): string | null {
@@ -670,7 +706,7 @@ export function short(id: string) { return id.replace(/^\d{4}-\d{2}-\d{2}-/, "")
 export function abandonRun(st: string, id: string, why: string): string | null {
   const file = join(st, "runs", id, "state.json");
   try {
-    const run = JSON.parse(readFileSync(file, "utf8"));
+    const run = JSON.parse(readText(file));
     if (run.stage === "abandoned") return "That run is already abandoned.";
     run.stage = "abandoned";
     run.awaiting = null;
@@ -700,7 +736,7 @@ export function replaceIdea(state: string, text: string, next: InboxLine | null)
 export function readArchive(state: string): Set<string> {
   const f = join(state, "archive.md");
   if (!existsSync(f)) return new Set();
-  return new Set(readFileSync(f, "utf8").split("\n")
+  return new Set(readText(f).split("\n")
     .map((l) => /^-\s*(\S+)/.exec(l.trim())?.[1])
     .filter((x): x is string => !!x));
 }
@@ -741,7 +777,7 @@ export function boardCards(states: string[], now: number): Card[] {
   const bodies = new Map<string, string>();
   const body = (st: string, id: string) => {
     const f = join(st, "runs", id, "00-request.md");
-    if (!bodies.has(f)) { try { bodies.set(f, readFileSync(f, "utf8")); } catch { bodies.set(f, ""); } }
+    if (!bodies.has(f)) { try { bodies.set(f, readText(f)); } catch { bodies.set(f, ""); } }
     return bodies.get(f)!;
   };
   const requests: string[] = [];
@@ -854,7 +890,7 @@ export function launchRun(it: Item, from: string): Launch {
 export async function pidOnPort(port: number): Promise<number | null> {
   try {
     if (process.platform === "win32") {
-      const out = await Bun.$`netstat -ano -p tcp`.text();
+      const out = await Bun.$`${sysExe("netstat.exe")} -ano -p tcp`.text();
       const m = new RegExp(`127\\.0\\.0\\.1:${port}\\s+\\S+\\s+LISTENING\\s+(\\d+)`).exec(out);
       return m ? Number(m[1]) : null;
     }
@@ -913,7 +949,7 @@ function runReport(state: string, id: string) {
   const base = join(state, "runs", id), its = join(base, "05-iterations");
   const fixes = existsSync(its) ? readdirSync(its).filter((n) => n.endsWith("-fix.md")).map((n) => join(its, n)) : [];
   let text = "", at = 0;
-  for (const f of [join(base, "03-impl.md"), ...fixes]) try { text += readFileSync(f, "utf8") + "\n"; at = Math.max(at, statSync(f).mtimeMs); } catch {}
+  for (const f of [join(base, "03-impl.md"), ...fixes]) try { text += readText(f) + "\n"; at = Math.max(at, statSync(f).mtimeMs); } catch {}
   return { text, at };
 }
 const names = (report: string, path: string) => report.includes("`" + path + "`") || report.includes("`" + path + ":");
@@ -956,7 +992,7 @@ export function runGit(state: string, id: string): GitStatus {
 // mtime is the liveness signal.
 export function readCommit(state: string, id: string): { sha: string; pushed: boolean } | null {
   try {
-    const t = readFileSync(join(state, "runs", id, "07-commit.md"), "utf8");
+    const t = readText(join(state, "runs", id, "07-commit.md"));
     return { sha: /^commit: (\S+)/m.exec(t)?.[1] ?? "", pushed: /^pushed: yes/m.test(t) };
   } catch { return null; }
 }

package/cli/web.ts

@@ -1,11 +1,11 @@
 // `kaizen web`: the board in a browser. A loopback HTTP server over state.ts and
 // one HTML page; the page never sees the filesystem, only JSON.
-import { existsSync, readFileSync, readdirSync, statSync, watch, appendFileSync, mkdirSync, type FSWatcher } from "node:fs";
+import { existsSync, readdirSync, statSync, watch, appendFileSync, mkdirSync, type FSWatcher } from "node:fs";
 import { join, dirname } from "node:path";
 import {
   home, type Item, type Card, boardCards, knownProjects, remember, locate, label, tilde, searchRoots, findProjects,
   readInbox, writeInbox, replaceIdea, abandonRun, launchRun, parseItem, short, setArchived, writeNotes,
-  appendNote, saveAttachment, pidOnPort, runGit, cardsGit, readCommit, commitPush, notice, notifier, LOGO,
+  appendNote, saveAttachment, pidOnPort, readText, cmdExe, sysExe, powershellExe, runGit, cardsGit, readCommit, commitPush, notice, notifier, LOGO,
   reviewFindings, pickFindings, fixPrompt,
 } from "./state.ts";
 import { readSources, addSource, removeSource, moveSource, gatherSource, gatherAll, gatherDirs, due } from "./sources.ts";
@@ -19,7 +19,7 @@ const DEFAULT_PORT = 7420;
 // Read once at start: a board keeps the code it started with, so this is what it
 // runs, not what is installed now. `/` sends it; `current()` compares the two.
 const VERSION = (() => {
-  try { return JSON.parse(readFileSync(join(dirname(import.meta.dir), "package.json"), "utf8")).version as string; }
+  try { return JSON.parse(readText(join(dirname(import.meta.dir), "package.json"))).version as string; }
   catch { return "unknown"; }
 })();
 
@@ -188,6 +188,10 @@ export async function web(repoDir: string, opts: Opts = {}) {
   function serve(port: number) { return Bun.serve({
     hostname: "127.0.0.1",
     port,
+    // Bun drops a request after 10s idle by default. A slow /state (git status in a
+    // big repo, on Windows) then comes back as nothing, and the page shows an empty
+    // board. Loopback only, so nothing waits on us but our own page.
+    idleTimeout: 0,
     async fetch(req) {
       // Host first: a hostname rebound to 127.0.0.1 by an attacker's DNS still
       // arrives with that hostname in Host, and gets nothing.
@@ -199,7 +203,7 @@ export async function web(repoDir: string, opts: Opts = {}) {
       if (req.method === "GET" && path === "/") {
         if (!existsSync(PAGE)) return new Response("web/board.html missing", { status: 500 });
         // The page gets the notify rule from state.ts rather than keeping its own copy.
-        return new Response(readFileSync(PAGE, "utf8").replace("/*notifier*/", () => notifier.toString()), {
+        return new Response(readText(PAGE).replace("/*notifier*/", () => notifier.toString()), {
           headers: { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", "x-kaizen-version": VERSION },
         });
       }
@@ -256,7 +260,7 @@ export async function web(repoDir: string, opts: Opts = {}) {
         if (!dir || !states(true).includes(dir) || !/^[\w.-]+$/.test(id)) return bad("no such run", 404);
         const base = join(dir, "runs", id);
         if (!existsSync(base)) return bad("no such run", 404);
-        const read = (f: string) => existsSync(join(base, f)) ? readFileSync(join(base, f), "utf8") : null;
+        const read = (f: string) => existsSync(join(base, f)) ? readText(join(base, f)) : null;
         return json({
           id, short: short(id), state: read("state.json"),
           request: read("00-request.md"), plan: read("01-plan.md"), approval: read("02-approval.md"),
@@ -504,7 +508,7 @@ export async function web(repoDir: string, opts: Opts = {}) {
           if (!/^[\w.-]+$/.test(id)) return bad("bad run id");
           if (dir === join(home, ".kaizen")) return bad("no project to commit", 409);
           let run: any;
-          try { run = JSON.parse(readFileSync(join(dir, "runs", id, "state.json"), "utf8")); } catch { return bad("no such run", 404); }
+          try { run = JSON.parse(readText(join(dir, "runs", id, "state.json"))); } catch { return bad("no such run", 404); }
           if (run.stage !== "done" && run.awaiting !== "approvals.review") return bad("this run is not finished", 409);
           const r = await commitPush(dir, id, String(body.message ?? ""), Array.isArray(body.files) ? body.files.map(String) : []);
           changed();
@@ -519,7 +523,7 @@ export async function web(repoDir: string, opts: Opts = {}) {
           if (!/^[\w.-]+$/.test(id)) return bad("bad run id");
           if (dir === join(home, ".kaizen")) return bad("no project to fix in", 409);
           let run: any;
-          try { run = JSON.parse(readFileSync(join(dir, "runs", id, "state.json"), "utf8")); } catch { return bad("no such run", 404); }
+          try { run = JSON.parse(readText(join(dir, "runs", id, "state.json"))); } catch { return bad("no such run", 404); }
           if (run.stage !== "done" && run.awaiting !== "approvals.review" && run.awaiting !== "findings") return bad("this run is still being worked on", 409);
           const nums = pickFindings(dir, id, body.nums);
           if (!nums) return bad("pick open findings of this review");
@@ -583,7 +587,7 @@ export async function openApp(url: string) {
   } catch { /* fall through to a plain tab */ }
   // `start` is a cmd builtin, not a program, so it has to go through cmd.
   if (process.platform === "win32") {
-    try { await Bun.$`cmd /c start "" ${url}`.quiet(); return true; } catch { return false; }
+    try { await Bun.$`${cmdExe()} /c start "" ${url}`.quiet(); return true; } catch { return false; }
   }
   const opener = process.platform === "darwin" ? "open" : "xdg-open";
   if (!Bun.which(opener)) return false;
@@ -644,8 +648,8 @@ export async function shortcut() {
     mkdirSync(dirname(vbs), { recursive: true });
     const vq = (s: string) => `""${s}""`;                       // a quoted arg inside a VBScript string
     writeFileSync(vbs, `CreateObject("WScript.Shell").Run "${vq(bun)} ${vq(script)} web --daemon", 0, False\r\n`);
-    const ps = `$s=(New-Object -ComObject WScript.Shell).CreateShortcut('${lnk}');$s.TargetPath='wscript.exe';$s.Arguments='"${vbs}"';$s.WorkingDirectory='${home}';${existsSync(ico) ? `$s.IconLocation='${ico}';` : ""}$s.Save()`;
-    await Bun.$`powershell -NoProfile -Command ${ps}`.quiet();
+    const ps = `$s=(New-Object -ComObject WScript.Shell).CreateShortcut('${lnk}');$s.TargetPath='${sysExe("wscript.exe")}';$s.Arguments='"${vbs}"';$s.WorkingDirectory='${home}';${existsSync(ico) ? `$s.IconLocation='${ico}';` : ""}$s.Save()`;
+    await Bun.$`${powershellExe()} -NoProfile -Command ${ps}`.quiet();
     return `${lnk} — double-click starts the board in the background and opens it; kaizen web --stop ends it`;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaizen-agent",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "description": "Staged workflow for AI agents — code, writing, research, operations: plan, human approval, build, independent review, bounded fix loop.",
   "type": "module",
   "bin": {