kaizen-agent 1.9.0 → 1.9.2

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;
@@ -279,7 +279,6 @@ if (wantWeb) {
   const port = at !== -1 ? Number(Bun.argv[at + 1]) || undefined : undefined;
   const url = `http://127.0.0.1:${port ?? 7420}/`;
   const pidFile = join(home, ".kaizen", "web.pid");
-  const alive = async () => { try { await fetch(url); return true; } catch { return false; } };
 
   if (args.has("--stop")) {
     // The pid file only knows a --daemon; a board started from the shortcut or a
@@ -300,7 +299,10 @@ if (wantWeb) {
   if (args.has("--daemon")) {
     // The daemon is this same command, detached, with the browser left to us:
     // ignored stdio is what lets it outlive the terminal.
-    if (await alive()) {
+    // A board running an older kaizen is not "already running": the child finds
+    // it on the port and replaces it (web() in web.ts).
+    const { current } = await import("./web.ts");
+    if (await current(url)) {
       console.log(`  kaizen web already running at ${url}`);
     } else {
       const argv = Bun.argv.slice(2).filter((a) => a !== "--daemon" && a !== "--no-open");
@@ -310,8 +312,8 @@ if (wantWeb) {
       child.unref();
       mkdirSync(dirname(pidFile), { recursive: true });
       writeFileSync(pidFile, String(child.pid));
-      for (let i = 0; i < 30 && !(await alive()); i++) await Bun.sleep(100);
-      if (!(await alive())) { console.log(`  kaizen web did not come up on ${url}`); process.exit(1); }
+      for (let i = 0; i < 30 && !(await current(url)); i++) await Bun.sleep(100);
+      if (!(await current(url))) { console.log(`  kaizen web did not come up on ${url}`); process.exit(1); }
       console.log(`\n  kaizen web  ${url}  (pid ${child.pid}, detached)`);
       console.log(`  kaizen web --stop to stop it\n`);
     }

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 = "") => {

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
@@ -79,6 +79,14 @@ const shq = (a: string) => `'${a.replace(/'/g, `'\\''`)}'`;
 // Bun.which reads the PATH the process started with unless handed the current one.
 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 +110,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,
     };
   }
@@ -193,7 +213,18 @@ export function knownProjects(): string[] {
   if (!existsSync(REGISTRY)) return [];
   return readFileSync(REGISTRY, "utf8").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
@@ -854,7 +885,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;
     }

package/cli/web.ts

@@ -5,7 +5,7 @@ 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, 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";
@@ -16,6 +16,19 @@ const PAGE = join(dirname(import.meta.dir), "web", "board.html");
 const NOTES_PAGE = join(dirname(import.meta.dir), "web", "notes.html");
 const NOTES_JS = join(dirname(import.meta.dir), "web", "notebook.js");
 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; }
+  catch { return "unknown"; }
+})();
+
+// A board answers at url and runs the installed version. A board from before the
+// version header sends none, so it counts as stale too.
+export async function current(url: string) {
+  const r = await fetch(url, { signal: AbortSignal.timeout(1500) }).catch(() => null);
+  return !!r?.ok && r.headers.get("x-kaizen-version") === VERSION;
+}
 
 type Opts = { port?: number; open?: boolean };
 
@@ -158,11 +171,12 @@ export async function web(repoDir: string, opts: Opts = {}) {
       if (!["EADDRINUSE", "EACCES"].includes((e as { code?: string }).code ?? "")) throw e;
       const url = `http://127.0.0.1:${port}/`;
       const up = await fetch(url, { signal: AbortSignal.timeout(1500) }).then((r) => r.ok, () => false);
-      if (up) { console.log(`\n  kaizen web already at ${url}\n`); if (opts.open !== false) await openApp(url); return; }
-      // A listener that does not answer is a board that hung; it is ours to stop.
+      if (up && await current(url)) { console.log(`\n  kaizen web already at ${url}\n`); if (opts.open !== false) await openApp(url); return; }
+      // A listener that does not answer is a board that hung, and one running an
+      // older kaizen serves 404 for whatever came since; both are ours to stop.
       const pid = await pidOnPort(port);
       if (pid && pid !== process.pid) {
-        try { process.kill(pid, "SIGTERM"); console.log(`  stopped a hung board on ${port} (pid ${pid})`); } catch { /* not ours to kill */ }
+        try { process.kill(pid, "SIGTERM"); console.log(`  stopped a ${up ? "stale" : "hung"} board on ${port} (pid ${pid})`); } catch { /* not ours to kill */ }
         await Bun.sleep(300);
         try { server = serve(port); continue; } catch { /* still held */ }
       }
@@ -174,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.
@@ -186,7 +204,7 @@ export async function web(repoDir: string, opts: Opts = {}) {
         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()), {
-          headers: { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" },
+          headers: { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", "x-kaizen-version": VERSION },
         });
       }
 
@@ -569,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;
@@ -630,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.0",
+  "version": "1.9.2",
   "description": "Staged workflow for AI agents — code, writing, research, operations: plan, human approval, build, independent review, bounded fix loop.",
   "type": "module",
   "bin": {