kaizen-agent 1.42.2 → 1.43.1

package/cli/web.ts

@@ -4,10 +4,10 @@ import { existsSync, readdirSync, statSync, watch, appendFileSync, mkdirSync, cp
 import { join, dirname, resolve, sep, basename } from "node:path";
 import {
   home, type Item, type Card, boardCards, knownProjects, remember, locate, label, tilde, searchRoots, findProjects,
-  readInbox, writeInbox, replaceIdea, moveIdea, abandonRun, launchRun, parseItem, agentChoices, projectOf, KNOWN_AGENTS, plainModel, short, setArchived, writeNotes,
+  readInbox, writeInbox, replaceIdea, moveIdea, abandonRun, runToIdea, 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.
@@ -1097,6 +1140,14 @@ export async function web(repoDir: string, opts: Opts = {}) {
             : { ok: false, why: r.why, manual: r.manual, agent: r.agent }, r.ok ? 200 : 500);
         }
 
+        if (path === "/to-idea") {
+          const id = String(body.id ?? "");
+          if (!/^[\w.-]+$/.test(id)) return bad("bad run id");
+          const failed = runToIdea(dir, id);
+          changed();
+          return failed ? bad(failed, 409) : json({ ok: true });
+        }
+
         if (path === "/abort") {
           const id = String(body.id ?? "");
           const why = String(body.why ?? "").trim() || "abandoned from the web board";

package/package.json

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

package/skills/kaizen/README.md

@@ -207,11 +207,7 @@ the defaults.
 | `auto_fix.max_iterations` | `2` | Fix/recheck rounds before whatever is left is escalated to you |
 | `review.memory_max_lines` | `100` | The cap on `memory.md`, which every stage of every run reads. Raise only if the lessons are genuinely all load-bearing |
 | `git.auto_commit` | `false` | `true` commits the files a run changed when it is done, by path. Never pushes |
-| `track.default` | `auto` (inferred) | A repo that is always one kind of work, e.g. a docs repo |
 | `backlog.enabled` | `true` | Set `false` to skip both backlog capture points; the run still executes, just without a `06-backlog.md` |
-| `backlog.file` | `06-backlog.md` | The per-run file name. Rarely. |
-| `backlog.statuses` | `[open, done, rejected]` | Rarely. Only `open` items are printed |
-| `backlog.orphan_file` | `backlog.md` | Where open items go when their run is pruned |
 | `state.keep_runs` | `20` | You want a longer or shorter run history |
 
 Mode never overrides a refusal: destructive or irreversible actions still get confirmed

package/skills/kaizen/SKILL.md

@@ -276,7 +276,10 @@ After a subagent returns, update `state.json` yourself in the main thread. Subag
 report; the main thread owns the state machine.
 Before moving any run from `build` to `review`, under either runner, apply the
 *Preview gate* in [`spec-main.md`](spec-main.md): no `## Preview` with a screenshot
-(or a one-line reason there is none) means the build is not done.
+(or a one-line reason there is none) means the build is not done. Before the final
+report and before `stage: "done"`, under either runner and in every mode, apply the
+*Docs gate* there too: the project's docs vault is brought up to date with what the
+run changed.
 
 **Name files, do not narrate them.** The prompt says which paths to read, which
 decisions bind the stage, and what to report back. It does not summarize those files:

package/skills/kaizen/config.default.yml

@@ -58,45 +58,7 @@ auto_fix:
   # knob in the file. A third round rarely closes what two could not.
   max_iterations: 2
 
-track:
-  # The kind of work a run is doing, which decides what "deliverable",
-  # "verification", and "finding" mean for every stage. It is INFERRED from the
-  # request by the planner and stated back in the plan's Framing for the user to
-  # correct at the approval — the user is never asked to categorize their own request.
-  # Set this only to pin a default for a repo that is always one kind of work
-  # (e.g. a docs repo). auto (or empty) infers per run.
-  default: auto
-
 review:
-  # Checks that run in every track.
-  checks:
-    - correctness
-    - plan_conformance
-  # Additional checks per track, chosen by what the run actually is. The planner may
-  # name a track not listed here; the reviewer then derives its checks from the
-  # track's "what would make it wrong".
-  # Each check below is one question the reviewer asks; the line beside it says which.
-  track_checks:
-    # security - no new way in, no secret or user data exposed
-    # reuse_simplification - nothing rebuilt that the codebase already had
-    # test_coverage - the changed behaviour has a check that fails when it breaks
-    software: [security, reuse_simplification, test_coverage]
-    # blast_radius and regression are universal — see spec-review.md — not listed here.
-    # completeness - every part the piece promises is actually present
-    # claim_accuracy - every checkable claim traced to a source
-    # reader_usability - its intended reader can act on it without asking
-    writing: [completeness, claim_accuracy, reader_usability]
-    # audience_fit - written for the people who will actually read it
-    # voice_consistency - reads as the same voice as the surrounding material
-    communication: [claim_accuracy, audience_fit, voice_consistency]
-    # prerequisites - everything needed before step one is stated
-    # rollback - a way back exists for every step that changes something
-    # executability - someone else can run it start to finish unaided
-    operations: [prerequisites, rollback, executability]
-    # evidence_support - the conclusion follows from evidence shown, not asserted
-    # selection_bias - the evidence was not picked to fit the answer
-    # alternatives - the readings that were rejected are named and why
-    research: [evidence_support, selection_bias, alternatives]
   # Let the reviewer append durable lessons to .kaizen/memory.md.
   write_memory: true
   # Every stage of every future run reads memory.md, so cap it. Over this, the reviewer
@@ -108,20 +70,12 @@ backlog:
   # not take, findings below the fix threshold, and debts deferred at an approval.
   # Written by the main thread at the plan approval and again at the final approval.
   enabled: true
-  # Per run, beside its plan and review — provenance without a central file to sync.
-  file: 06-backlog.md
-  # Items are open | done | rejected. Only open ones are printed by /kaizen backlog;
-  # closed ones stay in their run's file as record.
-  statuses: [open, done, rejected]
-  # Before state.keep_runs prunes a run, its still-open items move here, relative to
-  # state.dir. Done and rejected items are pruned with the run.
-  orphan_file: backlog.md
 
 state:
   dir: .kaizen
   # Keep this many completed runs before pruning the oldest. `kaizen prune` lists
   # what would go and `kaizen prune --yes` deletes it, after rescuing open backlog
-  # items into backlog.orphan_file, so it never destroys open work.
+  # items into backlog.md beside memory.md, so it never destroys open work.
   keep_runs: 20
 
 git:
@@ -130,9 +84,6 @@ git:
   # pushes. false: never commit, push, or open a PR unless the user explicitly asks.
   # Ignored when the project is not a git repository.
   auto_commit: false
-  # Create a branch before the implement stage when on the default branch.
-  # Ignored when the project is not a git repository.
-  branch_before_implement: true
   # Build each run on its own branch (kaizen/<run-id>) in its own git worktree under
   # .kaizen/wt/, so runs and people working at the same time never share a folder. Done
   # lands the branch by pull request (gh) or a rebase and push. Ignored when the

package/skills/kaizen/docs.md

@@ -1,8 +1,9 @@
 # Kaizen — docs
 
 Read for `/kaizen docs` and `/kaizen docs lint`. Nothing else needs this file, except
-the two paragraphs in `spec-build.md` and `spec-review.md` that keep the vault current
-during a run.
+the paragraphs in `spec-build.md` and `spec-review.md` that keep the vault current
+during a run, and the *Docs gate* in `spec-main.md`, which reads *Update* step 4 and
+*Lint* before a run is done.
 
 `/kaizen docs` writes a project's documentation into the notebook as a small vault an
 agent reads before it plans or builds: an **Index** listing every note with one line on

package/skills/kaizen/settings.md

@@ -23,17 +23,24 @@ nearest first, so a change lands globally unless this project keeps its own conf
 | `auto_fix.max_iterations` | `1`–`5` | Fix and recheck rounds before what is left is escalated |
 | `review.write_memory` | `true`, `false` | Let the reviewer append lessons to `memory.md` |
 | `git.auto_commit` | `true`, `false` | Commit the work when a run finishes |
-| `git.branch_before_implement` | `true`, `false` | Branch before building when on the default branch |
 | `git.worktree_per_run` | `true`, `false` | Build each run on its own branch in its own worktree and land it by pull request |
 | `ui.mouse` | `false`, `true` | Click to select, click again to act; while on, the terminal cannot select text |
 | `subagents.model` | `inherit`, `opus`, `sonnet`, `haiku` | Model the stage subagents run on (Claude Code only) |
 | `subagents.effort` | `inherit`, `low`, `medium`, `high` | Reasoning effort for the stage subagents (Claude Code only) |
 | `sources.every` | `off`, `1h`, `6h`, `24h` | How often the web board checks request sources for new requests, into the icebox, while it runs |
-| `sources.agent` | `ask`, `chatgpt`, `agent` | Who reads social sources when Gather is pressed: the ChatGPT plan signed in from the Icebox, or your agent on `/kaizen gather` |
+| `sources.agent` | `ask`, `chatgpt`, `agent` | Who picks the posts that fit from social sources when Gather is pressed: the ChatGPT plan signed in from the Icebox, or your agent on `/kaizen gather` |
 | `sources.model` | text | Model the ChatGPT plan gathers with; empty takes the first it lists |
 | `sources.effort` | `low`, `medium`, `high` | Reasoning effort of that model while gathering |
 | `agent.default` | `auto`, `claude`, `codex`, `agy`, `opencode`, `gemini` | Coding agent to launch from dashboard backlog |
 
+Some settings only have an effect while another stands a certain way: the approvals
+while `mode` is `approve`, `build.executor` and `subagents.*` while `runner` is `full`,
+`auto_fix.min_severity` and `auto_fix.max_iterations` while `auto_fix.enabled` is
+`true`, `sources.model` and `sources.effort` while `sources.agent` is `chatgpt`. When
+printing one of these that has no effect now, say so beside its value. Still offer it:
+a value set now applies once the other setting changes, and `/kaizen full` overrides
+the runner for one run.
+
 Rules for writing the file:
 
 - **Change the value in place.** `config.yml` ships with a comment above every key
@@ -46,7 +53,7 @@ Rules for writing the file:
 - After writing, print the setting and its new value, and nothing else. No summary of
   the whole file.
 
-Settings not in the table — the review checks, backlog and state paths, and the per-tool
+Settings not in the table — such as `state.dir` and the per-tool
 `agent.<cmd>.model` / `agent.<cmd>.effort` the board launches a session with — are edited by
 hand in `config.yml`, which is commented throughout. Say so rather than offering a
 picker with thirty options.

package/skills/kaizen/spec-build.md

@@ -86,8 +86,9 @@ the note, correct what the change made untrue or left out — never the `## Note
 section, which is the user's — and set its `updated` to today. Refresh the note's line
 in `Index.md` if its `description` changed, and append one line to `Log.md`:
 `- YYYY-MM-DD run <id> — <notes touched>`. Name the notes touched in `03-impl.md`. A
-change no note covers is not written up here: say "suggest `/kaizen docs`" in
-`03-impl.md` and leave the vault alone. No Index, nothing to do.
+change no note covers is not written up here: list it in `03-impl.md` as "no note
+covers `<path>`" — the main thread's *Docs gate* in `spec-main.md` documents it before
+the run is done. No Index, nothing to do.
 
 **Read the plan's File manifest instead of searching.** The planner already located
 every path this run touches. Search the material only for what the manifest does not

package/skills/kaizen/spec-main.md

@@ -97,13 +97,48 @@ tab from staying empty; the reviewer flagging it later is a second net, not the
 
 ---
 
+## Docs gate
+
+Before a run can be `done` — in every runner and every mode, `auto` included — bring
+the project's docs vault up to date with what the run changed. Apply it once the review
+is settled and before the final approval report, so the user approves the notes with
+the work; where the user's answer sends findings back to be fixed, apply it again over
+those fixes before setting `stage: "done"`. In a run with a `worktree`, edit the notes
+in the worktree, where the vault is committed with the code. Where
+`notes/Project/Index.md` does not exist in the state directory, there is no vault and
+nothing to do. The builder already updates the notes it can see during the build; this
+is the step that catches what it could not: fix iterations after it, and changes no
+note covers.
+
+1. **What changed:** every path named in `03-impl.md` and in each
+   `05-iterations/*-fix.md`, leaving out `.kaizen/` itself.
+2. **Covered:** for each note whose `sources` include one of those paths (a folder in
+   `sources` covers everything under it), check the note against the changed files.
+   Where the change made it untrue or left something out, correct it as *Keep the
+   project's docs vault current* in [`spec-build.md`](spec-build.md) says — never the
+   `## Notes` section — set `updated` to today, and append the `Log.md` line, unless the
+   builder already wrote this run's line, in which case add the notes to it.
+3. **Not covered:** a changed path no note's `sources` reach. Add it to the `sources`
+   of the note whose area it belongs to and describe it there; where it belongs to no
+   area, write a note for it as step 4 of *Update* in [`docs.md`](docs.md) says and
+   list it in `Index.md`. A path that is not part of the project's material — a lock
+   file, a generated bundle — needs no note.
+4. **Lint** the notes touched, as *Lint* in [`docs.md`](docs.md) lists, and fix what
+   this run broke.
+
+Name the notes touched in the final report; the commit at done includes them. A run
+whose changes leave every note true touches nothing and says so in one line.
+
+---
+
 ## Final approval
 
 Controlled by `approvals.review`, skipped in `auto`.
 
 Report: what was built (for a code run, show its Preview proof), verification results, findings fixed, findings still open,
 every criterion the reviewer answered `CANNOT VERIFY` with the check it says a human
-must make, and anything the builder noted as out of scope. Where the run used `runner: lite`, say
+must make, anything the builder noted as out of scope, and the notes the *Docs gate*
+touched. Where the run used `runner: lite`, say
 so in that report — the reviewer saw the work, and nobody should read a same-session
 review as an independent one because the output looked the same.
 Later build requests in the same session follow *Follow-ups are runs too* in [`spec.md`](spec.md): a revise of this run until it is `done`, then a new linked run.
@@ -133,10 +168,10 @@ Set `stage: "done"` in `state.json` once the user accepts.
 
 **Commit at done, when `git.auto_commit` is `true`.** Setting `stage: "done"` — the
 user approving at review, or an `auto` run finishing — is then the ask to commit, under
-either runner. Commit only the files this run changed (the paths `03-impl.md` names,
-that `git status` shows changed), by path: `git add -A -- <paths>` then
-`git commit -m <message> -- <paths>`, never the whole tree, since other sessions edit
-the same checkout. The message is `03-impl.md`'s `## Commit`. In a run with a
+either runner. Commit only the files this run changed (the paths `03-impl.md` names
+and the notes the *Docs gate* touched, that `git status` shows changed), by path:
+`git add -A -- <paths>` then `git commit -m <message> -- <paths>`, never the whole
+tree, since other sessions edit the same checkout. The message is `03-impl.md`'s `## Commit`. In a run with a
 `worktree`, commit there. Then write `runs/<id>/07-commit.md` as `commit: <short sha>`
 and `pushed: no`, so the board shows it committed and offers the push. Never push. A
 failed commit is reported as printed; the run is still `done`. With the setting

package/skills/kaizen/spec-review.md

@@ -125,7 +125,8 @@ and no criterion is `CANNOT VERIFY`; otherwise
 `; <n> cannot verify` when any criterion was — even when every count is 0, so an open
 human check never reads as a clean pass.
 
-The reviewer also appends any durable lesson about this material to `memory.md` —
+Where `review.write_memory` is true (the default), the reviewer also appends any
+durable lesson about this material to `memory.md` —
 a recurring bug pattern, a non-obvious constraint, a convention worth keeping. Not
 run-specific detail; only what the next run would want to know.
 

package/skills/kaizen-help/SKILL.md

@@ -88,15 +88,11 @@ Each iteration is written to `runs/<id>/05-iterations/`.
 | `auto_fix.enabled` | `true` | Auto-fix findings vs. escalate everything |
 | `auto_fix.min_severity` | `high` | Threshold for auto-fix (`critical\|high\|medium\|low`) |
 | `auto_fix.max_iterations` | `2` | Fix/recheck rounds before escalating remaining findings |
-| `track.default` | `auto` (inferred per run) | Pin a track for a repo that is always one kind of work |
 | `review.write_memory` | `true` | Let the reviewer append lessons to `.kaizen/memory.md` |
 | `backlog.enabled` | `true` | Capture what a run deliberately did not do |
-| `backlog.file` | `06-backlog.md` | Per-run backlog file |
-| `backlog.orphan_file` | `backlog.md` | Where a pruned run's open items are rescued to |
 | `state.dir` | `.kaizen` | State directory |
 | `state.keep_runs` | `20` | Completed runs kept before pruning oldest (rescues open backlog first) |
 | `git.auto_commit` | `false` | `true`: commit the run's changed files when it is done; never pushes |
-| `git.branch_before_implement` | `true` | Branch before implement stage when on the default branch |
 | `subagents.model` | `inherit` | Model the stage subagents run on (opus/sonnet/haiku, Claude Code only) |
 | `subagents.effort` | `inherit` | Reasoning effort for the stage subagents (low/medium/high, Claude Code only) |
 | `sources.every` | `24h` | How often the web board checks request sources for new ideas (`off\|1h\|6h\|24h`) |

package/web/board/agent-term.ts

@@ -11,7 +11,7 @@ let termKey = null,
   termOff = null,
   termLib = null;
 export const where = (r) => (r.pty ? "running in its card" : "opened in your terminal");
-const termLoad = () =>
+export const termLoad = () =>
   (termLib ||= new Promise((ok, no) => {
     const l = document.createElement("link");
     l.rel = "stylesheet";

package/web/board/api.ts

@@ -3,6 +3,7 @@ import { key, render } from "./cards.ts";
 import { $ } from "./dom.ts";
 import { close, ideaBody, open, openRun } from "./panel.ts";
 import { notifyUser, toast } from "./toast.ts";
+import { openTerms, termsShowing } from "./terms.ts";
 
 // The server writes notifier() from state.ts over a marker in board.html: one rule for both UIs.
 declare const due: (key: string, say: string | null, done: boolean, now: number) => boolean;
@@ -36,6 +37,7 @@ export async function load(quiet) {
   }
   // A redraw under a form being typed in would reset its fields and its focus.
   if (!(quiet && store.mode && $("board").querySelector(".inl input"))) render();
+  if (termsShowing()) openTerms();
   // Run on an idea closed the panel: open the card on its agent once the board knows the session.
   if (store.wantTerm && !store.openKey && !store.mode) {
     const n = store.S.cards.find((x) => key(x) === store.wantTerm && x.pty);

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);