kaizen-agent 1.42.2 → 1.43.1

package/cli/state.test.ts

@@ -7,7 +7,7 @@ import { tmpdir } from "node:os";
 import { issueUrl, systemInfo, scrubHome, REPO_URL, home as realHome, trustFolder } from "./state.ts";
 import * as stateModule from "./state.ts";
 import {
-  readRuns, readInbox, writeInbox, replaceIdea, moveIdea, abandonRun, allBacklog, backlog,
+  readRuns, readInbox, writeInbox, replaceIdea, moveIdea, abandonRun, runToIdea, allBacklog, backlog,
   requestTitle, statusOf, columnOf, parseItem, startedRuns, boardCards, parentOf, addCard, readArchive, setArchived,
   requestOf, agentFlags, plainModel, readNotes, writeNotes, manualCommand, parseNotes, formatNote, appendNote, saveAttachment,
   reviewFindings, pickFindings, fixPrompt, approvalPrompt, sessionLaunch, closeSessions, sweepSessions, readSessions, ownerOf, CLOSE_GRACE_MS, gitStatus, runGit, cardsGit, commitPush, readCommit, findTerminal, nativePath, pruneRuns, unrechecked, notice, notifier, notifyArgs, LOGO, type Card,
@@ -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", () => {
@@ -171,6 +176,30 @@ test("backlog: an abandoned run's items are neither listed nor counted", () => {
   rmSync(dir, { recursive: true });
 });
 
+test("runToIdea: a planning run goes back to its idea, newer than the run", () => {
+  const id = "2026-09-04-planning", dir = join(state, "runs", id);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "state.json"), JSON.stringify({ id, stage: "plan", awaiting: "approvals.plan" }));
+  writeFileSync(join(dir, "00-request.md"), "/kaizen lite export invoices as csv\n");
+  const then = new Date(Date.now() - 30_000);
+  utimesSync(join(dir, "00-request.md"), then, then);
+  writeInbox(state, [...readInbox(state), { status: "started", text: "export invoices", added: Date.now() - 60_000 }, { status: "started", text: "export invoices as csv", notes: "see #12", added: Date.now() - 60_000 }]);
+  expect(runToIdea(state, id)).toBeNull();
+  expect(JSON.parse(readFileSync(join(dir, "state.json"), "utf8")).stage).toBe("abandoned");
+  const cards = boardCards([state], Date.now());
+  expect(cards.find((c) => c.kind === "idea" && c.text === "export invoices as csv")).toMatchObject({ status: "idea", notes: "see #12" });
+  expect(cards.find((c) => c.kind === "run" && c.id === id)?.archived).toBe(true);
+  expect(readInbox(state).filter((l) => l.text === "export invoices as csv").length).toBe(1);
+  expect(readInbox(state).find((l) => l.text === "export invoices")?.status).toBe("started");
+  expect(runToIdea(state, id)).toMatch(/planning/);
+  writeFileSync(join(dir, "state.json"), JSON.stringify({ id, stage: "plan" }));
+  rmSync(join(dir, "00-request.md"));
+  expect(runToIdea(state, id)).toMatch(/no request/);
+  replaceIdea(state, "export invoices", null);
+  setArchived(state, id, false);
+  rmSync(dir, { recursive: true });
+});
+
 test("abandonRun refuses a done run", () => {
   expect(abandonRun(state, "2026-09-02-done", "late")).toMatch(/already done/);
 });
@@ -501,6 +530,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 +996,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 +1004,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 +1027,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 });

package/cli/state.ts

@@ -405,9 +405,11 @@ export function readRuns(state: string): Run[] {
       const file = join(dir, id, "state.json");
       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.
+      // own mtime is the evidence that anything is still working on it, along with
+      // progress.md, which a builder ticks between state.json writes.
       let moved = 0;
       try { moved = statSync(file).mtimeMs; } catch { /* vanished mid-read */ }
+      try { moved = Math.max(moved, statSync(join(dir, id, "progress.md")).mtimeMs); } catch { /* no progress kept */ }
       return [{ id, stage: s.stage ?? "?", awaiting: s.awaiting ?? null, moved, runner: s.runner, agent: s.agent, branch: typeof s.branch === "string" ? s.branch : undefined }];
     } catch { return []; }
   }).reverse();
@@ -612,6 +614,105 @@ export function allBacklog(state: string) {
   return out;
 }
 
+// Every `- open|done|rejected:` line of a backlog file, numbered from 1 in file order.
+// The number is how a notebook link (`#backlog-3`) and a backlog card name an item, so
+// lines are never removed or reordered: closing one rewrites its status word in place.
+export function backlogLines(file: string) {
+  let text = "";
+  try { text = readText(file); } catch { return []; }
+  const out: { n: number; status: string; text: string; line: number }[] = [];
+  text.split("\n").forEach((l, line) => {
+    const m = /^\s*-\s*(open|done|rejected):\s*(.*)$/.exec(l.replace(/\r$/, ""));
+    if (m) out.push({ n: out.length + 1, status: m[1]!, text: m[2]!.trim(), line });
+  });
+  return out;
+}
+
+// A backlog card's source: a run id, or "orphan" for the state dir's backlog.md.
+function backlogFile(state: string, source: string) {
+  if (source === "orphan") return join(state, "backlog.md");
+  return /^[\w.-]+$/.test(source) ? join(state, "runs", source, "06-backlog.md") : null;
+}
+
+// Line n of a backlog, or null when the source or the line does not exist.
+export function backlogItem(state: string, source: string, n: number) {
+  const file = backlogFile(state, source);
+  return (file && backlogLines(file).find((l) => l.n === n)) || null;
+}
+
+// The runs started from a backlog item, by the `Backlog: <source>#<n>` line the board
+// puts in their request (beside `Parent:`). A run with no state.json yet is not counted.
+// ponytail: reads every 00-request.md per refresh, as startedRuns does.
+export function startedBacklog(state: string) {
+  const out = new Map<string, { id: string; stage: string }[]>();
+  for (const r of readRuns(state)) {
+    let body = "";
+    try { body = readText(join(state, "runs", r.id, "00-request.md")); } catch { continue; }
+    const m = /^\s*(?:\[[^\]]*\]\s*)?Backlog:\s*([\w.-]+)#(\d+)\s*$/im.exec(body);
+    if (!m) continue;
+    const k = `${m[1]}#${Number(m[2])}`;
+    out.set(k, [...(out.get(k) ?? []), { id: r.id, stage: r.stage }]);
+  }
+  return out;
+}
+
+export type BacklogCard = { state: string; where: string; source: string; n: number; text: string; raw: string; severity: string | null; at: string | null };
+
+const SEVERITY_RANK: Record<string, number> = { critical: 0, high: 1, medium: 2, low: 3 };
+
+// The open backlog items of every non-abandoned run and the orphanage, as cards for the
+// board's Ideas column: most severe first, then newest run first, then file order. An
+// item a live run was started from is not shown; an abandoned one gives it back.
+export function backlogCards(states: string[]): BacklogCard[] {
+  const out: BacklogCard[] = [];
+  for (const st of states) {
+    const where = label(st);
+    const started = startedBacklog(st);
+    const runs = existsSync(join(st, "runs")) ? readdirSync(join(st, "runs")).sort().reverse() : [];
+    const sources = [...runs.filter((id) => existsSync(join(st, "runs", id, "state.json")) && !abandoned(join(st, "runs", id))), "orphan"];
+    for (const source of sources) {
+      for (const l of backlogLines(backlogFile(st, source)!)) {
+        if (l.status !== "open") continue;
+        if ((started.get(`${source}#${l.n}`) ?? []).some((c) => c.stage !== "abandoned")) continue;
+        const it = parseItem(l.text);
+        out.push({ state: st, where, source, n: l.n, text: it.text, raw: l.text, severity: it.severity, at: it.where });
+      }
+    }
+  }
+  const rank = (c: BacklogCard) => SEVERITY_RANK[c.severity ?? ""] ?? 4;
+  return out.sort((a, b) => rank(a) - rank(b));
+}
+
+// Rewrite the status of backlog line n from open, keeping its text and every other
+// byte of the file; `suffix` is appended after a ` | `. Null when written, else why not.
+export function closeBacklog(state: string, source: string, n: number, status: "done" | "rejected", suffix: string): string | null {
+  const file = backlogFile(state, source);
+  if (!file || !existsSync(file)) return "no such backlog";
+  const item = backlogLines(file).find((l) => l.n === n);
+  if (!item) return "no such backlog item";
+  if (item.status !== "open") return "that item is already closed";
+  // The raw bytes, not readText: a CRLF file or a BOM stays as it was written.
+  const lines = readFileSync(file, "utf8").split("\n");
+  const old = lines[item.line]!, cr = old.endsWith("\r") ? "\r" : "", bom = item.line === 0 && old.startsWith("\uFEFF") ? "\uFEFF" : "";
+  const body = old.slice(bom.length).replace(/\r$/, "");
+  if (!/^\s*-\s*open:/.test(body)) return "no such backlog item";
+  lines[item.line] = bom + body.replace(/^(\s*-\s*)open:\s*/, `$1${status}: `).replace(/\s+$/, "") + ` | ${suffix}` + cr;
+  writeFileSync(file, lines.join("\n"));
+  return null;
+}
+
+// A backlog item whose run is done is closed by that run: `done: <text> | <run id>`.
+// Run from the board's clock, never from a page load. Reads requests and state.json,
+// writes only backlog files, so no run looks as if it moved.
+export function markBacklogDone(state: string) {
+  for (const [k, kids] of startedBacklog(state)) {
+    const done = kids.find((c) => c.stage === "done");
+    if (!done) continue;
+    const [source, n] = k.split("#");
+    closeBacklog(state, source!, Number(n), "done", done.id);
+  }
+}
+
 // ---------------------------------------------------------------- board data
 
 // ---------------------------------------------------------------- board data
@@ -914,6 +1015,32 @@ export function abandonRun(st: string, id: string, why: string): string | null {
   }
 }
 
+// A run still planning, back to the idea it came from: abandoned and archived (the
+// record stays), and the idea open again. Its fresh stamp is newer than the run's
+// request, so the old run no longer retires it.
+export function runToIdea(st: string, id: string): string | null {
+  let stage = "";
+  try { stage = JSON.parse(readText(join(st, "runs", id, "state.json"))).stage; } catch {}
+  if (stage !== "plan") return "Only a run still in planning goes back to an idea.";
+  let req = "";
+  try { req = readText(join(st, "runs", id, "00-request.md")).trim(); } catch {}
+  const lines = readInbox(st);
+  // The longest started idea the request holds: "test" must not stand in for "test login".
+  let at = -1;
+  lines.forEach((l, i) => { if (l.status === "started" && normalise(req).includes(normalise(l.text)) && (at < 0 || l.text.length > lines[at]!.text.length)) at = i; });
+  const [first = "", ...rest] = req.split("\n");
+  const idea: InboxLine = at >= 0
+    ? { ...lines[at]!, status: "open", added: Date.now() }
+    : { status: "open", text: first.replace(/^\/kaizen(?:-\w+)?\s+(?:(?:lite|full|auto|plan)\s+)?/i, "").trim(), notes: rest.join("\n").trim() || undefined, added: Date.now() };
+  if (!idea.text) return "That run has no request to make an idea of.";
+  const failed = abandonRun(st, id, "Sent back to ideas from the board.");
+  if (failed) return failed;
+  setArchived(st, id, true);
+  if (at >= 0) lines.splice(at, 1);
+  writeInbox(st, [...lines, idea]);
+  return null;
+}
+
 export function replaceIdea(state: string, text: string, next: InboxLine | null) {
   const lines = readInbox(state);
   const at = lines.findIndex((l) => (l.status === "open" || l.status === "started") && l.text === text);
@@ -1015,7 +1142,8 @@ export function boardCards(states: string[], now: number): Card[] {
   }
   // A launched idea whose run reworded the request: the board's own launch record,
   // owned by a run (session id in its state.json, see ownerOf), retires it all the same.
-  const launchedInto = (st: string, t: string) => readSessions(st).some((s) => !s.run && normalise(s.text.replace(/^(lite|full|auto|plan)\s+/i, "")) === t.replace(/^(lite|full|auto|plan)\s+/i, "") && ownerOf(st, s) !== null);
+  const indexes = new Map<string, RunIndex>(), indexOf = (st: string) => indexes.get(st) ?? indexes.set(st, runIndex(st)).get(st)!;
+  const launchedInto = (st: string, t: string) => readSessions(st).some((s) => !s.run && normalise(s.text.replace(/^(lite|full|auto|plan)\s+/i, "")) === t.replace(/^(lite|full|auto|plan)\s+/i, "") && ownerOf(st, s, indexOf(st)) !== null);
   for (const st of states) {
     const where = label(st);
     const archive = readArchive(st);
@@ -1041,7 +1169,8 @@ export function boardCards(states: string[], now: number): Card[] {
     }
     // Runs started in Yolo. Only yolo records are matched to runs, so a project that
     // never used it pays one directory read.
-    const yolos = new Set(readSessions(st).filter((s) => s.yolo).map((s) => ownerOf(st, s)));
+    const yoloRecs = readSessions(st).filter((s) => s.yolo);
+    const yolos = new Set(yoloRecs.length ? yoloRecs.map((s) => ownerOf(st, s, indexOf(st))) : []);
     for (const r of readRuns(st)) {
       next.push({
         kind: "run", id: r.id, status: statusOf(r, now), text: short(r.id), state: st, where, column: columnOf(r.stage, r.awaiting), moved: r.moved,
@@ -1225,33 +1354,45 @@ export function readSessions(st: string): Session[] {
   }).sort((a, b) => a.started - b.started);
 }
 
+// What ownerOf matches a record against, read once: each conversation id a run recorded
+// at intake, to the first run (by id) that recorded it, and every run's request with
+// when it was written.
+type RunIndex = { bySession: Map<string, string>; requests: { id: string; born: number; text: string }[] };
+export function runIndex(st: string): RunIndex {
+  const bySession = new Map<string, string>(), requests: RunIndex["requests"] = [];
+  try {
+    for (const id of readdirSync(join(st, "runs")).sort()) {
+      try {
+        const sid = JSON.parse(readText(join(st, "runs", id, "state.json"))).session;
+        if (sid && !bySession.has(sid)) bySession.set(sid, id);
+      } catch { /* no state yet */ }
+      try {
+        const f = join(st, "runs", id, "00-request.md"), st2 = statSync(f);
+        requests.push({ id, born: st2.birthtimeMs || st2.mtimeMs, text: normalise(readText(f)) });
+      } catch { /* no request yet */ }
+    }
+  } catch { /* no runs dir */ }
+  return { bySession, requests };
+}
+
 // Whose session a record is. A decision's launch names its run. An idea's launch came
 // before its run existed, so it belongs to the first run created after it whose
 // request holds the idea's text: one run per record, never every run that mentions it.
-export function ownerOf(st: string, s: Session): string | null {
+// A caller asking about many sessions passes runIndex(st) once: built per call, it
+// reads every run's state.json and request each time.
+export function ownerOf(st: string, s: Session, idx?: RunIndex): string | null {
   if (s.run) return s.run;
+  const { bySession, requests } = idx ?? runIndex(st);
   // The launch's own conversation id, recorded by the run at intake: holds however the
   // request was worded. Text matching below is for tools that expose no id.
   if (s.sessionId) {
-    try {
-      const mine = readdirSync(join(st, "runs")).filter((id) => {
-        try { return JSON.parse(readText(join(st, "runs", id, "state.json"))).session === s.sessionId; } catch { return false; }
-      }).sort();
-      if (mine.length) return mine[0]!;
-    } catch { /* no runs dir */ }
+    const mine = bySession.get(s.sessionId);
+    if (mine) return mine;
   }
   const t = normalise(s.text);
   let best: string | null = null, at = Infinity;
-  try {
-    for (const id of readdirSync(join(st, "runs"))) {
-      try {
-        const f = join(st, "runs", id, "00-request.md");
-        const st2 = statSync(f), born = st2.birthtimeMs || st2.mtimeMs;
-        // A second of slack: file times come from a coarser clock than Date.now().
-        if (born >= s.started - 1000 && born < at && normalise(readText(f)).includes(t)) { best = id; at = born; }
-      } catch { /* no request yet */ }
-    }
-  } catch { /* no runs dir */ }
+  // A second of slack: file times come from a coarser clock than Date.now().
+  for (const r of requests) if (r.born >= s.started - 1000 && r.born < at && r.text.includes(t)) { best = r.id; at = r.born; }
   return best;
 }
 
@@ -1278,16 +1419,17 @@ export function launchMode(projectDir: string): "card" | "terminal" {
 // Whether a live PID is still the agent a record launched, not a stranger that reused
 // the number: the tool's name (and conversation id) in its arguments, started no
 // earlier than the record. On Windows the PID is the PowerShell kaizen opened.
-function isSession(pid: number, s: Session): boolean {
+// null: the system could not say (no ps, no answer), which callers treat as not ours.
+function isSession(pid: number, s: Session): boolean | null {
   try {
     if (process.platform === "win32") {
-      const out = Bun.spawnSync([sysExe("tasklist.exe"), "/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], { stdin: "ignore", timeout: 5000, windowsHide: true }).stdout.toString();
-      return /^"(powershell|pwsh)\.exe"/i.test(out.trim());
+      const out = Bun.spawnSync([sysExe("tasklist.exe"), "/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], { stdin: "ignore", timeout: 5000, windowsHide: true }).stdout.toString().trim();
+      return out.startsWith('"') ? /^"(powershell|pwsh)\.exe"/i.test(out) : null;
     }
     const ps = onPath("ps");
-    if (!ps) return false;
+    if (!ps) return null;
     const m = /^\s*(\S+)\s+(.*)$/.exec(Bun.spawnSync([ps, "-o", "etime=,args=", "-p", String(pid)], { stdin: "ignore", timeout: 5000 }).stdout.toString().trim());
-    if (!m) return false;
+    if (!m) return null;
     // etime is [[dd-]hh:]mm:ss
     const [d, rest] = m[1].includes("-") ? m[1].split("-") : ["0", m[1]];
     const secs = rest.split(":").reduce((a, n) => a * 60 + Number(n), 0) + Number(d) * 86400;
@@ -1296,7 +1438,7 @@ function isSession(pid: number, s: Session): boolean {
     const idInArgs = s.sessionId && (SESSION_FLAGS[s.cmd]?.start || s.resumed);
     return Date.now() - secs * 1000 >= s.started - 2000 && m[2].includes(s.cmd) && (!idInArgs || m[2].includes(s.sessionId!));
   } catch {
-    return false;
+    return null;
   }
 }
 
@@ -1323,7 +1465,19 @@ function closeOne(st: string, s: Session): boolean {
   return closed;
 }
 
-const openSessions = (st: string) => readSessions(st).filter((s) => existsSync(join(sessionsDir(st), s.key + ".pid")));
+// Sessions with a PID file. A file whose process is gone, or whose number another
+// process now holds, is dropped on the way: one is left per launch that ended by itself,
+// and each would be asked about every sweep. Only when the system says so; a PID it
+// cannot answer for stays.
+const openSessions = (st: string) => readSessions(st).filter((s) => {
+  const f = join(sessionsDir(st), s.key + ".pid");
+  if (!existsSync(f)) return false;
+  const pid = parseInt(readText(f));
+  let gone = false;
+  try { process.kill(pid, 0); } catch (e: any) { gone = e?.code === "ESRCH"; }
+  if (gone || (pid > 0 && isSession(pid, s) === false)) { rmSync(f, { force: true }); return false; }
+  return true;
+});
 
 // Close every session kaizen opened for a run, those launched before `before` only,
 // so a decision's own successor is never caught. The record stays: it holds the
@@ -1331,7 +1485,8 @@ const openSessions = (st: string) => readSessions(st).filter((s) => existsSync(j
 export function closeSessions(st: string, id: string, opts: { before?: number } = {}): number {
   try {
     if (!closeEnabled(dirname(st))) return 0;
-    return openSessions(st).filter((s) => s.started < (opts.before ?? Infinity) && ownerOf(st, s) === id).filter((s) => closeOne(st, s)).length;
+    const idx = runIndex(st);
+    return openSessions(st).filter((s) => s.started < (opts.before ?? Infinity) && ownerOf(st, s, idx) === id).filter((s) => closeOne(st, s)).length;
   } catch { return 0; }
 }
 
@@ -1343,9 +1498,9 @@ export function sweepSessions(st: string, now: number) {
   try {
     const live = openSessions(st);
     if (!live.length || !closeEnabled(dirname(st))) return;
-    const runs = new Map(readRuns(st).map((r) => [r.id, r]));
+    const runs = new Map(readRuns(st).map((r) => [r.id, r])), idx = runIndex(st);
     for (const s of live) {
-      const r = runs.get(ownerOf(st, s) ?? "");
+      const r = runs.get(ownerOf(st, s, idx) ?? "");
       if (r && r.stage === "done" && s.started <= r.moved && now - r.moved >= CLOSE_GRACE_MS && !typedSince(st, s, r.moved)) closeOne(st, s);
     }
   } catch { /* the next sweep tries again */ }
@@ -1376,9 +1531,9 @@ export function firstSession(st: string, id: string, cmd: string, cwd: string):
   const f = SESSION_FLAGS[cmd];
   if (!f) return null;
   const all = readSessions(st);
-  const taken = new Set(all.flatMap((s) => (s.sessionId ? [s.sessionId] : [])));
+  const taken = new Set(all.flatMap((s) => (s.sessionId ? [s.sessionId] : []))), idx = runIndex(st);
   for (const s of all) {
-    if (s.cmd !== cmd || ownerOf(st, s) !== id) continue;
+    if (s.cmd !== cmd || ownerOf(st, s, idx) !== id) continue;
     if (!s.sessionId && f.find) {
       // Before the tool's next launch here, any run's: from then on a conversation may be that launch's.
       const next = all.find((o) => o.cmd === cmd && o.started > s.started)?.started ?? Infinity;
@@ -1397,7 +1552,7 @@ export function firstSession(st: string, id: string, cmd: string, cwd: string):
 // The tool and model a run was started with: its latest recorded launch, else the
 // agent its state.json names. A decision continues on these whatever the config says now.
 export function runAgent(st: string, id: string): { cmd: string; model: string | null } | null {
-  const s = readSessions(st).filter((x) => ownerOf(st, x) === id).pop();
+  const idx = runIndex(st), s = readSessions(st).filter((x) => ownerOf(st, x, idx) === id).pop();
   if (s) return { cmd: s.cmd, model: s.model ?? null };
   try {
     const a = JSON.parse(readText(join(st, "runs", id, "state.json"))).agent;
@@ -1469,7 +1624,9 @@ export function launchRun(it: Item, from: string, run?: string, pick: { agent?:
   // Yolo was picked for one tool; a fallback to another opens in its normal mode.
   // A decision on a run started in Yolo keeps it, or its next stage stops on every command.
   const st = join(projectDir, ".kaizen");
-  const wasYolo = !!run && !pick.agent && readSessions(st).some((s) => s.yolo && s.cmd === agent.cmd && ownerOf(st, s) === run);
+  const yoloRecs = run && !pick.agent ? readSessions(st).filter((s) => s.yolo && s.cmd === agent.cmd) : [];
+  const idx = yoloRecs.length ? runIndex(st) : undefined;
+  const wasYolo = yoloRecs.some((s) => ownerOf(st, s, idx) === run);
   const yolo = (wasYolo || (!!pick.yolo && agent.cmd === pick.agent)) && !!YOLO_FLAGS[agent.cmd];
   const flags = [...agentFlags(projectDir, agent.cmd, undefined, model), ...(yolo ? YOLO_FLAGS[agent.cmd] : [])];
   // The idea as its run's request will hold it: without the runner word in front.
@@ -1555,7 +1712,8 @@ async function gitAsync(dir: string, ...args: string[]) {
   } catch { return NO_GIT; }
 }
 
-export type GitStatus = { repo: false } | { repo: true; branch: string; remote: string; files: string[]; ahead: number; others?: number; shared?: string[] };
+export type GitStatus = { repo: false } | { repo: true; branch: string; remote: string; files: string[]; ahead: number; others?: number; shared?: string[]; unpushed?: Unpushed[] };
+type Unpushed = { at: number; subject: string; files: string[] };
 
 // A project the board can commit for: a git work tree with somewhere to push.
 export function gitStatus(projectDir: string): GitStatus {
@@ -1567,7 +1725,14 @@ export function gitStatus(projectDir: string): GitStatus {
   // No upstream yet means nothing of this branch is on the remote: any commit is ahead.
   const up = git(projectDir, "rev-list", "--count", "@{u}..HEAD");
   const ahead = up.ok ? Number(up.out) : git(projectDir, "rev-parse", "HEAD").ok ? 1 : 0;
-  return { repo: true, branch: git(projectDir, "branch", "--show-current").out, remote, files: st ? st.split("\n") : [], ahead };
+  // Each commit not on the remote yet, with its files: a run is ahead only by its own.
+  const unpushed = up.ok && ahead > 0
+    ? git(projectDir, "log", "@{u}..HEAD", "--format=%x00%ct %s", "--name-only").out.split("\0").slice(1).map((c) => {
+        const [head, ...files] = c.trim().split("\n"), sp = head.indexOf(" ");
+        return { at: Number(head.slice(0, sp)) * 1000, subject: head.slice(sp + 1).trim(), files: files.filter(Boolean) };
+      })
+    : undefined;
+  return { repo: true, branch: git(projectDir, "branch", "--show-current").out, remote, files: st ? st.split("\n") : [], ahead, ...(unpushed ? { unpushed } : {}) };
 }
 
 // The path of a `git status --porcelain` line; for a rename, the new one.
@@ -1592,10 +1757,44 @@ function runReports(state: string): Report[] {
   try { ids = readdirSync(join(state, "runs")); } catch {}
   return ids.map((id) => ({ id, ...runReport(state, id) }));
 }
-const runFiles = (changed: string[], mine: Report, rest: Report[]) => changed.filter((l) => {
+// A run holds a path at time `t` when its report names it, was written by then, and no
+// other run naming it reported in between.
+const owns = (mine: Report, rest: Report[], p: string, t: number) =>
+  names(mine.text, p) && mine.at <= t && !rest.some((r) => r.at > mine.at && r.at <= t && names(r.text, p));
+const lastCommit = (dir: string, p: string) => Number(git(dir, "--literal-pathspecs", "log", "-1", "--format=%ct", "--", p).out) * 1000;
+// A changed file is the run's unless it was committed after the report: then the run's
+// work in it is in, and what changed since is someone else's. A commit in the same
+// second as the report keeps the file offered; hiding real work is the worse mistake.
+const runFiles = (dir: string, changed: string[], mine: Report, rest: Report[]) => changed.filter((l) => {
   const p = statusPath(l);
-  return names(mine.text, p) && !rest.some((r) => r.at > mine.at && names(r.text, p));
+  return owns(mine, rest, p, Infinity) && !(lastCommit(dir, p) > mine.at);
 });
+// How many unpushed commits each run has, worked out once for every run. A commit is
+// one run's, so a wide commit is not pinned on every old run that once touched a file
+// in it: the run whose report holds its subject (the `## Commit` message), else, of
+// the runs that reported by then (to the end of that second, since commit times are
+// whole seconds), the one naming most of its paths, the latest on a tie. One naming
+// none, a merge or a hand commit, goes to the run that reported last, so some run
+// still offers the push. No upstream yet: nothing is on the remote, every run is ahead by
+// the branch.
+function aheadBy(s: GitStatus & { repo: true }, all: Report[]): (id: string) => number {
+  if (!s.unpushed) return () => s.ahead;
+  const n = new Map<string, number>();
+  for (const c of s.unpushed) {
+    // The subject as a line of its own: a short one ("wip") is not found inside prose.
+    let best = c.subject ? all.find((r) => r.text.split("\n").some((l) => l.trim() === c.subject)) : undefined;
+    if (!best) {
+      let most = -1;
+      for (const r of all) {
+        if (!r.text || r.at > c.at + 999) continue;
+        const k = c.files.filter((p) => names(r.text, p)).length;
+        if (k > most || (k === most && r.at > best!.at)) { best = r; most = k; }
+      }
+    }
+    if (best) n.set(best.id, (n.get(best.id) ?? 0) + 1);
+  }
+  return (id) => n.get(id) ?? 0;
+}
 
 // The project's status narrowed to one run: a changed file is the run's when its
 // report names the path in backticks and no run that reported later names it too,
@@ -1610,14 +1809,15 @@ export function runGit(state: string, id: string): GitStatus {
   if (!s.repo) return s;
   const all = runReports(state), mine = all.find((r) => r.id === id) ?? { id, text: "", at: 0 };
   const rest = all.filter((o) => o.id !== id);
-  const files = runFiles(s.files, mine, rest);
+  const files = runFiles(dir, s.files, mine, rest);
   const shared = files.flatMap((l) => {
     const p = statusPath(l);
-    const since = Number(git(dir, "--literal-pathspecs", "log", "-1", "--format=%ct", "--", p).out) * 1000;
+    const since = lastCommit(dir, p);
     const who = rest.filter((r) => r.at > since && names(r.text, p)).map((r) => short(r.id));
     return who.length ? [`${p}: ${who.join(", ")}`] : [];
   });
-  return { ...s, files, others: s.files.length - files.length, shared };
+  const { unpushed, ...base } = s;
+  return { ...base, files, ahead: aheadBy(s, all)(id), others: s.files.length - files.length, shared };
 }
 
 // What the board did for a run, kept beside the run and not in state.json, whose
@@ -1633,15 +1833,15 @@ export function readCommit(state: string, id: string): { sha: string; pushed: bo
 // (`gitBtn` in web/board/git.ts): one project status and one read of the reports for
 // the lot. A run with nothing to say either way gets no entry.
 export function cardsGit(state: string, ids: string[]): Record<string, "pending" | "pushed"> {
-  const s = gitStatus(dirname(state)), out: Record<string, "pending" | "pushed"> = {};
+  const dir = dirname(state), s = gitStatus(dir), out: Record<string, "pending" | "pushed"> = {};
   if (!s.repo) return out;
-  const all = runReports(state);
+  const all = runReports(state), ahead = aheadBy(s, all);
   for (const id of ids) {
     const mine = all.find((r) => r.id === id) ?? { id, text: "", at: 0 }, k = readCommit(state, id);
-    const files = runFiles(s.files, mine, all.filter((o) => o.id !== id)).length;
+    const files = runFiles(dir, s.files, mine, all.filter((o) => o.id !== id)).length;
     if (files) out[id] = "pending";
     else if (k?.pushed) out[id] = "pushed";
-    else if (s.ahead > 0) out[id] = "pending";
+    else if (ahead(id) > 0) out[id] = "pending";
     else if (k || mine.text) out[id] = "pushed";
   }
   return out;