kaizen-agent 1.42.2 → 1.43.0

package/cli/backlog.test.ts

@@ -0,0 +1,133 @@
+// Backlog items as cards in the board's Ideas column: numbering, hiding while a run
+// started from one lives, closing in place, and the board routes that drive them.
+import { test, expect } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, statSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { backlogLines, backlogCards, startedBacklog, closeBacklog, markBacklogDone, backlogItem } from "./state.ts";
+import { boardIndex } from "./notes.ts";
+
+const scratch = () => {
+  const state = join(mkdtempSync(join(tmpdir(), "kz-bl-")), ".kaizen");
+  const run = (id: string, stage: string, files: Record<string, string> = {}) => {
+    const dir = join(state, "runs", id);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "state.json"), JSON.stringify({ id, stage, awaiting: null }));
+    for (const [f, t] of Object.entries(files)) writeFileSync(join(dir, f), t);
+    return dir;
+  };
+  return { state, run };
+};
+
+const BACKLOG = "# Backlog\n\n- open: `cli/x.ts:12`: low: first thing. Fix: do it.\n- done: closed one | run y\n- open: high: urgent thing\n  a note under it\n- rejected: no | why\n- open: plain item\n";
+
+test("backlogLines numbers every open, done and rejected line as boardIndex does", () => {
+  const { state, run } = scratch();
+  run("2026-10-01-src", "done", { "06-backlog.md": BACKLOG });
+  const lines = backlogLines(join(state, "runs", "2026-10-01-src", "06-backlog.md"));
+  expect(lines.map((l) => [l.n, l.status])).toEqual([[1, "open"], [2, "done"], [3, "open"], [4, "rejected"], [5, "open"]]);
+  const idx = boardIndex(state).runs.find((r) => r.id === "2026-10-01-src")!.backlog;
+  expect(idx).toEqual(lines.map(({ n, status, text }) => ({ n, status, text })));
+  expect(backlogLines(join(state, "nope.md"))).toEqual([]);
+});
+
+test("backlogCards: open items of live runs and the orphanage, most severe first; abandoned runs skipped", () => {
+  const { state, run } = scratch();
+  run("2026-10-01-src", "done", { "06-backlog.md": BACKLOG });
+  run("2026-10-02-gone", "abandoned", { "06-backlog.md": "- open: critical: from an abandoned run\n" });
+  writeFileSync(join(state, "backlog.md"), "- open: rescued item | from 2026-09-01-old\n");
+  const cards = backlogCards([state]);
+  expect(cards.map((c) => [c.source, c.n, c.severity])).toEqual([
+    ["2026-10-01-src", 3, "high"], ["2026-10-01-src", 1, "low"], ["2026-10-01-src", 5, null], ["orphan", 1, null],
+  ]);
+  expect(cards[1]).toMatchObject({ text: "first thing.", at: "x.ts:12", raw: "`cli/x.ts:12`: low: first thing. Fix: do it." });
+});
+
+test("a run started from an item hides its card; an abandoned one gives it back", () => {
+  const { state, run } = scratch();
+  run("2026-10-01-src", "done", { "06-backlog.md": BACKLOG });
+  const kid = run("2026-10-03-kid", "plan", { "00-request.md": "/kaizen urgent thing\n\nParent: 2026-10-01-src\nBacklog: 2026-10-01-src#3\n" });
+  expect(startedBacklog(state).get("2026-10-01-src#3")).toEqual([{ id: "2026-10-03-kid", stage: "plan" }]);
+  expect(backlogCards([state]).some((c) => c.n === 3)).toBe(false);
+  writeFileSync(join(kid, "state.json"), JSON.stringify({ stage: "abandoned" }));
+  expect(backlogCards([state]).some((c) => c.n === 3)).toBe(true);
+});
+
+test("markBacklogDone closes only the line its done run names, once, and touches no state.json", () => {
+  const { state, run } = scratch();
+  const src = run("2026-10-01-src", "done", { "06-backlog.md": BACKLOG });
+  run("2026-10-03-kid", "build", { "00-request.md": "x\n\nBacklog: 2026-10-01-src#3\n" });
+  run("2026-10-04-orph", "done", { "00-request.md": "y\n\nBacklog: orphan#1\n" });
+  writeFileSync(join(state, "backlog.md"), "- open: rescued item | from 2026-09-01-old\n");
+  markBacklogDone(state);
+  expect(readFileSync(join(src, "06-backlog.md"), "utf8")).toBe(BACKLOG);   // still building
+  expect(readFileSync(join(state, "backlog.md"), "utf8")).toBe("- open: rescued item | from 2026-09-01-old | 2026-10-04-orph\n".replace("open", "done"));
+  const kidState = join(state, "runs", "2026-10-03-kid", "state.json");
+  writeFileSync(kidState, JSON.stringify({ stage: "done" }));
+  const before = statSync(kidState).mtimeMs;
+  markBacklogDone(state);
+  markBacklogDone(state);
+  expect(readFileSync(join(src, "06-backlog.md"), "utf8")).toBe(BACKLOG.replace("- open: high: urgent thing", "- done: high: urgent thing | 2026-10-03-kid"));
+  expect(statSync(kidState).mtimeMs).toBe(before);
+  expect(backlogCards([state]).map((c) => c.n)).toEqual([1, 5]);
+});
+
+test("closeBacklog rewrites one open line in place and keeps CRLF; refuses closed or missing lines", () => {
+  const { state, run } = scratch();
+  const src = run("2026-10-01-src", "done", { "06-backlog.md": BACKLOG.replace(/\n/g, "\r\n") });
+  expect(closeBacklog(state, "2026-10-01-src", 5, "rejected", "not worth it")).toBeNull();
+  expect(readFileSync(join(src, "06-backlog.md"), "utf8")).toBe(BACKLOG.replace("- open: plain item", "- rejected: plain item | not worth it").replace(/\n/g, "\r\n"));
+  expect(closeBacklog(state, "2026-10-01-src", 2, "rejected", "x")).toBe("that item is already closed");
+  expect(closeBacklog(state, "2026-10-01-src", 9, "rejected", "x")).toBe("no such backlog item");
+  expect(closeBacklog(state, "../../etc", 1, "rejected", "x")).toBe("no such backlog");
+  expect(backlogItem(state, "2026-10-01-src", 5)?.status).toBe("rejected");
+});
+
+// The real server in a scratch home. Linux only: launching is made to fail before any
+// terminal or agent opens (no display, no terminal on PATH, terminal launch mode), and
+// the manual command it hands back is the request a run would have been given.
+test.skipIf(process.platform !== "linux")("board routes: /state lists backlog cards, /backlog rejects, /run carries the item's source", async () => {
+  const homeDir = mkdtempSync(join(tmpdir(), "kz-bl-home-")), proj = join(homeDir, "p"), state = join(proj, ".kaizen");
+  for (const d of [state, join(homeDir, ".kaizen"), join(homeDir, ".claude")]) mkdirSync(d, { recursive: true });
+  writeFileSync(join(homeDir, ".kaizen", "projects"), proj + "\n");
+  writeFileSync(join(homeDir, ".kaizen", "config.yml"), "agent:\n  launch: terminal\n");
+  const src = join(state, "runs", "2026-10-01-src");
+  mkdirSync(src, { recursive: true });
+  writeFileSync(join(src, "state.json"), JSON.stringify({ stage: "done", awaiting: null }));
+  writeFileSync(join(src, "06-backlog.md"), BACKLOG);
+  const port = 20000 + Math.floor(Math.random() * 20000);
+  const repo = join(import.meta.dir, "..");
+  const env: Record<string, string> = { HOME: homeDir, USERPROFILE: homeDir, KAIZEN_HOME: repo, PATH: dirname(process.execPath), DISPLAY: "", WAYLAND_DISPLAY: "", TERMINAL: "", TMUX: "" };
+  const proc = Bun.spawn([process.execPath, join(repo, "cli", "install.ts"), "web", "--port", String(port), "--no-open", "--foreground"], { cwd: proj, env, stdout: "ignore", stderr: "ignore" });
+  try {
+    const at = `http://127.0.0.1:${port}`;
+    for (let i = 0; ; i++) { try { await fetch(at + "/state"); break; } catch { if (i > 100) throw new Error("board did not start"); await Bun.sleep(50); } }
+    const post = async (path: string, body: object) => { const r = await fetch(at + path, { method: "POST", body: JSON.stringify({ dir: state, ...body }) }); return { status: r.status, ...(await r.json() as any) }; };
+    const listed = async () => ((await (await fetch(at + "/state?all=1")).json()) as any).backlog.map((b: any) => [b.source, b.n]);
+    expect(await listed()).toEqual([["2026-10-01-src", 3], ["2026-10-01-src", 1], ["2026-10-01-src", 5]]);
+
+    expect(await post("/backlog", { op: "reject", source: "2026-10-01-src", n: 5, reason: "" })).toMatchObject({ status: 400 });
+    expect(await post("/backlog", { op: "reject", source: "2026-10-01-src", n: 5, reason: "not now" })).toMatchObject({ status: 200 });
+    expect(await post("/backlog", { op: "reject", source: "2026-10-01-src", n: 5, reason: "again" })).toMatchObject({ status: 409 });
+    expect(await post("/backlog", { op: "reject", source: "2026-10-01-src", n: 42, reason: "x" })).toMatchObject({ status: 404 });
+    expect(readFileSync(join(src, "06-backlog.md"), "utf8")).toContain("- rejected: plain item | not now\n");
+    expect(await listed()).toEqual([["2026-10-01-src", 3], ["2026-10-01-src", 1]]);
+
+    expect(await post("/run", { backlog: { source: "2026-10-01-src", n: 2 } })).toMatchObject({ status: 409 });
+    expect(await post("/run", { backlog: { source: "2026-10-01-src", n: 42 } })).toMatchObject({ status: 404 });
+    const r = await post("/run", { kind: "lite", backlog: { source: "2026-10-01-src", n: 1 } });
+    expect(r).toMatchObject({ status: 500, ok: false });
+    expect(r.manual).toContain("/kaizen lite first thing. (x.ts:12)");
+    expect(r.manual).toContain("Parent: 2026-10-01-src");
+    expect(r.manual).toContain("Backlog: 2026-10-01-src#1");
+    expect(r.manual).toContain("Backlog item: `cli/x.ts:12`: low: first thing. Fix: do it.");
+
+    // Once a run carries the line, a second start is refused and the card is gone.
+    const kid = join(state, "runs", "2026-10-05-kid");
+    mkdirSync(kid, { recursive: true });
+    writeFileSync(join(kid, "state.json"), JSON.stringify({ stage: "plan", awaiting: null }));
+    writeFileSync(join(kid, "00-request.md"), "first thing\n\nParent: 2026-10-01-src\nBacklog: 2026-10-01-src#1\n");
+    expect(await post("/run", { backlog: { source: "2026-10-01-src", n: 1 } })).toMatchObject({ status: 409 });
+    expect(await listed()).toEqual([["2026-10-01-src", 3]]);
+  } finally { proc.kill(); await proc.exited; }
+}, 30_000);

package/cli/board.test.ts

@@ -22,7 +22,8 @@ test("Settings rechecks an existing update alert and clears or refreshes it", as
     getElementById: (id: string) => id === "pbody" ? body : elements.get(id),
     createElement: () => ({
       isConnected: false,
-      set innerHTML(html: string) {
+      set innerHTML(v: unknown) {
+        const html = String(v);
         this.html = html;
         elements.clear();
         for (const [, id] of html.matchAll(/id="([^"]+)"/g)) elements.set(id, { textContent: "", disabled: false, focus() {} });
@@ -154,7 +155,7 @@ test("card menu items: appropriate actions and distinct icons across phases", ()
 
   const ico = (n: string) => `<svg><use href="#i-${n}"/></svg>`;
   const from = cards.indexOf("if (k === store.menuKey) {");
-  const menuSnippet = (cards.slice(from, cards.indexOf('el.innerHTML += `<div class="menu-pop"', from)) + "}").replace("const items = [];", "items = [];");
+  const menuSnippet = (cards.slice(from, cards.indexOf('el.innerHTML += html`<div class="menu-pop"', from)) + "}").replace("const items = [];", "items = [];");
   const a0 = cards.indexOf("const actionOf =");
   const actionOf = cards.slice(a0, cards.indexOf("\n\n", a0));
   const getItems = new Function("c", "archive", "S", `const ico = ${ico.toString()};\nconst decided = new Set(), answer = () => "";\n${actionOf}\nconst store = { S, menuKey: 1 };\nlet k = 1, items = [];\n${menuSnippet}\nreturn items;`);
@@ -178,6 +179,10 @@ test("card menu items: appropriate actions and distinct icons across phases", ()
   const startItems = getItems(startingIdea, false);
   expect(startItems.map((i: any) => i ? i[1] : null)).toEqual(["Open", "Run again", "Archive", null, "Remove"]);
 
+  // Ideas column, Backlog tab: a run's leftover, run like an idea, rejected with a reason.
+  expect(getItems({ kind: "backlog", status: "idea", column: 0 }, false).map((i: any) => i ? i[1] : null)).toEqual(["Run", "Open its run", null, "Reject"]);
+  expect(getItems({ kind: "backlog", status: "starting", column: 0 }, false)[0][1]).toBe("Run again");
+
   // Phase 1: Planning (run waiting for plan approval)
   const planWaiting = { kind: "run", status: "waiting", awaiting: "approvals.plan", column: 1 };
   const planItems = getItems(planWaiting, false);

package/cli/html.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+import { html, ico, raw } from "../web/board/dom.ts";
+
+test("html escapes interpolations once and keeps trusted markup", () => {
+  const bad = '<img src=x onerror=1> & "q"';
+  const out = String(html`<b title="${bad}">${bad}</b>`);
+  expect(out).not.toContain("<img");
+  expect(out).toContain("&lt;img src=x onerror=1&gt; &amp; &quot;q&quot;");
+  expect(String(html`${"a&b"}`)).toBe("a&amp;b");
+  expect(String(html`${raw("<i>")}${ico("x")}`)).toBe('<i><svg><use href="#i-x"/></svg>');
+  expect(String(html`<ul>${[1, 2].map((n) => html`<li>${n}</li>`)}</ul>`)).toBe("<ul><li>1</li><li>2</li></ul>");
+  expect(String(html`${["<a>"]}`)).toBe("&lt;a&gt;");
+  expect(String(html`[${null}${undefined}${false}]`)).toBe("[]");
+  expect(String(html`${html`<u>${"&"}</u>`}`)).toBe("<u>&amp;</u>");
+});
+
+test("aria states render false explicitly when stringified", () => {
+  expect(String(html`<b aria-pressed="${String(false)}" aria-checked="${String(true)}">`)).toBe('<b aria-pressed="false" aria-checked="true">');
+});

package/cli/notes.ts

@@ -3,7 +3,7 @@
 // the page goes through safeName before it becomes a path.
 import { existsSync, mkdirSync, readdirSync, realpathSync, renameSync, rmdirSync, statSync, writeFileSync } from "node:fs";
 import { join, dirname, resolve, sep } from "node:path";
-import { boardCards, reviewFindings, readText } from "./state.ts";
+import { backlogLines, boardCards, reviewFindings, readText } from "./state.ts";
 import { wikilinks, boardLink, resolveRun } from "../web/notes-lib.ts";
 
 export type Note = { name: string; mtime: number; text: string };
@@ -114,11 +114,7 @@ function prune(state: string, dir: string) {
 // project keeps hundreds of runs.
 export function boardIndex(state: string) {
   const cards = boardCards([state], Date.now());
-  const backlog = (id: string) => {
-    let text = "";
-    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() }));
-  };
+  const backlog = (id: string) => backlogLines(join(state, "runs", id, "06-backlog.md")).map(({ n, status, text }) => ({ n, status, text }));
   return {
     runs: cards.filter((c) => c.kind === "run").map((c) => ({
       id: c.id!, short: c.id!.replace(/^\d{4}-\d{2}-\d{2}-/, ""), title: c.title ?? c.text, status: c.status,

package/cli/state.test.ts

@@ -57,6 +57,11 @@ test("statusOf: waiting beats stage, mtime decides running vs stalled", () => {
   expect(statusOf(stale!, now)).toBe("stalled");
   expect(statusOf({ ...stale!, moved: now }, now)).toBe("running");
   expect(statusOf({ ...stale!, stage: "abandoned", awaiting: "x" }, now)).toBe("abandoned");
+  // A builder ticking progress.md is moving, though state.json is old.
+  const progress = join(state, "runs", "2026-09-03-stale", "progress.md");
+  writeFileSync(progress, "- doing: step 2\n");
+  try { expect(statusOf(readRuns(state)[0]!, now)).toBe("running"); } finally { rmSync(progress); }
+  expect(statusOf(readRuns(state)[0]!, now)).toBe("stalled");
 });
 
 test("columnOf: every stage word lands somewhere", () => {
@@ -501,6 +506,52 @@ test("commitPush: commits the run's files only, pushes, and records it; the mess
   expect(cardsGit(join(root, ".kaizen"), ["r1"])).toEqual({});   // not a repo
 }, 60_000);   // dozens of git calls, ~250ms each on Windows
 
+test("runGit, cardsGit: a run committed elsewhere is not offered the edits made since, nor another run's unpushed commit", () => {
+  const root = mkdtempSync(join(tmpdir(), "kz-git-"));
+  const bare = join(root, "remote.git"), proj = join(root, "proj"), st = join(proj, ".kaizen");
+  // Commit times pinned (seconds since the epoch), so each sits where the test says.
+  const sh = (cwd: string, at: number | null, ...a: string[]) => Bun.spawnSync(["git", "-C", cwd, ...a], { env: { ...process.env, ...(at ? { GIT_COMMITTER_DATE: `@${at} +0000`, GIT_AUTHOR_DATE: `@${at} +0000` } : {}) } }).stdout.toString().trim();
+  const report = (id: string, text: string, at: number) => {
+    mkdirSync(join(st, "runs", id), { recursive: true });
+    writeFileSync(join(st, "runs", id, "03-impl.md"), text);
+    utimesSync(join(st, "runs", id, "03-impl.md"), new Date(at * 1000), new Date(at * 1000));
+  };
+  Bun.spawnSync(["git", "init", "-q", "--bare", bare]);
+  Bun.spawnSync(["git", "init", "-q", proj]);
+  for (const kv of [["user.name", "t"], ["user.email", "t@t"], ["commit.gpgsign", "false"], ["core.hooksPath", "/dev/null"]]) sh(proj, null, "config", ...kv);
+  sh(proj, null, "remote", "add", "origin", bare);
+  writeFileSync(join(proj, ".gitignore"), ".kaizen/\n");
+  writeFileSync(join(proj, "x.txt"), "1");
+  report("old", "- `x.txt`: x\n", 1000);
+  sh(proj, null, "add", "-A");
+  sh(proj, 2000, "commit", "-qm", "feat: x");
+  sh(proj, null, "push", "-qu", "origin", "HEAD");
+  // Edited again after the run's commit, by someone with no run of their own.
+  writeFileSync(join(proj, "x.txt"), "2");
+  expect(runGit(st, "old")).toMatchObject({ files: [], ahead: 0, others: 1 });
+  expect(cardsGit(st, ["old"])).toEqual({ old: "pushed" });
+  // Another run's commit, not pushed: the branch is ahead, the old run is not.
+  writeFileSync(join(proj, "y.txt"), "y");
+  report("new", "- `y.txt`: y\n", 3000);
+  sh(proj, null, "add", "y.txt");
+  sh(proj, 4000, "commit", "-qm", "feat: y");
+  expect(runGit(st, "old")).toMatchObject({ files: [], ahead: 0 });
+  expect(runGit(st, "new")).toMatchObject({ files: [], ahead: 1 });
+  expect(cardsGit(st, ["old", "new"])).toEqual({ old: "pushed", new: "pending" });
+  // The old run reporting again after its commit: the edit is its work after all.
+  report("old", "- `x.txt`: x, again\n", 5000);
+  expect((runGit(st, "old") as any).files).toEqual([" M x.txt"]);
+  // A commit no run's report names still gets a push: from the run that reported last by then.
+  const commit = (f: string, at: number, msg: string) => { writeFileSync(join(proj, f), f); sh(proj, null, "add", f); sh(proj, at, "commit", "-qm", msg); };
+  commit("z.txt", 6000, "chore: z");
+  expect(runGit(st, "old")).toMatchObject({ ahead: 1 });
+  expect(runGit(st, "new")).toMatchObject({ ahead: 1 });
+  // A run whose report holds the commit's subject as a line owns it, over the file count.
+  report("new", "- `y.txt`: y\n\n## Commit\nchore: z\n", 3000);
+  expect(runGit(st, "old")).toMatchObject({ ahead: 0 });
+  expect(runGit(st, "new")).toMatchObject({ ahead: 2 });
+}, 60_000);
+
 test.skipIf(process.platform === "win32")("findTerminal: a running herdr wins, then tmux, else neither; the prompt stays one literal argument", () => {
   const bin = mkdtempSync(join(tmpdir(), "kz-bin-"));
   const stub = (name: string, code: number) => writeFileSync(join(bin, name), `#!/bin/sh\nexit ${code}\n`, { mode: 0o755 });
@@ -921,7 +972,7 @@ test.skipIf(process.platform === "win32")("closeSessions ends only the run's own
   const alive = (pr: ReturnType<typeof Bun.spawn>) => pr.exitCode === null && pr.signalCode === null;
   const procs: Record<string, ReturnType<typeof Bun.spawn>> = {
     mine: start("mine", {}),
-    later: start("later", { started: Date.now() + 60_000 }),        // the decision's own successor
+    later: start("later", { started: Date.now() - 1000 }),          // the decision's own successor: after `before` below
     stranger: start("stranger", { cmd: "notkzagent" }),             // a PID that is not this agent
     other: start("other", { run: "2026-10-01-b" }),                 // another run's
   };
@@ -929,13 +980,14 @@ test.skipIf(process.platform === "win32")("closeSessions ends only the run's own
   writeFileSync(join(dir, "dead.json"), JSON.stringify({ run: "2026-10-01-a", text: "a", cmd: "kzagent", sessionId: null, started: 0 }));
   writeFileSync(join(dir, "dead.pid"), "999999\n");
   try {
-    expect(closeSessions(st, "2026-10-01-a", { before: Date.now() })).toBe(1);
+    expect(closeSessions(st, "2026-10-01-a", { before: Date.now() - 3000 })).toBe(1);
     expect(await procs.mine.exited).not.toBe(0);
     for (const k of ["later", "stranger", "other"] as const) expect(alive(procs[k])).toBe(true);
     expect(existsSync(join(dir, "mine.pid"))).toBe(false);
     expect(existsSync(join(dir, "mine.json"))).toBe(true);       // its conversation id is still needed
     expect(existsSync(join(dir, "dead.pid"))).toBe(false);
     expect(existsSync(join(dir, "later.pid"))).toBe(true);
+    expect(existsSync(join(dir, "stranger.pid"))).toBe(false);   // its number is held by something else: dropped, not killed
 
     // Off: nothing is ended.
     writeFileSync(join(st, "config.yml"), "agent:\n  default: claude\n  close: off\n");
@@ -951,6 +1003,13 @@ test.skipIf(process.platform === "win32")("closeSessions ends only the run's own
     sweepSessions(st, Date.now() + CLOSE_GRACE_MS);
     expect(await procs.other.exited).not.toBe(0);
     expect(alive(procs.later)).toBe(true);                     // run a is still waiting
+    // A PID file whose process is gone is dropped by the sweep, whatever its run is doing.
+    writeFileSync(join(dir, "dead2.json"), JSON.stringify({ run: "2026-10-01-a", text: "a", cmd: "kzagent", sessionId: null, started: 0 }));
+    writeFileSync(join(dir, "dead2.pid"), "999999\n");
+    sweepSessions(st, Date.now());
+    expect(existsSync(join(dir, "dead2.pid"))).toBe(false);
+    expect(existsSync(join(dir, "dead2.json"))).toBe(true);
+    expect(existsSync(join(dir, "later.pid"))).toBe(true);
 
     // A fix launched on a done run, after it last moved, is doing the work: kept.
     const fix = start("fix", { run: "2026-10-01-b", started: Date.now() + 1000 });