kaizen-agent 1.41.2 → 1.42.0

package/cli/conpty.ts

@@ -0,0 +1,99 @@
+// Windows has no Bun.Terminal, so the in-card terminal there runs through a small
+// ConPTY host: PowerShell compiles the C# below with Add-Type, starts the command in
+// a pseudo console, and bridges it to plain pipes. Its stdout is the screen, its
+// stdin the keys. A resize travels in-band on stdin as ESC ] kzr;<cols>;<rows> BEL,
+// a sequence no key produces, and is taken out before the rest reaches the console.
+const HOST = String.raw`
+using System; using System.IO; using System.Threading; using System.Runtime.InteropServices;
+public static class KzPty {
+  [StructLayout(LayoutKind.Sequential)] struct COORD { public short X, Y; }
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] struct STARTUPINFO {
+    public int cb; public string r, d, t; public int x, y, w, h, cx, cy, fa, fl; public short sw, r2; public IntPtr r3, i, o, e; }
+  [StructLayout(LayoutKind.Sequential)] struct STARTUPINFOEX { public STARTUPINFO si; public IntPtr attrs; }
+  [StructLayout(LayoutKind.Sequential)] struct PI { public IntPtr hp, ht; public int pid, tid; }
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool CreatePipe(out IntPtr r, out IntPtr w, IntPtr a, int s);
+  [DllImport("kernel32.dll")] static extern int CreatePseudoConsole(COORD c, IntPtr i, IntPtr o, uint f, out IntPtr h);
+  [DllImport("kernel32.dll")] static extern int ResizePseudoConsole(IntPtr h, COORD c);
+  [DllImport("kernel32.dll")] static extern void ClosePseudoConsole(IntPtr h);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool InitializeProcThreadAttributeList(IntPtr l, int n, int f, ref IntPtr s);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool UpdateProcThreadAttribute(IntPtr l, uint f, IntPtr a, IntPtr v, IntPtr s, IntPtr p, IntPtr r);
+  [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)] static extern bool CreateProcessW(string app, string cmd, IntPtr pa, IntPtr ta, bool inh, uint f, IntPtr env, string cwd, ref STARTUPINFOEX si, out PI pi);
+  [DllImport("kernel32.dll")] static extern uint WaitForSingleObject(IntPtr h, uint ms);
+  [DllImport("kernel32.dll")] static extern bool GetExitCodeProcess(IntPtr h, out int c);
+  [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr h);
+  static COORD Size(int c, int r) { COORD s; s.X = (short)c; s.Y = (short)r; return s; }
+  static FileStream Of(IntPtr h, FileAccess a) { return new FileStream(new Microsoft.Win32.SafeHandles.SafeFileHandle(h, true), a); }
+  public static int Run(string cmd, int cols, int rows) {
+    IntPtr inR, inW, outR, outW, hpc;
+    if (!CreatePipe(out inR, out inW, IntPtr.Zero, 0) || !CreatePipe(out outR, out outW, IntPtr.Zero, 0)) return 1;
+    int hr = CreatePseudoConsole(Size(cols, rows), inR, outW, 0, out hpc);
+    if (hr != 0) { Console.Error.WriteLine("CreatePseudoConsole failed: " + hr); return 1; }
+    IntPtr sz = IntPtr.Zero;
+    InitializeProcThreadAttributeList(IntPtr.Zero, 1, 0, ref sz);
+    var si = new STARTUPINFOEX(); si.si.cb = Marshal.SizeOf(typeof(STARTUPINFOEX));
+    // STARTF_USESTDHANDLES with none: otherwise the child takes this host's piped stdio, not the console.
+    si.si.fl = 0x100;
+    si.attrs = Marshal.AllocHGlobal(sz);
+    if (!InitializeProcThreadAttributeList(si.attrs, 1, 0, ref sz)
+      || !UpdateProcThreadAttribute(si.attrs, 0, (IntPtr)0x20016, hpc, (IntPtr)IntPtr.Size, IntPtr.Zero, IntPtr.Zero)) return 1;
+    PI pi;
+    if (!CreateProcessW(null, cmd, IntPtr.Zero, IntPtr.Zero, false, 0x80000, IntPtr.Zero, null, ref si, out pi)) {
+      Console.Error.WriteLine("CreateProcess failed: " + Marshal.GetLastWin32Error()); return 1; }
+    // The console holds its own copies; ours would keep the pipes open past its end.
+    CloseHandle(inR); CloseHandle(outW);
+    var input = Of(inW, FileAccess.Write); var output = Of(outR, FileAccess.Read);
+    var stdout = Console.OpenStandardOutput();
+    var pump = new Thread(() => {
+      var b = new byte[16384]; int n;
+      try { while ((n = output.Read(b, 0, b.Length)) > 0) { stdout.Write(b, 0, n); stdout.Flush(); } } catch { }
+    });
+    pump.IsBackground = true; pump.Start();
+    var keys = new Thread(() => {
+      var stdin = Console.OpenStandardInput(); var b = new byte[4096]; int n;
+      var held = new MemoryStream();
+      try {
+        while ((n = stdin.Read(b, 0, b.Length)) > 0) {
+          // ponytail: a UTF-8 character split across two reads decodes as U+FFFD; hold incomplete tails if that shows up.
+          held.Write(b, 0, n);
+          var s = System.Text.Encoding.UTF8.GetString(held.ToArray());
+          // A resize cut in half by the pipe waits for its other half.
+          int keep = s.LastIndexOf("\x1b]kzr;");
+          if (keep >= 0 && s.IndexOf('\x07', keep) < 0) { held = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(s.Substring(keep))); s = s.Substring(0, keep); }
+          else held = new MemoryStream();
+          s = System.Text.RegularExpressions.Regex.Replace(s, "\x1b]kzr;(\\d+);(\\d+)\x07", m => {
+            ResizePseudoConsole(hpc, Size(int.Parse(m.Groups[1].Value), int.Parse(m.Groups[2].Value))); return ""; });
+          var o = System.Text.Encoding.UTF8.GetBytes(s);
+          if (o.Length > 0) { input.Write(o, 0, o.Length); input.Flush(); }
+        }
+      } catch { }
+    });
+    keys.IsBackground = true; keys.Start();
+    WaitForSingleObject(pi.hp, 0xFFFFFFFF);
+    int code; GetExitCodeProcess(pi.hp, out code);
+    // Closing the console flushes its last frame into the pump, then ends it.
+    ClosePseudoConsole(hpc);
+    pump.Join(2000);
+    return code;
+  }
+}`;
+
+// The PowerShell that hosts it: the child's command line, size and directory come in
+// through the environment, so nothing the agent is given passes through a quoting layer.
+const SCRIPT = `Add-Type -TypeDefinition @'
+${HOST}
+'@
+Set-Location -LiteralPath $env:KZ_PTY_CWD
+exit [KzPty]::Run($env:KZ_PTY_CMD, [int]$env:KZ_PTY_COLS, [int]$env:KZ_PTY_ROWS)`;
+
+export const conptyHost = () => Buffer.from(SCRIPT, "utf16le").toString("base64");
+
+export const resizeSeq = (cols: number, rows: number) => `\x1b]kzr;${cols};${rows}\x07`;
+
+// The command line the pseudo console starts: PowerShell running cmd. It finds .cmd
+// shims (npm installs claude as one), which CreateProcess alone does not, and takes
+// the arguments as -EncodedCommand, as findTerminal does, so newlines survive.
+export function innerCommand(shell: string, cmd: string[]): string {
+  const q = (a: string) => `'${a.replace(/'/g, "''")}'`;
+  const enc = Buffer.from(`& ${cmd.map(q).join(" ")}`, "utf16le").toString("base64");
+  return `"${shell}" -NoProfile -ExecutionPolicy Bypass -EncodedCommand ${enc}`;
+}

package/cli/install.ts

@@ -540,6 +540,15 @@ if (interactive && !upgrade && Bun.argv.length === 2) {
   }
 }
 
+// A board on Windows hands its Update here and exits: Windows will not rename
+// ~/kaizen while that board holds files in it. Wait for it to go, and bring a board
+// back on its port however the upgrade ends (finish()).
+const argAt = (flag: string) => { const i = Bun.argv.indexOf(flag); return i === -1 ? NaN : Number(Bun.argv[i + 1]); };
+if (upgrade && argAt("--wait") > 0) {
+  for (let i = 0; i < 100; i++) {
+    try { process.kill(argAt("--wait"), 0); await Bun.sleep(200); } catch { break; }
+  }
+}
 if (upgrade) await clearBunxCache();
 
 // Upgrade means the newest release on npm, whatever the install on disk is: a clone
@@ -551,16 +560,16 @@ if (upgrade) {
   const why = await devCheckout(dest);
   if (why) {
     console.log(`\n  ${c.bold("Not upgraded")}  ${c.dim(`${tilde(dest)} is ${why}; update it with git`)}\n`);
-    process.exit(1);
+    finish(1);
   }
   const latest = await npmLatest();
   if (!latest) {
     console.log(`\n  ${c.bold("Not upgraded")}  ${c.dim(`could not reach npm (kaizen ${now})`)}\n`);
-    process.exit(1);
+    finish(1);
   }
   if (latest === now) {
     console.log(`\n  ${c.bold("Up to date")}${c.dim(`  —  kaizen ${now}`)}\n`);
-    process.exit(0);
+    finish(0);
   }
   step(`fetching kaizen ${latest} from npm`);
   // --force so a stale package manifest cannot resolve the version away, and the
@@ -578,10 +587,10 @@ if (upgrade) {
     console.log(`\n  ${c.bold(`could not install kaizen ${latest}`)}`);
     // npm names a new version before it serves it (its review takes minutes).
     console.log(`  ${c.dim("npm may still be publishing it: try again in a few minutes, or run")} ${c.cyan(`bunx kaizen-agent@${latest}`)}\n`);
-    process.exit(1);
+    finish(1);
   }
   console.log(`\n  ${c.bold("Upgraded")}  ${c.dim(now)} → ${c.green(after)}\n  ${c.dim("Restart Claude Code to pick up any new slash commands.")}\n`);
-  process.exit(0);
+  finish(0);
 }
 if (!check && !upgrade) await welcome();
 
@@ -1065,6 +1074,16 @@ if (blocked) process.exit(1);
 
 // ---------------------------------------------------------------- helpers
 
+function finish(code: number): never {
+  const port = argAt("--restart");
+  if (port > 0) {
+    Bun.spawn([process.execPath, join(installDir(), "cli", "install.ts"), "web", "--port", String(port), "--no-open", "--foreground"], {
+      cwd: home, detached: true, stdio: ["ignore", "ignore", "ignore"], windowsHide: true,
+    }).unref();
+  }
+  process.exit(code);
+}
+
 function step(msg: string) { console.log(`  ${c.green("+")} ${msg}`); }
 
 // Runs the upgrade and reports what it actually did, version to version, so the

package/cli/pty.test.ts

@@ -5,7 +5,8 @@ import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, realpa
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { launchMode, closeSessions, readSessions, sweepSessions, CLOSE_GRACE_MS } from "./state.ts";
-import { loginEnv, startPty, writePty } from "./pty.ts";
+import { loginEnv, startPty, writePty, attachPty, ptyState } from "./pty.ts";
+import { conptyHost, innerCommand, resizeSeq } from "./conpty.ts";
 
 const root = realpathSync(mkdtempSync(join(tmpdir(), "kaizen-pty-")));
 
@@ -194,3 +195,27 @@ test("asking: Claude Code and Codex prompts count as a question, ordinary output
   expect(asking("Do you want to make this edit to cli/pty.ts?")).toBe(true);
   expect(asking("Reading cli/pty.ts\r\n\x1b[2K✻ Thinking… 1. step one done")).toBe(false);
 });
+
+test("Windows ConPTY host: resize travels in-band, the agent command survives quotes and newlines", () => {
+  expect(resizeSeq(100, 40)).toBe("\x1b]kzr;100;40\x07");
+  const line = innerCommand("C:\\ps.exe", ["claude", "it's\nhere"]);
+  const enc = line.split(" ").pop()!;
+  expect(line.startsWith('"C:\\ps.exe" -NoProfile -ExecutionPolicy Bypass -EncodedCommand ')).toBe(true);
+  expect(Buffer.from(enc, "base64").toString("utf16le")).toBe("& 'claude' 'it''s\nhere'");
+  // The host script decodes to PowerShell carrying the C# whole.
+  expect(Buffer.from(conptyHost(), "base64").toString("utf16le")).toContain("CreatePseudoConsole");
+});
+
+test.skipIf(process.platform !== "win32")("on Windows a card agent runs in a pseudo console and takes typed input", async () => {
+  const key = `win-${Date.now()}`;
+  const out: string[] = [];
+  startPty(key, ["cmd.exe", "/q", "/k", "echo ready"], root);
+  attachPty(key, (d) => { if (d) out.push(d); });
+  const until = async (re: RegExp) => { for (let i = 0; i < 300 && !re.test(out.join("")); i++) await Bun.sleep(100); return out.join(""); };
+  expect(await until(/ready/)).toContain("ready");
+  writePty(key, "echo typed-%OS%\r");
+  expect(await until(/typed-Windows_NT/)).toContain("typed-Windows_NT");
+  writePty(key, "exit\r");
+  for (let i = 0; i < 100 && ptyState(key)?.alive; i++) await Bun.sleep(100);
+  expect(ptyState(key)?.alive).toBe(false);
+}, 60_000);

package/cli/pty.ts

@@ -1,8 +1,15 @@
 // Agents the web board runs itself, each in a pseudo-terminal the board owns, so a
 // card can show the agent's screen and pass it the user's typing (agent.launch: card).
 // They live in this process: the board stopping ends them, as closing a terminal
-// window ends the agent in it. Bun has no pseudo-terminal on Windows.
+// window ends the agent in it. Bun has no pseudo-terminal on Windows; there the
+// agent runs under a ConPTY host (conpty.ts) spoken to over pipes.
 import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { conptyHost, innerCommand, resizeSeq } from "./conpty.ts";
+
+const WIN = process.platform === "win32";
+// Windows PowerShell, which every Windows has, both hosts the console and runs the agent in it.
+const winPs = () => join(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
 
 type Pty = { proc: Bun.Subprocess; out: string[]; size: number; listeners: Set<(d: string | null) => void>; exit: number | null; asking: boolean; quiet?: Timer; total: number; since: number; onChange?: () => void };
 
@@ -24,7 +31,7 @@ export const asking = (screen: string) =>
 const QUIET_MS = 700;
 // Bun gained pseudo-terminals in 1.3.5; an older one spawns without a tty, so it
 // keeps opening terminal windows.
-export const ptySupported = process.platform !== "win32" && typeof (Bun as any).Terminal === "function";
+export const ptySupported = WIN || typeof (Bun as any).Terminal === "function";
 
 // Starts cmd in a new pseudo-terminal under `key` and returns its PID. pidFile gets
 // that PID, the agent's own, so closeSessions can end it like any launched session.
@@ -46,7 +53,21 @@ export function startPty(key: string, cmd: string[], cwd: string, pidFile?: stri
       flag(p.exit === null && n > 0 && asking(p.out.join("").slice(-n)));
     }, QUIET_MS);
   };
-  p.proc = Bun.spawn(cmd, {
+  if (WIN) {
+    const ps = winPs();
+    p.proc = Bun.spawn([ps, "-NoProfile", "-NonInteractive", "-EncodedCommand", conptyHost()], {
+      cwd,
+      env: { ...process.env, KZ_PTY_CMD: innerCommand(ps, cmd), KZ_PTY_CWD: cwd, KZ_PTY_COLS: "120", KZ_PTY_ROWS: "32" },
+      stdin: "pipe", stdout: "pipe", stderr: "pipe", windowsHide: true,
+    });
+    const read = async (s: ReadableStream<Uint8Array>) => {
+      const d = new TextDecoder();
+      for await (const c of s) push(d.decode(c, { stream: true }));
+    };
+    read(p.proc.stdout as ReadableStream<Uint8Array>).catch(() => {});
+    // The host's own failures (Add-Type, CreateProcess) land on the screen, not nowhere.
+    read(p.proc.stderr as ReadableStream<Uint8Array>).catch(() => {});
+  } else p.proc = Bun.spawn(cmd, {
     cwd,
     env: { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor" },
     terminal: { cols: 120, rows: 32, data: (_t, d) => push(dec.decode(d, { stream: true })) },
@@ -82,13 +103,18 @@ export function writePty(key: string, d: string) {
   if (!p || p.exit !== null) return;
   p.since = p.total;
   if (p.asking) { p.asking = false; p.onChange?.(); }
-  p.proc.terminal?.write(d);
+  send(p, d);
 }
 
+const send = (p: Pty, d: string) => {
+  if (!WIN) return p.proc.terminal?.write(d);
+  try { (p.proc.stdin as Bun.FileSink).write(d); (p.proc.stdin as Bun.FileSink).flush(); } catch { /* host gone */ }
+};
+
 export function resizePty(key: string, cols: number, rows: number) {
   const p = ptys.get(key);
   const c = Math.max(10, Math.min(500, cols | 0)), r = Math.max(5, Math.min(300, rows | 0));
-  if (p && p.exit === null) p.proc.terminal?.resize(c, r);
+  if (p && p.exit === null) WIN ? send(p, resizeSeq(c, r)) : p.proc.terminal?.resize(c, r);
 }
 
 export const ptyKeys = () => [...ptys.keys()];

package/cli/state.test.ts

@@ -796,7 +796,7 @@ test("findTerminal records the agent's PID: a POSIX wrapper that execs it, a Pow
     process.env.SystemRoot = "D:\\Win";
     const w = findTerminal("C:\\p", ["claude", "/kaizen x"], "C:\\p\\.kaizen\\sessions\\k.pid")!;
     const ps = Buffer.from(w.cmd.at(-1)!, "base64").toString("utf16le");
-    expect(ps).toBe("$PID | Set-Content -LiteralPath 'C:\\p\\.kaizen\\sessions\\k.pid'; Set-Location 'C:\\p'; & 'claude' '/kaizen x'");
+    expect(ps).toBe("$PID | Set-Content -LiteralPath 'C:\\p\\.kaizen\\sessions\\k.pid'; Set-Location 'C:\\p'; & 'claude' '/kaizen x'; if (-not (Test-Path -LiteralPath 'C:\\p\\.kaizen\\sessions\\k.pid')) { exit 0 }");
   } finally {
     Object.defineProperty(process, "platform", platform);
     keys.forEach((k, i) => (saved[i] === undefined ? delete process.env[k] : (process.env[k] = saved[i])));
@@ -1148,3 +1148,11 @@ test("parent/child: a Parent line links a run and an idea to the run that filed
   expect(boardCards([st], Date.now()).find((k) => k.text === "next thing")!.parent).toBe("2026-01-02-b");
   rmSync(dirname(st), { recursive: true, force: true });
 });
+
+test("winShim swaps an npm .cmd shim for the .ps1 beside it, so a multi-line prompt survives", () => {
+  const { winShim } = stateModule;
+  const has = (p: string) => p === "C:\\npm\\claude.ps1";
+  expect(winShim("C:\\npm\\claude.cmd", has)).toBe("C:\\npm\\claude.ps1");
+  expect(winShim("C:\\npm\\codex.CMD", () => false)).toBe("C:\\npm\\codex.CMD");
+  expect(winShim("C:\\bin\\claude.exe", () => true)).toBe("C:\\bin\\claude.exe");
+});

package/cli/state.ts

@@ -130,6 +130,14 @@ export const readText = (file: string) => readFileSync(file, "utf8").replace(/^\
 
 const onPath = (bin: string) => Bun.which(bin, { PATH: process.env.PATH });
 
+// npm installs a Windows tool as x.cmd with x.ps1 beside it. PowerShell hands a .cmd to
+// cmd.exe, which ends the command line at the first newline -- a prompt with notes lost
+// everything after its first line. The .ps1 runs in PowerShell itself, argument intact.
+export const winShim = (bin: string, exists = existsSync) => {
+  const ps1 = bin.replace(/\.cmd$/i, ".ps1");
+  return ps1 !== bin && exists(ps1) ? ps1 : bin;
+};
+
 // 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".
@@ -164,7 +172,10 @@ export function findTerminal(cwd: string, fullCmd: string[], pidFile?: string):
     const q = (a: string) => `'${a.replace(/'/g, "''")}'`;
     const shell = powershellExe();
     // 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(" ")}`;
+    // The pid file gone after the agent means closeSessions ended it: exit 0, which closes
+    // the tab (Windows Terminal keeps one open after a non-zero exit). An agent that ends
+    // by itself leaves the window open, -NoExit, so what it printed can still be read.
+    const ps = `${pidFile ? `$PID | Set-Content -LiteralPath ${q(pidFile)}; ` : ""}Set-Location ${q(cwd)}; & ${fullCmd.map(q).join(" ")}${pidFile ? `; if (-not (Test-Path -LiteralPath ${q(pidFile)})) { exit 0 }` : ""}`;
     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
@@ -173,19 +184,19 @@ export function findTerminal(cwd: string, fullCmd: string[], pidFile?: string):
     // 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}; exit`;
+      const typed = `& ${q(shell)} -NoProfile -ExecutionPolicy Bypass -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 };
     }
     const wt = onPath("wt.exe");
     if (wt) {
-      return { cmd: [wt, "-d", cwd, shell, "-NoExit", "-EncodedCommand", enc], detached: true };
+      return { cmd: [wt, "-d", cwd, shell, "-NoExit", "-ExecutionPolicy", "Bypass", "-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: [cmdExe(), "/c", "start", "", "/D", cwd, shell, "-NoExit", "-EncodedCommand", enc],
+      cmd: [cmdExe(), "/c", "start", "", "/D", cwd, shell, "-NoExit", "-ExecutionPolicy", "Bypass", "-EncodedCommand", enc],
       detached: true,
     };
   }
@@ -1297,8 +1308,14 @@ function closeOne(st: string, s: Session): boolean {
   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");
+      if (process.platform === "win32") {
+        // The pid file first, then only the PowerShell's children: the PowerShell sees the
+        // file gone and exits 0 by itself, closing its tab. Killed, it exits 1 and the tab stays.
+        rmSync(pidFile, { force: true });
+        const kids = Bun.spawnSync([powershellExe(), "-NoProfile", "-NonInteractive", "-Command", `(Get-CimInstance Win32_Process -Filter 'ParentProcessId=${pid}').ProcessId`], { stdin: "ignore", stderr: "ignore", timeout: 10000, windowsHide: true }).stdout.toString().match(/\d+/g) ?? [];
+        // No children (a launch from before this): the PowerShell itself, as before.
+        for (const k of kids.length ? kids : [String(pid)]) Bun.spawnSync([sysExe("taskkill.exe"), "/T", "/F", "/PID", k], { stdin: "ignore", stdout: "ignore", stderr: "ignore", timeout: 5000, windowsHide: true });
+      } else process.kill(pid, "SIGTERM");
       closed = true;
     }
   } catch { /* already gone */ }
@@ -1444,7 +1461,7 @@ export function launchRun(it: Item, from: string, run?: string, pick: { agent?:
   // agent inheriting it runs as its child and keeps no transcript, so nothing to resume.
   for (const k of Object.keys(process.env)) if (CHILD_ENV.test(k)) delete process.env[k];
   // onPath, not Bun.which: the board may have taken a login shell's PATH after it started.
-  const agentBin = onPath(agent.cmd) ?? agent.cmd;
+  const agentBin = winShim(onPath(agent.cmd) ?? agent.cmd);
   // No text: a run's conversation reopened as it was, with nothing sent to it.
   const prompt = !it.text ? "" : requestOf(it.where ? `/kaizen ${it.text} (${it.where})` : `/kaizen ${it.text}`, it.notes, from);
   const wanted = pick.model ?? (own?.cmd === agent.cmd ? own.model : null) ?? undefined;

package/cli/web.ts

@@ -1,7 +1,7 @@
 // `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, readdirSync, statSync, watch, appendFileSync, mkdirSync, type FSWatcher } from "node:fs";
-import { join, dirname, resolve, sep } from "node:path";
+import { existsSync, readdirSync, statSync, watch, appendFileSync, mkdirSync, cpSync, rmSync, type FSWatcher } from "node:fs";
+import { join, dirname, resolve, sep, basename } from "node:path";
 import {
   home, type Item, type Card, boardCards, knownProjects, remember, locate, label, tilde, searchRoots, findProjects,
   readInbox, writeInbox, replaceIdea, moveIdea, abandonRun, launchRun, parseItem, agentChoices, projectOf, KNOWN_AGENTS, plainModel, short, setArchived, writeNotes,
@@ -550,7 +550,7 @@ export async function web(repoDir: string, opts: Opts = {}) {
         const v = await npmLatest(url.searchParams.has("fresh"));
         const update = !!v && newer(v, VERSION);
         const notes = update ? await releaseNotes(VERSION, url.searchParams.has("fresh")) : [];
-        return json({ version: VERSION, latest: v, update, notes });
+        return json({ version: VERSION, latest: v, update, notes, failed: upgradeFailed });
       }
 
       // `kaizen upgrade`, run here with no window, then a new board on this port: it
@@ -560,6 +560,21 @@ export async function web(repoDir: string, opts: Opts = {}) {
       if (req.method === "POST" && path === "/upgrade") {
         if (!local(req)) return bad("cross-origin write refused", 403);
         if (upgrading) return bad("an upgrade is already running", 409);
+        // Windows will not rename ~/kaizen while this board holds files in it, so the
+        // upgrade waits in its own process for this one to exit, then starts the board
+        // again; ~/.kaizen/upgrade.log keeps what it said. It runs from a copy of cli/,
+        // so nothing runs out of ~/kaizen while it is renamed.
+        if (process.platform === "win32") {
+          const helper = join(home, ".kaizen", "upgrader");
+          rmSync(helper, { recursive: true, force: true });
+          cpSync(join(repoDir, "cli"), join(helper, "cli"), { recursive: true });
+          const log = Bun.file(UPGRADE_LOG);
+          Bun.spawn([process.execPath, join(helper, "cli", "install.ts"), "upgrade", "--wait", String(process.pid), "--restart", String(srv.port)], {
+            cwd: home, detached: true, stdio: ["ignore", log, log], windowsHide: true,
+          }).unref();
+          setTimeout(() => process.exit(0), 300);
+          return json({ ok: true });
+        }
         upgrading = true;
         try {
           const p = Bun.spawn([process.execPath, join(repoDir, "cli", "install.ts"), "upgrade"], { stdin: "ignore", stdout: "pipe", stderr: "pipe", windowsHide: true });
@@ -688,6 +703,33 @@ export async function web(repoDir: string, opts: Opts = {}) {
           return json({ ok: true, added: knownProjects().length - before });
         }
 
+        // A new, empty project: a folder in the projects folder (else ~/Projects), or
+        // where the page names, set up at once. /find only sees folders that already
+        // have a .kaizen, so a folder made by hand never shows there.
+        if (path === "/new-project") {
+          const name = typeof body.name === "string" ? body.name.trim() : "";
+          // Windows' rules on every platform, so a project made here also opens there:
+          // no reserved device names (CON, NUL, COM1…), no trailing dot or space.
+          const winBad = (n: string) => !n || /[\\/:*?"<>|\x00-\x1f]/.test(n) || /[. ]$/.test(n)
+            || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i.test(n);
+          const t = typeof body.to === "string" ? body.to.trim() : "";
+          const to = t ? resolve(home, nativePath(t.startsWith("~") ? home + t.slice(1) : t))
+            : join((await projectsRoot()) || join(home, "Projects"), name);
+          // The page asks while the name is typed: "con" on the way to "config" is no error yet.
+          if (body.check) return json({ ok: true, to });
+          if (winBad(name)) return bad("name the project: a folder name, without / \\ : * ? \" < > |, not ending in a dot or space, and not CON, NUL, COM1 or the like");
+          if (winBad(basename(to))) return bad(`${basename(to)} cannot be a folder name on Windows`);
+          let used = false;
+          try { used = readdirSync(to).length > 0; } catch (e) { used = existsSync(to); }
+          if (used) return bad(`${to} already exists and is not empty`, 409);
+          // A drive that is not there, a read-only folder, a path too long: said in a toast, not a crash.
+          try { mkdirSync(join(to, ".kaizen"), { recursive: true }); }
+          catch (e) { return bad(`could not create ${to}: ${(e as Error).message}`); }
+          remember(to);
+          changed();
+          return json({ ok: true, dir: join(to, ".kaizen") });
+        }
+
         // Clone a GitHub repository into the projects folder (else ~/Projects) and
         // set it up as a project. Arguments go to git as an array: no shell.
         if (path === "/clone") {
@@ -1124,6 +1166,18 @@ async function openDefault(url: string) {
 let picking = false;
 // One `kaizen upgrade` at a time, from any page.
 let upgrading = false;
+// What a Windows hand-off upgrade said (see POST /upgrade). Read once at start: no
+// "Upgraded" or "Up to date" line means it failed, and its last lines say why.
+const UPGRADE_LOG = join(home, ".kaizen", "upgrade.log");
+const upgradeFailed = (() => {
+  if (!existsSync(UPGRADE_LOG)) return null;
+  const lines = readText(UPGRADE_LOG).replace(/\x1b\[[0-9;]*m/g, "").split("\n").map((l) => l.trim()).filter(Boolean);
+  try { rmSync(UPGRADE_LOG, { force: true }); } catch { /* shown again next start */ }
+  if (lines.some((l) => /^(Upgraded|Up to date)\b/.test(l))) return null;
+  // "kept ~/kaizen (in use …)" is the reason when there is one; else the closing lines.
+  const kept = lines.find((l) => /^\+?\s*kept\b/.test(l));
+  return kept?.replace(/^\+\s*/, "") ?? (lines.filter((l) => !l.startsWith("+")).slice(-2).join(" — ") || "kaizen upgrade said nothing");
+})();
 
 // The system folder picker for this platform, printing the chosen path on stdout.
 // macOS and Windows always have one; on Linux it is whichever desktop tool exists.

package/package.json

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

package/skills/kaizen/README.md

@@ -206,7 +206,7 @@ the defaults.
 | `auto_fix.min_severity` | `high` | Lower to `medium` or `low` to have more auto-fixed; raise findings you see instead of auto-fixing |
 | `auto_fix.max_iterations` | `2` | Fix/recheck rounds before whatever is left is escalated to you |
 | `review.memory_max_lines` | `100` | The cap on `memory.md`, which every stage of every run reads. Raise only if the lessons are genuinely all load-bearing |
-| `git.auto_commit` | `false` | Leave it. Kaizen does not commit or push unless you ask |
+| `git.auto_commit` | `false` | `true` commits the files a run changed when it is done, by path. Never pushes |
 | `track.default` | `auto` (inferred) | A repo that is always one kind of work, e.g. a docs repo |
 | `backlog.enabled` | `true` | Set `false` to skip both backlog capture points; the run still executes, just without a `06-backlog.md` |
 | `backlog.file` | `06-backlog.md` | The per-run file name. Rarely. |

package/skills/kaizen/config.default.yml

@@ -125,7 +125,9 @@ state:
   keep_runs: 20
 
 git:
-  # Never commit, push, or open a PR unless the user explicitly asks.
+  # true: when a run reaches done (approved at review, or an auto run finishing),
+  # commit the files that run changed, by path, with its ## Commit message. Never
+  # pushes. false: never commit, push, or open a PR unless the user explicitly asks.
   # Ignored when the project is not a git repository.
   auto_commit: false
   # Create a branch before the implement stage when on the default branch.
@@ -168,8 +170,8 @@ agent:
   # Where the web board runs the agent it launches.
   #   card     - inside the board: the card's Terminal tab shows the agent live and
   #              takes your typing. The agent lives in the board's process, so
-  #              stopping or upgrading the board ends it. Not on Windows, where it
-  #              falls back to a terminal window.
+  #              stopping or upgrading the board ends it. On Windows it runs in
+  #              a ConPTY console that Windows PowerShell hosts.
   #   terminal - a new terminal window (or tmux/herdr tab) per launch.
   # The terminal dashboard always opens terminal windows.
   launch: card

package/skills/kaizen/spec-main.md

@@ -131,6 +131,17 @@ change is that it is written down rather than spoken and discarded.
 
 Set `stage: "done"` in `state.json` once the user accepts.
 
+**Commit at done, when `git.auto_commit` is `true`.** Setting `stage: "done"` — the
+user approving at review, or an `auto` run finishing — is then the ask to commit, under
+either runner. Commit only the files this run changed (the paths `03-impl.md` names,
+that `git status` shows changed), by path: `git add -A -- <paths>` then
+`git commit -m <message> -- <paths>`, never the whole tree, since other sessions edit
+the same checkout. The message is `03-impl.md`'s `## Commit`. In a run with a
+`worktree`, commit there. Then write `runs/<id>/07-commit.md` as `commit: <short sha>`
+and `pushed: no`, so the board shows it committed and offers the push. Never push. A
+failed commit is reported as printed; the run is still `done`. With the setting
+`false`, nothing is committed unless the user asks.
+
 ---
 
 ## Child cards

package/skills/kaizen-help/SKILL.md

@@ -95,7 +95,7 @@ Each iteration is written to `runs/<id>/05-iterations/`.
 | `backlog.orphan_file` | `backlog.md` | Where a pruned run's open items are rescued to |
 | `state.dir` | `.kaizen` | State directory |
 | `state.keep_runs` | `20` | Completed runs kept before pruning oldest (rescues open backlog first) |
-| `git.auto_commit` | `false` | Never commit/push/PR unless the user explicitly asks |
+| `git.auto_commit` | `false` | `true`: commit the run's changed files when it is done; never pushes |
 | `git.branch_before_implement` | `true` | Branch before implement stage when on the default branch |
 | `subagents.model` | `inherit` | Model the stage subagents run on (opus/sonnet/haiku, Claude Code only) |
 | `subagents.effort` | `inherit` | Reasoning effort for the stage subagents (low/medium/high, Claude Code only) |

package/web/board/cards.ts

@@ -467,6 +467,7 @@ export function render() {
     ["All projects", "all"],
     ...store.S.projects.map((p) => [p.label, p.dir]),
     ...store.S.fresh.map((p) => [p.label, p.dir, 1]),
+    ["New project…", "__new"],
     ["Find projects on this PC…", "__find"],
     ["Clone from GitHub…", "__clone"],
   ];

package/web/board/dom.ts

@@ -27,7 +27,11 @@ export function modal(html: string) {
   dl.className = "kz";
   dl.innerHTML = `<form class="inl" method="dialog">${html}</form>`;
   dl.onclose = () => dl.remove();
-  dl.onclick = (e) => e.target === dl && dl.close(); // a tap on the backdrop
+  // A tap on the backdrop. Braces matter: an on* handler that returns false cancels the click,
+  // which stopped every submit button inside the form.
+  dl.onclick = (e) => {
+    if (e.target === dl) dl.close();
+  };
   document.body.appendChild(dl);
   dl.showModal();
   return dl;

package/web/board/projects.ts

@@ -35,7 +35,7 @@ export function list() {
     store.PL.map((p, i) =>
       p[0].toLowerCase().includes(q)
         ? (p[2] && !g++ ? `<div class="grp">In your projects folder</div>` : "") +
-          `<button role="option" data-i="${i}" title="${esc(p[0])}">${p[1] === "all" ? `<span class="plogo" aria-hidden="true">${ico("board")}</span><span>${esc(p[0])}</span>` : p[1] === "__find" || p[1] === "__clone" ? `<span class="plogo" aria-hidden="true">${ico("plus")}</span><span>${esc(p[0])}</span>` : prow(p[1], p[0])}</button>`
+          `<button role="option" data-i="${i}" title="${esc(p[0])}">${p[1] === "all" ? `<span class="plogo" aria-hidden="true">${ico("board")}</span><span>${esc(p[0])}</span>` : p[1] === "__new" || p[1] === "__find" || p[1] === "__clone" ? `<span class="plogo" aria-hidden="true">${ico("plus")}</span><span>${esc(p[0])}</span>` : prow(p[1], p[0])}</button>`
         : "",
     ).join("") || `<div class="grp">No match</div>`;
   const f = $("projs").querySelector("button");
@@ -55,6 +55,45 @@ async function pick(v) {
     toast("Searching…");
     const j = await post("/find", {});
     if (j.ok) toast(j.added ? `Found ${j.added} new project${j.added === 1 ? "" : "s"}` : "No new projects found");
+  } else if (v === "__new") {
+    // A name, and where it goes: the projects folder unless typed or picked.
+    const dl = modal(
+      `<b>New project</b><input name="name" placeholder="Project name" aria-label="Project name" spellcheck="false" autocomplete="off"><div class="row"><input name="to" placeholder="Create in (a new folder is made)" aria-label="Create in" spellcheck="false" autocomplete="off"><button type="button" class="btn ghost" data-a="pick">Pick…</button></div><div class="row"><button type="button" class="btn ghost" data-a="x">Cancel</button><button class="btn pri">Create</button></div>`,
+    );
+    const f = dl.querySelector("form"),
+      name = f.querySelector("[name=name]"),
+      to = f.querySelector("[name=to]");
+    let auto = ""; // the folder this form filled in; one the user typed is left alone
+    name.oninput = async () => {
+      const n = name.value.trim();
+      if (!n || /[\\/:*?"<>|]/.test(n) || (to.value.trim() && to.value !== auto)) return; // a bad name is reported once, at Create
+      const d = await post("/new-project", { name: n, check: true });
+      if (d.ok && name.value.trim() === n) to.value = auto = d.to;
+    };
+    f.querySelector("[data-a=x]").onclick = () => dl.close();
+    f.querySelector("[data-a=pick]").onclick = async () => {
+      const p = await post("/pick-folder", {});
+      if (p.path)
+        to.value = p.path.replace(/[\\/]+$/, "") + (p.path.includes("\\") ? "\\" : "/") + (name.value.trim() || "");
+    };
+    name.focus();
+    const dir = await new Promise((done) => {
+      dl.addEventListener("close", () => done(null));
+      f.onsubmit = async (e) => {
+        e.preventDefault();
+        if (!name.value.trim()) return name.focus();
+        const j = await post("/new-project", { name: name.value.trim(), to: to.value.trim() || undefined });
+        if (!j.ok) return;
+        done(j.dir);
+        dl.close();
+      };
+    });
+    if (!dir) return;
+    await post("/cd", { dir });
+    store.all = false;
+    store.dir = dir;
+    keep(dir);
+    toast("Project created");
   } else if (v === "__clone") {
     // One form: the link, then where it goes. The folder fills in once the link names a repo.
     const dl = modal(

package/web/board/update.ts

@@ -30,6 +30,7 @@ export function updBar() {
       : "";
     d.innerHTML = `<span>kaizen <b>${esc(upd.latest)}</b> is available. You are running ${esc(upd.version)}.</span><span class="updact">${news}<button class="btn" id="upd-chk">Check for updates</button><button class="btn pri" id="upd-go">Update kaizen</button></span>`;
   }
+  if (ver && ver.failed) d.insertAdjacentHTML("afterbegin", `<span class="updfail" role="alert">Last update failed: ${esc(ver.failed)}</span>`);
   $("pbody").prepend(d);
   const check = $("upd-chk");
   check.onclick = async () => {