kaizen-agent 1.43.0 → 1.43.2

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
@@ -163,7 +114,7 @@ agent:
   # auto picks Claude Code if installed, otherwise the first agent found on PATH.
   default: auto
   # on: a board decision ends the run's waiting session before continuing its
-  # conversation, and abandoned or done runs (after 2 minutes) have theirs ended.
+  # conversation, and abandoned or done runs (after 1 minute) have theirs ended.
   # Only sessions the board or dashboard launched are touched. off: nothing is
   # ended, and a resumed conversation opens beside the window still waiting.
   close: on

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
@@ -107,7 +108,9 @@ updated: YYYY-MM-DD
 2. Split it into 5–12 areas a newcomer would name — by what the parts do, not by
    folder alone. Fewer for a small project.
 3. Write one note per area in the shape above, then `Index.md`, then `Log.md` with the
-   first line.
+   first line. Every source file lands in some note's `sources` — the area's helpers,
+   small screens and scripts too, not only its main files — named directly or through a
+   folder that holds it (see *Coverage* below).
 4. Write the pointer (below).
 5. Lint, and report.
 
@@ -123,8 +126,9 @@ updated: YYYY-MM-DD
    rewrite the sections they affect — never `## Notes` — and set `updated`.
 3. Every `sources` path is gone: move the note to `Project/Archive/` and drop it from
    the Index. Never delete a note.
-4. A part of the repository no note covers (a new top-level folder, a new entry point):
-   write a note for it.
+4. A source file no note covers (see *Coverage*): add it to the `sources` of the note
+   whose area it belongs to, and mention it there; where it fits no area (a new top-level
+   folder, a new entry point), write a note for it.
 5. Refresh the Index lines whose description changed, append one Log line naming every
    note touched, refresh the pointer, lint, and report.
 
@@ -137,10 +141,20 @@ Checks, reported and not silently fixed:
 - every note has `description`, `tags`, `sources` and `updated` (the Index and Log need
   no `sources`), and is listed in the Index;
 - every `sources` path exists;
+- **uncovered**: source files no note's `sources` names or holds, listed one per line;
 - **stale**: notes whose `sources` changed after their `updated` day, found as in
   *Update* step 1;
 - `Index.md` is under 60 lines.
 
+## Coverage
+
+A **source file** is one the repository tracks (`git ls-files`; outside git, every file
+not ignored), leaving out lockfiles, generated or built output, vendored code, binaries,
+and bulk data folders. A note covers a file when its `sources` names the file or a folder
+that holds it, so a data folder such as `public/quran` is covered by naming the folder.
+Lint's *uncovered* list is what makes this checkable: a file no note covers is also a file
+whose changes *stale* never sees, so the vault falls behind without saying so.
+
 ## The pointer
 
 What makes an agent open the Index first. One block, identical everywhere:

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
@@ -156,3 +191,31 @@ When a child run reaches `done`, the board appends `Child <child id> done: <titl
 the parent's `notes.md` by itself. The parent documents it from there: if it is still in
 flight its next stage reads `notes.md`; if it is already `done`, the entry is the record.
 Never reopen a finished parent.
+
+**A roadmap's increments are filed at its approval.** When the approved plan has a
+`## Roadmap` (see *A whole application is a roadmap* in `spec-plan.md`), the same write
+that records the approval files increments 2 to N, in order, from the project folder:
+`kaizen card add "<title> (roadmap #N · after #a, #b)" --parent <run id>`, with
+`any time` in place of `after …` where it has no prerequisite and its `blocked: <reason>`
+kept in the text where it has one. Increment 1 is this run's own build. Nothing starts
+by itself: the user starts an increment from its card when they choose, and the parent's
+card lists its children with their status. An increment cut at the approval is not
+filed; it goes to the backlog like anything else cut there.
+
+## Discovery rounds
+
+A roadmap plan's Discovery and any run's REA offer reach the user through the main
+thread, under every runner: each round's questions are asked with the tool's structured
+question mechanism (AskUserQuestion in Claude Code), all of a round's questions in one
+call, each with the planner's recommended option first. Under `runner: full`, the
+planner stops after writing a round; dispatch it again with the answers, recorded in
+`02-approval.md` as that round's decisions, until it writes a plan with no round left
+to ask, then present that plan at the plan approval as usual. Answers are not an
+approval: the run stays at `stage: "plan"` with `awaiting: null` throughout, and
+`awaiting: "approvals.plan"` is set only once `01-plan.md` has a `## Roadmap` — a round
+written to that file is not a plan to approve, and a tool resuming the run re-asks its
+questions. Where the user says yes to REA before the plan exists, run the study here,
+write what it found to the run's `notes.md`, and dispatch the planner with it. Where
+REA has to be installed first, the install in *Offer REA* (`spec-plan.md`) is the main
+thread's too: doctor, the dry-run shown to the user, setup only on their approval,
+then the restart, after which the run resumes at `stage: "plan"` from `state.json`.

package/skills/kaizen/spec-plan.md

@@ -27,6 +27,39 @@ different work behind each, nothing available to break the tie — and even then
 its recommendation with the question. Questions the existing material can answer are
 never asked; that is the planner's own work.
 
+**Offer REA for what exists but is not here.** In every run and every track: when the
+request or what came with it names something that already exists but whose source is
+not at hand — an app or site to copy, replace or integrate with, an APK or IPA, a
+binary, a package, a file format, a device or its firmware, a protocol or a capture —
+and REA's tools are connected in the session, the plan asks once:
+`Q: Study <the thing> with REA first?`, with `yes` (recommended where how it works
+inside decides the design) and `no`. Under `runner: lite` or an inline planner, a yes
+given before the plan is written lets the planner run REA itself and plan from what it
+found. Under `full`, where the planner has no REA tools, the main thread runs the study
+on a yes, writes what it found to the run's `notes.md`, and dispatches the planner
+again; a yes given at the plan approval instead makes the study the build's first
+step. What REA
+returns is cited with its limitations, as *the track* in `spec.md` already requires.
+REA not connected: ask instead
+`Q: REA isn't installed — set it up first?`, with `help me install it` (recommended
+where how it works inside decides the design), `I'll install it myself` and `skip
+REA`. On *help me install it* the main thread follows REA's own setup: it runs
+`npx -y rea-agents@<version> doctor --client <client> --json` — the version pinned,
+as REA's own guide pins it, taken from `npm view rea-agents version` and shown to the
+user; the client from the run's `agent` (`claude` → `claude_code`, `codex` → `codex`,
+`agy` → `antigravity`, `opencode` → `opencode`, `gemini` → `gemini_cli`, `cursor` →
+`cursor`) — then `setup --client <client> --dry-run --json` with the same version, shows the user the exact files it
+would change, and runs `setup --client <client> --yes` only after they approve it —
+setup writes the agent's own configuration, so it is never run unseen, in any mode.
+On *I'll install it myself* it gives that same command and waits. Either way the new
+tools appear only after the agent restarts: say so, and the run resumes from its
+`state.json`, the yes to REA recorded beforehand in `02-approval.md` so the resumed
+session studies the thing rather than asking again. REA's prerequisites (Node, and
+Java, Ghidra or JADX for some targets) are named where doctor reports them missing,
+never installed by the run. On *skip REA*, or when setup fails, the plan says so
+once and claims about that thing's internals are marked unverified. Nothing of the
+kind named: REA is not mentioned.
+
 **Building from nothing is the exception: settle the foundation first.** When the
 track is a new product or app, there is no material to answer the questions that
 decide everything after them, and "wrong" for this track is a wrong foundation — the
@@ -39,6 +72,67 @@ materially different builds — put to the user as an *Open question* with optio
 all in one round, before anything is built. Three quick questions and a default for
 the rest is how a run ends up writing the second app instead of the first.
 
+**A whole application is a roadmap, not a run.** When the track is a new product or
+app — web, mobile, PWA, desktop, anything — and it covers more than one independent
+module, one run cannot hold it: the plan, the diff and the review all outgrow what a
+reader can check. A single screen or a single feature stays one run. The Framing says
+in one line that the plan is a roadmap, so the user can refuse it. A roadmap plan adds
+three sections right after the Goal, each written for a person, and the
+foundation round above becomes up to three rounds:
+
+- **`## Discovery`** — the planner goes deep before it designs. It reads everything the
+  user brought first (decks, forms, sheets, screenshots, an existing repo, REA's
+  findings), then asks only what is still open, in up to three rounds of `Q:` pick
+  lists, each question with a recommended option: (1) purpose, who uses it and in what
+  roles, what it replaces; (2) the flows of each module and their domain rules;
+  (3) the foundation choices, among them how it ships, as a multi-select — full CI/CD
+  (tests and deploy on every merge), Docker (an image and a compose file that run
+  anywhere), a managed platform (Vercel, Fly, Railway or similar), mobile app ready
+  (store builds with signing, for example Capacitor or Expo/EAS), or a simple manual
+  deploy — and, where the app has a screen and no design system exists, its look and
+  feel, asked as item 7 *Design direction* below says: the feel (for example rich and
+  animated, calm and simple, enterprise and dense, gen-z and playful) and how much
+  motion. A round with nothing left to ask is skipped. Under `runner: full` the
+  planner writes `01-plan.md` with the Framing, `## Discovery` so far and the round's
+  questions as *Open questions*, and no `## Roadmap`, then stops; that file is a
+  round, not a plan. The main thread asks them and dispatches it again with the
+  answers. Under
+  `lite` or inline, the session asks them directly. The section records the roles, the
+  main flows, the things the app keeps track of and how they relate, a glossary of
+  the domain's words, and every answer given.
+- **`## Foundation`** — a decision with its reason, derived from Discovery, for each
+  of: platform; frontend (framework, UI kit, state, the design direction chosen);
+  backend (runtime, framework, API style); the contract between them (REST, RPC or
+  realtime, and where its types live); hosting and deploy, as chosen in discovery;
+  database (engine, where it runs, the main tables or collections and their
+  relations, how migrations are done); auth and access; repo layout and conventions.
+  Every increment builds on it.
+- **`## Roadmap`** — the increments, numbered, one line each:
+  `N. <title> — <what it delivers> — after: #a, #b` (or `any time`), with
+  `— blocked: <reason>` when something outside the work holds it. Increment 1 is always
+  the skeleton: the scaffold, the stack wired, the database schema and migration setup,
+  an auth stub, and a deploy of the empty app the way the Foundation ships (in its
+  Docker image, through its pipeline, as a store test build). Every feature increment
+  after it is one feature end to end — its screens, its API, its tables and migration,
+  and its tests — so each can be tried on its own; splitting by layer ("all the APIs", then "all the screens")
+  is only for an app with no UI or no backend. Each increment is sized to one ordinary
+  run. Where real people will use the app, the last increment is going live: what
+  the deploy choice still needs (the full pipeline, the production image, store
+  listings and release builds), backups, monitoring and error tracking, and the
+  production deploy. A last line says which must go in order and which can start any
+  time.
+
+The rest of a roadmap plan — Work list, Steps, File manifest, gate — covers increment 1
+only; it is this run's build. The others become child cards at the approval (see
+*Child cards* in `spec-main.md`).
+
+**An increment run builds inside its parent's decisions.** A request with a `Parent:`
+line whose parent run's `01-plan.md` has a `## Roadmap` is an increment. Its planner
+reads that plan's Discovery, Foundation and its own Roadmap line before anything else.
+They bind it: a deviation from the Foundation is an *Open question* to the user, and a
+change to the roadmap is an *Out of scope suggestion*, never a silent edit of the
+parent's plan.
+
 The goals stay the user's. The planner may propose a better solution to what was
 asked, or argue that the request as stated will not achieve what the user wants, but
 it may not widen the goal on its own. Anything beyond the request goes in *Out of
@@ -132,7 +226,7 @@ questions that are open. An alternative rejected gets a line saying what and why
 a case against it.
 
 **Write the parts a person reads for a person.** Framing, the Work list, Goal, Scope,
-Risks and Out of scope suggestions are read by someone deciding whether to approve,
+Discovery, Foundation, Roadmap, Risks and Out of scope suggestions are read by someone deciding whether to approve,
 often on a narrow panel. Write them in everyday words: short sentences, one idea per
 bullet, things named by what the user sees ("the chat bubble", "the Plan tab") rather
 than by function, file, CSS value or gate id. Code names, `path:line` and gate ids

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

@@ -31,7 +31,7 @@ anything.
 | `/kaizen backlog` | Print open backlog items across all runs, grouped by source run, rescued items last under `Orphaned` |
 | `/kaizen gather` | Read request sources kaizen cannot read by itself; their requests land in the icebox, nothing starts |
 | `/kaizen discover` | Group what is in the icebox and promote the ideas you pick; nothing starts |
-| `/kaizen docs [lint]` | Write or refresh the project's docs vault in the notebook, which agents read first; `lint` only reports what is stale or broken |
+| `/kaizen docs [lint]` | Write or refresh the project's docs vault in the notebook, which agents read first; `lint` only reports what is stale, broken or uncovered |
 | `/kaizen approve` | Approve whatever the current run is waiting on |
 | `/kaizen reject <reason>` | Reject it; the reason decides revise (back to planner) vs kill (abandon) |
 | `/kaizen abort` | Mark the current run abandoned |
@@ -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/cards.ts

@@ -237,6 +237,7 @@ function card(c) {
     } else {
       items.push(["open", actionOf(c), ico("open")]);
       items.push(["archive", "Archive", ico("archive")]);
+      if (c.column === 1 && c.status !== "abandoned") items.push(["toidea", "Back to idea", ico("restore")]);
       if (c.status === "waiting" || c.status === "running" || c.status === "stalled") {
         items.push(null, ["reject", "Abandon", ico("x"), "danger"]);
       }
@@ -267,6 +268,12 @@ function card(c) {
           toggleArchive(c, a === "archive");
           return;
         }
+        if (a === "toidea") {
+          const r = await post("/to-idea", { dir: c.state, id: c.id });
+          if (r.ok) toast("Back in Ideas");
+          load();
+          return;
+        }
         store.mode = a;
         store.modeKey = k;
         render();
@@ -302,7 +309,7 @@ function inlineForm(c) {
   li.className = "inl";
   const dir = c.state;
   if (store.mode === "edit") {
-    li.innerHTML = html`<input value="${c.text}"><textarea placeholder="Notes: links, paths, background">${c.notes || ""}</textarea><div class="q dim" id="clong" hidden>The first line is over 72 characters; logs will cut it short.</div><div class="row"><button class="btn ghost" data-a="c">Cancel</button><button class="btn pri" data-a="s">Save</button></div>`;
+    li.innerHTML = html`<input value="${c.text}"><textarea placeholder="Anything the planner should know">${c.notes || ""}</textarea><div class="q dim" id="clong" hidden>The first line is over 72 characters; logs will cut it short.</div><div class="row"><button class="btn ghost" data-a="c">Cancel</button><button class="btn pri" data-a="s">Save</button></div>`;
     li.querySelector("[data-a=s]").onclick = async () => {
       const next = li.querySelector("input").value.trim(),
         notes = li.querySelector("textarea").value.trim();
@@ -314,7 +321,7 @@ function inlineForm(c) {
   }
   if (store.mode === "reject") {
     const idea = c.kind !== "run";
-    li.innerHTML = html`<div class="q">${c.kind === "backlog" ? "Not doing this backlog item?" : idea ? "Reject this idea?" : "Abandon this run?"} The reason is recorded.</div><input placeholder="Reason"><div class="row"><button class="btn ghost" data-a="c">Keep it</button><button class="btn warn" data-a="s">${idea ? "Reject" : "Abandon"}</button></div>`;
+    li.innerHTML = html`<div class="q">${c.kind === "backlog" ? "Not doing this backlog item?" : idea ? "Reject this idea?" : "Abandon this run?"} The reason is recorded.</div><input placeholder="Why not?"><div class="row"><button class="btn ghost" data-a="c">Keep it</button><button class="btn warn" data-a="s">${idea ? "Reject" : "Abandon"}</button></div>`;
     li.querySelector("[data-a=s]").onclick = async () => {
       const why = li.querySelector("input").value.trim();
       if (!why) {
@@ -450,7 +457,7 @@ async function startRun(c, kind) {
   const backlog = c.kind === "backlog" ? { source: c.source, n: c.n } : undefined;
   const r = await post("/run", { dir: c.state, text: c.text, backlog, kind, agent: p ? p.agent : undefined, yolo });
   if (r.ok) {
-    toast((kind === "full" ? "Full" : "Lite") + (yolo ? " yolo" : "") + " run " + where(r) + ": " + via(r.agent));
+    toast((kind === "full" ? "Full" : kind === "lite" ? "Lite" : "Started") + (yolo ? " yolo" : "") + " run " + where(r) + ": " + via(r.agent));
     // A backlog card has no terminal of its own; the run's card gets it once the run exists.
     if (r.pty && !backlog) store.wantTerm = key(c);
   }
@@ -461,12 +468,13 @@ const HINT = { 1: "Ideas you run are planned here", 2: "Approved plans are built
 
 // The new-idea form, wired into f: inline at the top of Ideas, or in a modal.
 function ideaForm(f, close) {
-  f.innerHTML = html`${store.all ? html`<div class="combo" id="ndc"><button type="button" class="sel" id="newdir" aria-label="Project for this idea" aria-haspopup="listbox" aria-expanded="false"></button><div class="menu-pop" hidden><input class="sel" aria-label="Search projects" placeholder="Search projects…" spellcheck="false" autocomplete="off"><div id="nds" role="listbox"></div></div></div>` : ""}<input id="newidea" placeholder="What would you like done?"><textarea id="newnotes" placeholder="Notes: links, paths, background (optional)"></textarea><div class="att" id="newatt"></div><input type="file" id="newfile" multiple hidden><div class="row"><button type="button" class="ib" id="newpick" aria-label="Attach files" title="Attach files">${ico("clip")}</button><button type="button" class="btn ghost" id="nc">Cancel</button><button type="button" class="btn pri" id="ns">Add</button></div>`;
+  f.innerHTML = html`${store.all ? html`<div class="combo" id="ndc"><button type="button" class="sel" id="newdir" aria-label="Project for this idea" aria-haspopup="listbox" aria-expanded="false"></button><div class="menu-pop" hidden><input class="sel" aria-label="Search projects" placeholder="Search projects…" spellcheck="false" autocomplete="off"><div id="nds" role="listbox"></div></div></div>` : ""}<input id="newidea" placeholder="What do you want to build?"><textarea id="newnotes" placeholder="Anything the planner should know (optional)"></textarea><div class="att" id="newatt"></div><input type="file" id="newfile" multiple hidden><div class="row"><button type="button" class="ib" id="newpick" aria-label="Attach files" title="Attach files">${ico("clip")}</button><button type="button" class="btn ghost" id="nc">Cancel</button><div class="split"><button type="button" class="btn pri" id="ns">Add</button><button type="button" class="btn pri" id="nm" aria-label="More ways to add" aria-haspopup="menu" aria-expanded="false">${ico("chev")}</button><div class="menu-pop" role="menu" hidden><button type="button" role="menuitem" id="nr" title="Add the idea and run it now">${ico("play")}Start run</button></div></div></div>`;
   const inp = f.querySelector("#newidea"),
     files = [];
   draft(inp, "f:new:0");
   draft(f.querySelector("textarea"), "f:new:1");
-  const save = async () => {
+  // run: add the idea, then launch it at once with the project's runner and agent.
+  const save = async (run) => {
     const text = inp.value.trim();
     if (!text) return;
     const notes = f.querySelector("textarea").value.trim();
@@ -481,6 +489,11 @@ function ideaForm(f, close) {
         const n = await post("/note", { dir, for: text, text: "", files: enc });
         if (!n.ok) toast("Idea added, files not attached");
       }
+      if (run) {
+        await load();
+        const c = store.S.cards.find((x) => x.kind === "idea" && x.text === text && (!dir || x.state === dir));
+        if (c) return startRun(c);
+      }
     }
     load();
   };
@@ -503,7 +516,37 @@ function ideaForm(f, close) {
         }
     };
   if (store.all) ideaCombo(f);
-  f.querySelector("#ns").onclick = save;
+  f.querySelector("#ns").onclick = () => save(false);
+  f.querySelector("#nr").onclick = () => save(true);
+  {
+    const mb = f.querySelector("#nm"),
+      menu = f.querySelector(".split .menu-pop");
+    // Focus moves into the menu only when it was opened from the keyboard.
+    const show = (on, kbd) => {
+      menu.hidden = !on;
+      mb.setAttribute("aria-expanded", String(on));
+      if (on && kbd) setTimeout(() => menu.querySelector("button").focus());
+    };
+    mb.onclick = (e) => {
+      e.stopPropagation();
+      show(menu.hidden, e.detail === 0);
+    };
+    menu.onkeydown = (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        e.stopPropagation();
+        show(false);
+        mb.focus();
+      }
+    };
+    f.addEventListener("click", (e) => {
+      if (!menu.hidden && !e.target.closest(".split")) show(false);
+    });
+    const sp = f.querySelector(".split");
+    sp.addEventListener("focusout", (e) => {
+      if (!sp.contains(e.relatedTarget)) show(false);
+    });
+  }
   f.querySelector("#nc").onclick = close;
   {
     const m = mic([inp, f.querySelector("textarea")]);
@@ -512,7 +555,7 @@ function ideaForm(f, close) {
   inp.onkeydown = (e) => {
     if (e.key === "Enter") {
       e.preventDefault();
-      save();
+      save(false);
     }
     if (e.key === "Escape") {
       e.preventDefault();

package/web/board/git.ts

@@ -31,7 +31,7 @@ export function gitBtn(c) {
 export function confirmCommit(c, msg) {
   const g = store.runDoc.git,
     foot = $("pfoot");
-  foot.innerHTML = html`<div class="inl" style="flex:1"><div class="q">Commit ${g.files.length} changed file${g.files.length === 1 ? "" : "s"} on ${g.branch || "this branch"} and push to ${g.remote}?</div><div class="q dim">Only the files this run's report names.${g.others ? ` ${g.others} other changed file${g.others === 1 ? " is" : "s are"} left alone.` : ""}</div><pre class="files">${g.files.join("\n")}</pre>${g.shared && g.shared.length ? html`<div class="q">These files also hold other runs' changes, and a file is committed whole:</div><pre class="files">${g.shared.join("\n")}</pre>` : ""}<textarea aria-label="Commit message" placeholder="feat(scope): what changed">${msg || commitMsg(store.runDoc.impl) || c.title || c.text}</textarea><div class="q dim" id="clong" hidden>The first line is over 72 characters; logs will cut it short.</div><div class="row"><button class="btn ghost" data-a="c">Cancel</button><button class="btn pri" data-a="s">Commit &amp; push</button></div></div>`;
+  foot.innerHTML = html`<div class="inl" style="flex:1"><div class="q">Commit ${g.files.length} changed file${g.files.length === 1 ? "" : "s"} on ${g.branch || "this branch"} and push to ${g.remote}?</div><div class="q dim">Only the files this run's report names.${g.others ? ` ${g.others} other changed file${g.others === 1 ? " is" : "s are"} left alone.` : ""}</div><pre class="files">${g.files.join("\n")}</pre>${g.shared && g.shared.length ? html`<div class="q">These files also hold other runs' changes, and a file is committed whole:</div><pre class="files">${g.shared.join("\n")}</pre>` : ""}<textarea aria-label="Commit message" placeholder="Describe what changed">${msg || commitMsg(store.runDoc.impl) || c.title || c.text}</textarea><div class="q dim" id="clong" hidden>The first line is over 72 characters; logs will cut it short.</div><div class="row"><button class="btn ghost" data-a="c">Cancel</button><button class="btn pri" data-a="s">Commit &amp; push</button></div></div>`;
   const inp = foot.querySelector("textarea"),
     go = foot.querySelector("[data-a=s]");
   inp.focus();

package/web/board/icebox.ts

@@ -975,7 +975,7 @@ export async function openSources() {
       if (!dir && !showable().length) return toast("Pick a project first");
       // The new-idea form, cut down: the request, files, dictation and, in All projects, the project.
       const dl = modal(
-        `${all ? `<div class="combo" id="ndc"><button type="button" class="sel" id="newdir" aria-label="Project for this request" aria-haspopup="listbox" aria-expanded="false"></button><div class="menu-pop" hidden><input class="sel" aria-label="Search projects" placeholder="Search projects…" spellcheck="false" autocomplete="off"><div id="nds" role="listbox"></div></div></div>` : ""}<textarea id="newidea" placeholder="New request for the icebox" aria-label="Request"></textarea><div class="att"></div><input type="file" multiple hidden><div class="row"><button type="button" class="ib" id="newpick" aria-label="Attach files" title="Attach files">${ico("clip")}</button><button type="button" class="btn ghost" value="">Cancel</button><button class="btn pri">Add</button></div>`,
+        `${all ? `<div class="combo" id="ndc"><button type="button" class="sel" id="newdir" aria-label="Project for this request" aria-haspopup="listbox" aria-expanded="false"></button><div class="menu-pop" hidden><input class="sel" aria-label="Search projects" placeholder="Search projects…" spellcheck="false" autocomplete="off"><div id="nds" role="listbox"></div></div></div>` : ""}<textarea id="newidea" placeholder="What did someone ask for?" aria-label="Request"></textarea><div class="att"></div><input type="file" multiple hidden><div class="row"><button type="button" class="ib" id="newpick" aria-label="Attach files" title="Attach files">${ico("clip")}</button><button type="button" class="btn ghost" value="">Cancel</button><button class="btn pri">Add</button></div>`,
       );
       const f = dl.querySelector("form"),
         inp = f.querySelector("textarea"),