kaizen-agent 1.42.2 → 1.43.0

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
@@ -1015,7 +1116,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 +1143,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 +1328,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 +1393,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 +1412,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 +1439,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 +1459,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 +1472,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 +1505,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 +1526,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 +1598,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 +1686,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 +1699,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 +1731,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 +1783,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 +1807,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;

package/cli/web.ts

@@ -6,8 +6,8 @@ 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,
   appendNote, saveAttachment, pidOnPort, readText, cmdExe, sysExe, powershellExe, runGit, cardsGit, readCommit, commitPush, notice, notifier, LOGO,
-  reviewFindings, pickFindings, fixPrompt, approvalPrompt, canApproveAwaiting, nativePath, closeSessions, sweepSessions, issueUrl,
-  launchMode, readSessions, ownerOf, resumePrompt, runAgent, firstSession, webHosts,
+  reviewFindings, pickFindings, backlogCards, backlogItem, startedBacklog, closeBacklog, markBacklogDone, fixPrompt, approvalPrompt, canApproveAwaiting, nativePath, closeSessions, sweepSessions, issueUrl,
+  launchMode, readSessions, ownerOf, runIndex, resumePrompt, runAgent, firstSession, webHosts,
 } from "./state.ts";
 import { attachPty, writePty, resizePty, ptyState, ptyKeys, adoptLoginEnv } from "./pty.ts";
 import { readSources, addSource, removeSource, moveSource, setCategory, setWriteback, readIcebox, promote, dismiss, restore, addItem, githubRepo, markDone, markReplied, gatherSource, freshImages, gatherAll, gatherDirs, due, socialUrl, socialOf } from "./sources.ts";
@@ -190,17 +190,27 @@ export async function web(repoDir: string, opts: Opts = {}) {
   const inCard = (dir: string) => ({ card: launchMode(projectOf(dir)) === "card", onChange: changed });
   // An idea's session, until its run exists and owns it (ownerOf).
   const ideaPty = new Map<string, string>();
+  // Backlog items this board launched whose run has not written its state.json yet:
+  // shown as starting, like a started idea. Forgotten on restart; the card then offers Run again.
+  const backlogLaunched = new Set<string>();
   // The card's newest in-card session, live or recently ended. Sessions are only read
   // while this board has any, so /state costs nothing more for terminal launches.
-  const ptyOf = (c: Card) => {
+  // Owners are worked out once per /state: per card it re-read every session and every
+  // run's state.json, about a second on a board of 400 runs.
+  const ptyOf = (cards: Card[]) => {
     const live = new Set(ptyKeys());
-    if (!live.size) return undefined;
-    const key = c.kind === "run"
-      ? readSessions(c.state).filter((s) => live.has(s.key) && ownerOf(c.state, s) === c.id).pop()?.key
-      : ideaPty.get(`${c.state}\0${c.text}`);
-    if (!key || !live.has(key)) return undefined;
-    const st = ptyState(key)!;
-    return { key, alive: st.alive, asking: st.asking };
+    if (!live.size) return () => undefined;
+    const runs = new Map<string, string>();
+    for (const d of new Set(cards.filter((c) => c.kind === "run").map((c) => c.state))) {
+      const ids = runIndex(d);
+      for (const s of readSessions(d)) if (live.has(s.key)) runs.set(`${d}\0${ownerOf(d, s, ids)}`, s.key); // oldest first: the newest wins
+    }
+    return (c: Card) => {
+      const key = c.kind === "run" ? runs.get(`${c.state}\0${c.id}`) : ideaPty.get(`${c.state}\0${c.text}`);
+      if (!key || !live.has(key)) return undefined;
+      const st = ptyState(key)!;
+      return { key, alive: st.alive, asking: st.asking };
+    };
   };
   // Dev: the page reloads itself when board.html or its bundle is saved. Server code needs
   // `bun --watch cli/install.ts web`; the page reconnects and reloads on hello.
@@ -271,7 +281,7 @@ export async function web(repoDir: string, opts: Opts = {}) {
   // Done requests are reported back to their sources here, on the board's own clock: a
   // page load only reads, so opening the Icebox never closes an issue.
   const loop = setInterval(async () => {
-    for (const dir of states(true)) { try { markDone(dir); await writeBacks(dir); } catch { /* the next tick tries again */ } }
+    for (const dir of states(true)) { try { markDone(dir); markBacklogDone(dir); await writeBacks(dir); } catch { /* the next tick tries again */ } }
   }, 60_000);
 
   const BOOT = Date.now().toString(36);
@@ -443,7 +453,7 @@ export async function web(repoDir: string, opts: Opts = {}) {
           return !root || d === state || (fold(p).startsWith(inside)
             && (!isGroup(p) || filled(d) || fold(dirname(p)) !== fold(root)));
         });
-        const cards = boardCards(dirs, Date.now());
+        const cards = boardCards(dirs, Date.now()), pty = ptyOf(cards);
         // The git mark, for the cards whose panel offers commit and push: one status per project.
         const marks = new Map<string, Record<string, string>>();
         const markable = (c: Card) => c.kind === "run" && !c.archived && (c.status === "done" || c.awaiting === "approvals.review") && c.state !== join(home, ".kaizen");
@@ -456,7 +466,8 @@ export async function web(repoDir: string, opts: Opts = {}) {
           project, all, dir: state,
           projects: picker.map((d) => ({ dir: d, label: label(d), logo: !!projectLogo(d) })),
           fresh: unset.map((d) => ({ dir: join(d, ".kaizen"), label: tilde(d) })),
-          cards: cards.map((c) => ({ ...c, notice: notice(c), git: markable(c) ? marks.get(c.state)?.[c.id!] : undefined, open: openFindings(c), pty: ptyOf(c) })),
+          cards: cards.map((c) => ({ ...c, notice: notice(c), git: markable(c) ? marks.get(c.state)?.[c.id!] : undefined, open: openFindings(c), pty: pty(c) })),
+          backlog: backlogCards(dirs).map((b) => ({ ...b, starting: backlogLaunched.has(`${b.state}\0${b.source}#${b.n}`) || undefined })),
           now: Date.now(),
         });
       }
@@ -667,7 +678,8 @@ export async function web(repoDir: string, opts: Opts = {}) {
         if (!/^(runs\/[\w.-]+\/)?attachments\/[\w.-]+$/.test(p)) return bad("bad path");
         const f = join(dir, p);
         if (!existsSync(f)) return bad("no such file", 404);
-        return new Response(Bun.file(f), { headers: { "cache-control": "private, max-age=3600" } });
+        // no-cache: a revise retakes a screenshot under the same name, and the browser must ask again.
+        return new Response(Bun.file(f), { headers: { "cache-control": "private, no-cache" } });
       }
 
       // An icebox image, sent on to a link read fresh from its source: the one kept
@@ -781,6 +793,18 @@ export async function web(repoDir: string, opts: Opts = {}) {
           return json({ ok: true, project: label(dir) });
         }
 
+        // "Not doing this" on a backlog card: the line is closed in place with the reason,
+        // never removed, so a notebook link to it keeps its number.
+        if (path === "/backlog") {
+          if (body.op !== "reject") return bad("unknown op");
+          const why = String(body.reason ?? "").trim();
+          if (!why) return bad("a rejection needs a reason");
+          const err = closeBacklog(dir, String(body.source ?? ""), Number(body.n), "rejected", why);
+          if (err) return bad(err, err === "that item is already closed" ? 409 : 404);
+          changed();
+          return json({ ok: true });
+        }
+
         if (path === "/inbox") {
           const text = String(body.text ?? "").trim();
           // Absent means untouched; an empty string clears. replaceIdea keeps the
@@ -922,11 +946,30 @@ export async function web(repoDir: string, opts: Opts = {}) {
         if (path === "/run") {
           const text = String(body.text ?? "").trim();
           const kind = body.kind === "full" || body.kind === "lite" ? body.kind : "";
-          if (!text) return bad("empty idea");
+          if (!text && !body.backlog) return bad("empty idea");
           const agent = typeof body.agent === "string" && body.agent ? body.agent : undefined;
           if (agent && !KNOWN_AGENTS.some((a) => a.cmd === agent)) return bad("unknown agent");
           const model = typeof body.model === "string" ? body.model.trim() : "";
           if (model && !plainModel(model)) return bad("A model name is letters, digits and . : / @ _ - only");
+          // A backlog item runs as an idea would, its text read here from the file, never
+          // from the page. The request names its source, which is how the board finds the
+          // line again: to hide the card while the run lives, and to close it when done.
+          if (body.backlog) {
+            const source = String(body.backlog.source ?? ""), n = Number(body.backlog.n);
+            const line = backlogItem(dir, source, n);
+            if (!line) return bad("no such backlog item", 404);
+            if (line.status !== "open") return bad("that item is already closed", 409);
+            if ((startedBacklog(dir).get(`${source}#${n}`) ?? []).some((c) => c.stage !== "abandoned")) return bad("a run was already started from that item", 409);
+            const p = parseItem(line.text);
+            const it: Item = { ...p, text: kind ? `${kind} ${p.text}` : p.text };
+            it.notes = [source !== "orphan" ? `Parent: ${source}` : "", `Backlog: ${source}#${n}`, p.text !== line.text ? `Backlog item: ${line.text}` : ""].filter(Boolean).join("\n");
+            const r = launchRun(it, dir, undefined, { agent, model: model || undefined, yolo: body.yolo === true, ...inCard(dir) });
+            if (r.ok) backlogLaunched.add(`${dir}\0${source}#${n}`);
+            changed();
+            return json(r.ok
+              ? { ok: true, agent: r.agent, project: tilde(r.projectDir), pty: r.pty }
+              : { ok: false, why: r.why, manual: r.manual, agent: r.agent }, r.ok ? 200 : 500);
+          }
           const it: Item = parseItem(`${kind} ${text}`.trim());
           // A `started` idea may be run again: the terminal the first launch opened
           // can come up empty, and nothing else tells the board a run never began.

package/package.json

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

package/web/board/approvals.ts

@@ -2,7 +2,7 @@ import { store } from "./store.ts";
 import { where } from "./agent-term.ts";
 import { post } from "./api.ts";
 import { key, via } from "./cards.ts";
-import { $, esc } from "./dom.ts";
+import { $, html } from "./dom.ts";
 import { openRun } from "./panel.ts";
 import { askNotify, toast } from "./toast.ts";
 
@@ -57,7 +57,7 @@ export async function decide(c, b, why, answers) {
 export function confirmRevise(c) {
   const foot = $("pfoot"),
     plan = c.awaiting === "approvals.plan";
-  foot.innerHTML = `<div class="inl" style="flex:1"><div class="q">${plan ? "What should the plan do differently?" : "What should change in the work?"}</div><div class="q dim">Opens your agent on this run with your comment.${plan ? " It revises the plan and comes back here for approval." : " It changes the work, rechecks it and comes back here."}</div><textarea aria-label="Revise comment"></textarea><div class="row"><button class="btn ghost" data-a="c">Cancel</button><button class="btn pri" data-a="s">Send back</button></div></div>`;
+  foot.innerHTML = html`<div class="inl" style="flex:1"><div class="q">${plan ? "What should the plan do differently?" : "What should change in the work?"}</div><div class="q dim">Opens your agent on this run with your comment.${plan ? " It revises the plan and comes back here for approval." : " It changes the work, rechecks it and comes back here."}</div><textarea aria-label="Revise comment"></textarea><div class="row"><button class="btn ghost" data-a="c">Cancel</button><button class="btn pri" data-a="s">Send back</button></div></div>`;
   const inp = foot.querySelector("textarea");
   inp.focus();
   foot.querySelector("[data-a=c]").onclick = () => {
@@ -78,7 +78,7 @@ export function confirmRevise(c) {
 // a note for what the options miss. Each answer reaches the agent as one line.
 export function confirmAnswers(c, qs) {
   const foot = $("pfoot");
-  foot.innerHTML = `<div class="inl qa" style="flex:1"><div class="q">The plan asks ${qs.length === 1 ? "one question" : qs.length + " questions"}.</div><div class="q dim">Your answers go to your agent with the approval. It records them and builds the plan.</div>${qs.map((x, i) => `<fieldset><legend>${esc(x.q)}</legend>${x.options.map((o, j) => `<label><input type="${x.multi ? "checkbox" : "radio"}" name="q${i}" value="${j}"${o.rec || (!x.multi && !j && !x.options.some((p) => p.rec)) ? " checked" : ""}> ${esc(o.text)}</label>`).join("")}<input type="text" data-n="${i}" placeholder="Note (optional)" aria-label="Note: ${esc(x.q)}"></fieldset>`).join("")}<div class="row"><button class="btn ghost" data-a="c">Cancel</button><button class="btn pri" data-a="s">Approve with these answers</button></div></div>`;
+  foot.innerHTML = html`<div class="inl qa" style="flex:1"><div class="q">The plan asks ${qs.length === 1 ? "one question" : qs.length + " questions"}.</div><div class="q dim">Your answers go to your agent with the approval. It records them and builds the plan.</div>${qs.map((x, i) => html`<fieldset><legend>${x.q}</legend>${x.options.map((o, j) => html`<label><input type="${x.multi ? "checkbox" : "radio"}" name="q${i}" value="${j}"${o.rec || (!x.multi && !j && !x.options.some((p) => p.rec)) ? " checked" : ""}> ${o.text}</label>`)}<input type="text" data-n="${i}" placeholder="Note (optional)" aria-label="Note: ${x.q}"></fieldset>`)}<div class="row"><button class="btn ghost" data-a="c">Cancel</button><button class="btn pri" data-a="s">Approve with these answers</button></div></div>`;
   foot.querySelector("[data-a=c]").onclick = () => {
     foot.innerHTML = "";
     openRun(c, true);