kaizen-agent 1.43.0 → 1.43.1

package/agents/kaizen-reviewer.md

@@ -142,7 +142,7 @@ open human check never reads as a clean pass.
 
 ## Memory
 
-When memory writing is enabled, append to `.kaizen/memory.md` any durable lesson
+When `review.write_memory` is true (the default), append to `.kaizen/memory.md` any durable lesson
 about this codebase: a recurring bug pattern, a non-obvious constraint, a convention
 worth preserving. One line each. Nothing run-specific, nothing already obvious from
 reading the code.

package/cli/board.test.ts

@@ -186,10 +186,11 @@ test("card menu items: appropriate actions and distinct icons across phases", ()
   // Phase 1: Planning (run waiting for plan approval)
   const planWaiting = { kind: "run", status: "waiting", awaiting: "approvals.plan", column: 1 };
   const planItems = getItems(planWaiting, false);
-  expect(planItems.map((i: any) => i ? i[1] : null)).toEqual(["Review plan", "Archive", null, "Abandon"]);
+  expect(planItems.map((i: any) => i ? i[1] : null)).toEqual(["Review plan", "Archive", "Back to idea", null, "Abandon"]);
   expect(planItems[0][2]).toBe(ico("open"));
   expect(planItems[1][2]).toBe(ico("archive"));
-  expect(planItems[3][2]).toBe(ico("x"));
+  expect(planItems[2][2]).toBe(ico("restore"));
+  expect(planItems[4][2]).toBe(ico("x"));
 
   // Phase 2: Building (running run)
   const buildingRun = { kind: "run", status: "running", column: 2 };

package/cli/browser.test.ts

@@ -18,7 +18,7 @@ const run = async (code: string, env: Record<string, string> = {}) => {
   const script = `import * as br from ${JSON.stringify(join(repo, "cli/browser.ts"))};
 Object.assign(process.env, ${JSON.stringify({ HOME: process.env.HOME ?? "", USERPROFILE: process.env.USERPROFILE ?? "" })});
 console.log(JSON.stringify(await (async () => { ${code} })()));`;
-  const p = Bun.spawn(["bun", "-e", script], { cwd: home, env: { ...process.env, HOME: home, USERPROFILE: home, ...env }, stdout: "pipe", stderr: "pipe" });
+  const p = Bun.spawn(["bun", "-e", script], { cwd: home, env: { ...process.env, HOME: home, USERPROFILE: home, KAIZEN_BROWSER_PACE: "0.1", ...env }, stdout: "pipe", stderr: "pipe" });
   const [out, err, code_] = [await new Response(p.stdout).text(), await new Response(p.stderr).text(), await p.exited];
   if (code_ !== 0) throw new Error(err);
   return JSON.parse(out.trim().split("\n").at(-1)!);

package/cli/browser.ts

@@ -30,6 +30,8 @@ export const POST: Record<string, RegExp> = {
 };
 // Grids show thumbnails, not text: each post page is opened for its caption.
 const GRID = new Set(["instagram"]);
+// The fixed waits below are sized for real platforms; KAIZEN_BROWSER_PACE scales them (the tests run at 0.1).
+const nap = (ms: number) => Bun.sleep(ms * (Number(process.env.KAIZEN_BROWSER_PACE) || 1));
 
 // KAIZEN_BROWSER, else the usual names on PATH, else the usual install paths.
 export function findBrowser(): string | null {
@@ -97,9 +99,9 @@ export class Page {
   async go(url: string) {
     await this.call("Page.navigate", { url });
     const end = Date.now() + 20_000;
-    await Bun.sleep(1500);
-    while (Date.now() < end && (await this.js("document.readyState")) !== "complete") await Bun.sleep(250);
-    await Bun.sleep(2000);   // the posts arrive after the page itself
+    await nap(1500);
+    while (Date.now() < end && (await this.js("document.readyState")) !== "complete") await nap(250);
+    await nap(2000);   // the posts arrive after the page itself
   }
   close() { try { this.ws.close(); } catch { /* already gone */ } }
 }
@@ -200,7 +202,10 @@ export async function browse<T>(use: (page: Page) => Promise<T>): Promise<T | {
   } finally {
     page?.close();
     proc.kill();
-    await Promise.race([proc.exited, Bun.sleep(5000)]);
+    // A cleared timer, not Bun.sleep: a pending sleep keeps the process alive 5 s after Chrome is gone.
+    let t: Timer | undefined;
+    await Promise.race([proc.exited, new Promise((r) => { t = setTimeout(r, 5000); })]);
+    clearTimeout(t);
     if (proc.exitCode === null) proc.kill(9);
   }
 }
@@ -230,7 +235,7 @@ export async function readPage(page: Page, url: string, platform: string, max =
     // A page that renders its posts late is not empty: stop early only once some arrived.
     still = seen.size && seen.size === before ? still + 1 : 0;
     await page.js("window.scrollBy(0, window.innerHeight * 1.5)");
-    await Bun.sleep(1500);
+    await nap(1500);
   }
   let found = [...seen.values()].slice(0, max);
   if (GRID.has(platform)) {
@@ -310,12 +315,12 @@ export async function replyOn(page: Page, link: string, platform: string, text:
   if (!(await page.js<boolean>(FIND(how.box, "focus"))))
     return { ok: false, note: (await page.js<boolean>(OFFERS)) ? signInNote(platform) : `Could not find the reply box on ${name}. Nothing was posted.` };
   await page.call("Input.insertText", { text });
-  await Bun.sleep(800);
+  await nap(800);
   if (!(await here())) return { ok: false, note: `The page left ${name}. Nothing was posted.` };
   if (!(await page.js<boolean>(FIND(how.send, "click")))) return { ok: false, note: `Could not find ${name}'s send button. Nothing was posted.` };
   // Sent once the box is gone or emptied; still holding the text means it did not go.
   for (let i = 0; i < 20; i++) {
-    await Bun.sleep(500);
+    await nap(500);
     const left = await page.js<string | null>(BOX);
     if (left === null || !left.trim()) return { ok: true };
   }

package/cli/pty.ts

@@ -81,7 +81,8 @@ export function startPty(key: string, cmd: string[], cwd: string, pidFile?: stri
     for (const f of p.listeners) f(null);
     p.listeners.clear();
     try { p.proc.terminal?.close(); } catch { /* already closed */ }
-    setTimeout(() => { if (ptys.get(key) === p) ptys.delete(key); }, KEEP_MS).unref();
+    // Dropped: pages showing it (the Terminal page) refresh, or its tile lingers until some other change.
+    setTimeout(() => { if (ptys.get(key) === p) { ptys.delete(key); onChange?.(); } }, KEEP_MS).unref();
     onChange?.();
   });
   return p.proc.pid;

package/cli/settings.test.ts

@@ -6,6 +6,7 @@ import { test, expect, beforeAll, afterAll } from "bun:test";
 import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, copyFileSync, rmSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
+import { applyPreset, detectPreset } from "./settings.ts";
 
 const repo = join(dirname(import.meta.path), "..");
 const defaults = join(repo, "skills/kaizen/config.default.yml");
@@ -48,3 +49,40 @@ test("board settings save to the global config, project settings to the project"
   expect(inProject(`return setSetting(repo, "git.auto_commit", "true")`)).toEqual({ ok: true });
   expect(readFileSync(join(project, ".kaizen", "config.yml"), "utf8")).toMatch(/auto_commit: true/);
 });
+
+test("every row is a key in config.default.yml, and every `when` names a row and one of its values", () => {
+  const rows = inProject(`return listSettings(repo).rows`);
+  const text = readFileSync(defaults, "utf8");
+  for (const r of rows) {
+    const [top, leaf] = r.key.split(".");
+    const block = leaf ? new RegExp(`^${top}:\\n(?:(?:  .*|\\s*)\\n)*?  ${leaf}:`, "m") : new RegExp(`^${top}:`, "m");
+    expect(block.test(text) ? r.key : `${r.key} missing`).toBe(r.key);
+    if (!r.when) continue;
+    const dep = rows.find((x) => x.key === r.when[0]);
+    expect(dep?.values).toContain(r.when[1]);
+  }
+});
+
+test("a row dims while the setting it depends on has it switched off, and a leftover dead key changes nothing", () => {
+  const conf = join(project, ".kaizen", "config.yml");
+  // The low preset as an older config holds it, with keys kaizen no longer reads.
+  writeFileSync(conf, readFileSync(defaults, "utf8")
+    .replace("enabled: true\n  # critical", "enabled: false\n  # critical")
+    .replace("git:\n", "git:\n  branch_before_implement: false\n")
+    + "\ntrack:\n  default: software\n");
+  const idle = (k: string) => inProject(`return listSettings(repo).rows.find((r) => r.key === ${JSON.stringify(k)}).idle`);
+  expect(idle("auto_fix.min_severity")).toBe("No effect unless Fix findings automatically is on");
+  expect(idle("auto_fix.enabled")).toBe("");
+  expect(inProject(`return setSetting(repo, "auto_fix.max_iterations", "3")`)).toEqual({ ok: true });
+  expect(inProject(`return setSetting(repo, "auto_fix.enabled", "true")`)).toEqual({ ok: true });
+  expect(idle("auto_fix.min_severity")).toBe("");
+  expect(inProject(`return value("auto_fix.max_iterations")`)).toBe("3");
+  copyFileSync(defaults, conf);
+});
+
+test("a config still holding git.branch_before_implement keeps its preset", () => {
+  const text = readFileSync(defaults, "utf8");
+  const low = applyPreset(text, "low", text).replace("git:\n", "git:\n  branch_before_implement: true\n");
+  expect(detectPreset(low, text)).toBe("low");
+  expect(detectPreset(text, text)).toBe("medium");
+});

package/cli/settings.ts

@@ -6,7 +6,10 @@ import { homedir } from "node:os";
 import { readText } from "./state.ts";
 
 // `text` is a value typed rather than chosen: a path. It has no values to cycle.
-type Setting = { key: string; label: string; group: string; values: string[]; help: string; text?: boolean; folder?: boolean };
+// `when`: the row only has an effect while that other key holds that value; both
+// settings screens dim it otherwise, and it stays editable (`/kaizen full` overrides
+// the runner for one run, so a subagent model still matters under `runner: lite`).
+type Setting = { key: string; label: string; group: string; values: string[]; help: string; text?: boolean; folder?: boolean; when?: [string, string] };
 
 export type PresetName = "low" | "medium" | "ultra";
 
@@ -29,7 +32,6 @@ export const PRESETS: Record<PresetName, {
       "auto_fix.min_severity": "high",
       "auto_fix.max_iterations": "1",
       "git.auto_commit": "false",
-      "git.branch_before_implement": "false",
       "git.worktree_per_run": "false",
     },
   },
@@ -47,7 +49,6 @@ export const PRESETS: Record<PresetName, {
       "auto_fix.min_severity": "high",
       "auto_fix.max_iterations": "2",
       "git.auto_commit": "false",
-      "git.branch_before_implement": "true",
       "git.worktree_per_run": "true",
     },
   },
@@ -65,7 +66,6 @@ export const PRESETS: Record<PresetName, {
       "auto_fix.min_severity": "low",
       "auto_fix.max_iterations": "4",
       "git.auto_commit": "true",
-      "git.branch_before_implement": "true",
       "git.worktree_per_run": "true",
     },
   },
@@ -99,31 +99,29 @@ export function applyPreset(text: string, preset: PresetName, defaults: string):
 
 const SETTINGS: Setting[] = [
   { key: "preset", label: "Preset", group: "Preset", values: ["low", "medium", "ultra", "custom"], help: "" },
-  { key: "mode", label: "Stop for approval", group: "Approvals", values: ["approve", "auto", "plan-only", "review-only"], help: "" },
-  { key: "approvals.plan", label: "Approve the plan first", group: "Approvals", values: ["true", "false"], help: "" },
-  { key: "approvals.review", label: "Approve after review", group: "Approvals", values: ["true", "false"], help: "" },
-  { key: "approvals.each_file", label: "Confirm every file edit", group: "Approvals", values: ["true", "false"], help: "" },
+  { key: "mode", label: "Run mode", group: "Approvals", values: ["approve", "auto", "plan-only", "review-only"], help: "" },
+  { key: "approvals.plan", label: "Approve the plan first", group: "Approvals", values: ["true", "false"], help: "", when: ["mode", "approve"] },
+  { key: "approvals.review", label: "Approve after review", group: "Approvals", values: ["true", "false"], help: "", when: ["mode", "approve"] },
+  { key: "approvals.each_file", label: "Confirm every file edit", group: "Approvals", values: ["true", "false"], help: "", when: ["mode", "approve"] },
   { key: "runner", label: "Stage isolation", group: "Agents", values: ["full", "lite"], help: "full: separate agent per stage. lite: one session" },
-  { key: "build.executor", label: "Who builds", group: "Agents", values: ["subagent", "inline", "ask"], help: "" },
+  { key: "build.executor", label: "Who builds", group: "Agents", values: ["subagent", "inline", "ask"], help: "subagent: its own agent · inline: this session · ask: pick at plan approval", when: ["runner", "full"] },
   { key: "agent.default", label: "Tool the board launches", group: "Agents", values: ["auto", "claude", "codex", "agy", "opencode", "gemini"], help: "" },
   { key: "agent.launch", label: "Where the board runs agents", group: "Agents", values: ["card", "terminal"], help: "" },
-  { key: "subagents.model", label: "Model for stage agents", group: "Agents", values: ["inherit", "opus", "sonnet", "haiku"], help: "" },
-  { key: "subagents.effort", label: "Effort for stage agents", group: "Agents", values: ["inherit", "low", "medium", "high"], help: "" },
+  { key: "subagents.model", label: "Model for subagents", group: "Agents", values: ["inherit", "opus", "sonnet", "haiku"], help: "Planner, builder, reviewer", when: ["runner", "full"] },
+  { key: "subagents.effort", label: "Effort for subagents", group: "Agents", values: ["inherit", "low", "medium", "high"], help: "Planner, builder, reviewer", when: ["runner", "full"] },
   { key: "auto_fix.enabled", label: "Fix findings automatically", group: "Auto-fix", values: ["true", "false"], help: "" },
-  { key: "auto_fix.min_severity", label: "Auto-fix from severity", group: "Auto-fix", values: ["critical", "high", "medium", "low"], help: "" },
-  { key: "auto_fix.max_iterations", label: "Max fix rounds", group: "Auto-fix", values: ["1", "2", "3", "4", "5"], help: "" },
+  { key: "auto_fix.min_severity", label: "Lowest severity to fix", group: "Auto-fix", values: ["critical", "high", "medium", "low"], help: "", when: ["auto_fix.enabled", "true"] },
+  { key: "auto_fix.max_iterations", label: "Max fix rounds", group: "Auto-fix", values: ["1", "2", "3", "4", "5"], help: "", when: ["auto_fix.enabled", "true"] },
   { key: "git.auto_commit", label: "Commit when done", group: "Git", values: ["false", "true"], help: "Never pushes" },
-  { key: "git.branch_before_implement", label: "Branch before building", group: "Git", values: ["true", "false"], help: "" },
   { key: "git.worktree_per_run", label: "Branch and folder per run", group: "Git", values: ["true", "false"], help: "" },
-  { key: "track.default", label: "Kind of work", group: "Project", values: ["auto", "software", "writing", "communication", "operations", "research"], help: "" },
   { key: "review.write_memory", label: "Remember lessons", group: "Project", values: ["true", "false"], help: "" },
   { key: "review.memory_max_lines", label: "Memory size cap", group: "Project", values: ["50", "100", "200", "400"], help: "" },
   { key: "state.keep_runs", label: "Runs to keep", group: "Project", values: ["5", "10", "20", "50"], help: "" },
   { key: "dictation.model", label: "Dictation model", group: "Board", values: ["tiny", "base", "small", "large-v3-turbo"], help: "" },
   { key: "sources.every", label: "Gather requests", group: "Board", values: ["off", "1h", "6h", "24h"], help: "" },
-  { key: "sources.agent", label: "Who reads social sources", group: "Board", values: ["ask", "chatgpt", "agent"], help: "" },
-  { key: "sources.model", label: "ChatGPT model for gathering", group: "Board", values: [], text: true, help: "Empty: plan default" },
-  { key: "sources.effort", label: "ChatGPT effort for gathering", group: "Board", values: ["low", "medium", "high"], help: "" },
+  { key: "sources.agent", label: "Who picks social posts", group: "Board", values: ["ask", "chatgpt", "agent"], help: "X, TikTok, Instagram, Threads" },
+  { key: "sources.model", label: "ChatGPT model for gathering", group: "Board", values: [], text: true, help: "Empty: plan default", when: ["sources.agent", "chatgpt"] },
+  { key: "sources.effort", label: "ChatGPT effort for gathering", group: "Board", values: ["low", "medium", "high"], help: "", when: ["sources.agent", "chatgpt"] },
   { key: "board.projects_dir", label: "Projects folder", group: "Board", values: [], text: true, folder: true, help: "Empty: known projects only" },
   { key: "board.open", label: "Open the board in", group: "Board", values: ["browser", "app"], help: "" },
   { key: "ui.mouse", label: "Enable mouse", group: "Terminal", values: ["false", "true"], help: "" },
@@ -137,13 +135,18 @@ export function listSettings(repoRoot: string) {
   const load = (f: string) => existsSync(f) ? readText(f) : "";
   const text = load(file), board = load(globalFile());
   const preset = detectPreset(text, defaults);
-  return {
-    file: tilde(file),
-    rows: SETTINGS.map((s) => ({
-      ...s,
-      value: s.key === "preset" ? preset : (read(s.group === "Board" ? board : text, s.key) || read(defaults, s.key)) ?? s.values[0] ?? "",
-    })),
-  };
+  const rows = SETTINGS.map((s) => ({
+    ...s,
+    value: s.key === "preset" ? preset : (read(s.group === "Board" ? board : text, s.key) || read(defaults, s.key)) ?? s.values[0] ?? "",
+  }));
+  const valueOf = (k: string) => rows.find((r) => r.key === k)?.value ?? null;
+  return { file: tilde(file), rows: rows.map((r) => ({ ...r, idle: idle(r, valueOf) })) };
+}
+
+// Why a row has no effect right now, or "" while it has one: its `when` is not met.
+function idle(s: Setting, valueOf: (key: string) => string | null) {
+  if (!s.when || valueOf(s.when[0]) === s.when[1]) return "";
+  return `No effect unless ${SETTINGS.find((x) => x.key === s.when![0])!.label} is ${s.when[1] === "true" ? "on" : s.when[1]}`;
 }
 
 export function setSetting(repoRoot: string, key: string, value: string) {
@@ -217,13 +220,17 @@ export async function settings(repoRoot: string, standalone = true) {
       }
       return v;
     };
+    const valueOf = (k: string) => {
+      const d = SETTINGS.find((x) => x.key === k)!;
+      return read(fileFor(d) === file ? text : readText(fileFor(d)), k) || read(defaults, k);
+    };
     const rows = SETTINGS.map((s) => ({
       s,
-      // Older configs spell "infer the track" as an empty string; show what it means.
+      idle: idle(s, valueOf),
       // The preset as a game's quick preset: arrows either side, the tier lit after it. No colour codes: the selected row wraps this in inverse, which a reset would end.
       value: s.key === "preset"
         ? `◁ ${currentPreset.padEnd(6)} ▷ ${(["low", "medium", "ultra"] as const).map((p) => p === currentPreset ? "━" : "─").join("")}`
-        : show(s, (read(fileFor(s) === file ? text : readText(fileFor(s)), s.key) || (s.key === "track.default" ? "auto" : undefined)) ?? c.dim("(default)")),
+        : show(s, read(fileFor(s) === file ? text : readText(fileFor(s)), s.key) ?? c.dim("(default)")),
     }));
     const width = Math.max(...SETTINGS.map((s) => s.label.length)) + 4;
 
@@ -234,7 +241,7 @@ export async function settings(repoRoot: string, standalone = true) {
     rowAt = [];
     let line = 2, group = "";
     const list = shown();
-    for (const [i, { s, value }] of rows.entries()) {
+    for (const [i, { s, value, idle: off }] of rows.entries()) {
       if (!list.includes(i)) continue;
       if (s.group !== group) {
         group = s.group;
@@ -245,14 +252,14 @@ export async function settings(repoRoot: string, standalone = true) {
       const name = s.label.padEnd(width);
       stdout.write(on
         ? `  ${c.cyan("›")} ${c.bold(name)}${c.inv(` ${value} `)}\n`
-        : `    ${c.dim(name)}${value}\n`);
+        : `    ${c.dim(name)}${off ? c.dim(value) : value}\n`);
       rowAt[line++] = i;
     }
     const cur = SETTINGS[active]!;
     if (!list.length) stdout.write(`\n  ${c.dim(`no setting matches "${query}"`)}\n\n`);
     else {
       stdout.write(`\n  ${c.dim(cur.key)}  ${c.dim("options:")} ${cur.values.map((v) => v || '""').join(c.dim(" / "))}\n`);
-      stdout.write(`  ${cur.help}\n`);
+      stdout.write(`  ${[cur.help, rows[active]!.idle].filter(Boolean).join(" · ")}\n`);
     }
     stdout.write(`\n  ${c.dim(typing
       ? "type to filter · enter or ↑↓ keep it · esc clear"

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,
@@ -176,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/);
 });

package/cli/state.ts

@@ -1015,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);

package/cli/web.ts

@@ -4,7 +4,7 @@ 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, backlogCards, backlogItem, startedBacklog, closeBacklog, markBacklogDone, fixPrompt, approvalPrompt, canApproveAwaiting, nativePath, closeSessions, sweepSessions, issueUrl,
   launchMode, readSessions, ownerOf, runIndex, resumePrompt, runAgent, firstSession, webHosts,
@@ -1140,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.43.0",
+  "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