@dougharness/cli 1.4.0 → 1.5.0

package/node_modules/@dougharness/flow/scripts/plan.mjs

@@ -179,18 +179,18 @@ function cachingProvider(provider) {
 async function attachLessons(plan, dir, provider) {
   if (!existsSync(join(dir, MEMORY_DB_RELPATH))) return plan;
   try {
-    const { openMemory, recallLessons, degradedWarning, degradedReason, renderLessons } = await import("../lib/memory.mjs");
+    const { openMemory, LIVE_LESSON_SQL, recallLessons, degradedWarning, degradedReason, renderFlowLessons } = await import("../lib/memory.mjs");
     const staleDays = readMemoryStaleDays(dir);
     const m = openMemory(dir);
     try {
       const detectedProvider = await detectOnce(provider);
       // An empty lesson store has nothing to degrade (a code-index-only database, say): no warning for it.
-      const hasLessons = m.prepare("SELECT 1 FROM lessons WHERE superseded_by IS NULL AND stale IS NULL LIMIT 1").get() !== undefined;
+      const hasLessons = m.prepare(`SELECT 1 FROM lessons WHERE ${LIVE_LESSON_SQL} LIMIT 1`).get() !== undefined;
       const tasks = [];
       for (const task of plan.tasks) {
         const taskRecall = await recallLessons(m, `${task.title}\n${task.spec}`, { files: task.files, k: 8, checkoutDir: dir, provider, staleDays, detectedProvider });
         if (hasLessons) warnOnce(degradedWarning(taskRecall, { what: "memory recall", detectedProvider }));
-        const taskLessons = renderLessons(taskRecall.lessons);
+        const taskLessons = renderFlowLessons(taskRecall.lessons);
         const lessonsText = taskLessons.text !== null && taskRecall.degraded ? `(recall was keyword-only: ${degradedReason(taskRecall, detectedProvider)})\n${taskLessons.text}` : taskLessons.text;
         tasks.push(taskLessons.text === null ? task : { ...task, lessons: lessonsText, lessonIds: taskLessons.ids });
       }

package/node_modules/@dougharness/flow/skills/doug-hand/SKILL.md

@@ -40,6 +40,8 @@ Batch: one `AskUserQuestion` names every remaining card of the batch (id, title,
 
 A size L card with no `docs/specs/<card-id>/spec.md` is offered feature mode first (ADR 0012): after Start and before 2b, ask with `AskUserQuestion` whether to run `/doug-start <id>` (specification, optional pseudocode, architecture, refinement) or build now; `/doug-start <id>` ends this loop and the card stays In flow. S and M cards go straight on, and any card can still run `/doug-start <id>` on request. Under autopilot the offer is not asked and the card goes straight on.
 
+Batch: ask the offer for each such card before 2b; a card answered `/doug-start <id>` is dropped from the batch and stays In flow for `/doug-start <id>`, and the rest of the batch goes on (one card left is a plain single-card run; none left ends this loop).
+
 ## 2b. Shape: by hand, or a swarm
 
 Size S, or a card with no size at all: by hand, no question.
@@ -50,7 +52,7 @@ Batch: a batch runs only as a swarm, so for two or more cards this step does not
 
 Recommend a swarm only when the goal asks for two or more independent deliverables: separate pieces of work, each with its own test file, where none uses a function, type, or file another one adds (the 2026-09-19 split probe's four report commands, docs/live-runs.md); otherwise recommend by hand. Say in the question, in one clause, which side of this rule the card is on. The recommendation is the lead's reading of the goal, not a default.
 
-Otherwise, for one card, ask with `AskUserQuestion`: run it as a swarm, or by hand. Swarm: spawn the planner the way `doug-plan` does, on the `plan` row: read it with the `plan.mjs models` command, `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" models` (`roles.plan.model`, `roles.plan.effort`), and pass that row's model (omit `model` when the row says `inherit`), but tell it this plan runs as a swarm the way `/doug-swarm` does: `Agent({ subagent_type: "doug-flow:planner", model: "<the plan row's model>", prompt: "Board card <id>, title \"<title>\": <goal>. This plan runs as a swarm: set \"swarm\": true in the plan file, and size every task M or L unless it is truly one bounded change (a size-S task keeps a single implementer). Scripts: ${CLAUDE_PLUGIN_ROOT}/scripts. Write .doug/plan.json and return the rendered plan." })`. Then `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" set card <id>` and `plan.mjs set swarm on` (`node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" set swarm on`) guarantee the card and the opt-in even if the planner forgot, put `plan.mjs show` in the chat, and ask the approval gate with `AskUserQuestion`: approve as written, edit first, or stop. Approval is never automatic.
+Otherwise, for one card, ask with `AskUserQuestion`: run it as a swarm, or by hand. Swarm: spawn the planner the way `doug-plan` does, on the `plan` row: read it with the `plan.mjs models` command, `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" models` (`roles.plan.model`, `roles.plan.effort`), and pass that row's model (omit `model` when the row says `inherit`), but tell it this plan runs as a swarm the way `/doug-swarm` does: `Agent({ subagent_type: "doug-flow:planner", model: "<the plan row's model>", prompt: "Board card <id>, title \"<title>\": <goal>. This plan runs as a swarm: set \"swarm\": true in the plan file, and size every task M or L unless it is truly one bounded change (a size-S task keeps a single implementer). Scripts: ${CLAUDE_PLUGIN_ROOT}/scripts. Write .doug/plan.json and return the rendered plan." })`. Then `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" set card <id>` and `plan.mjs set swarm on` (`node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" set swarm on`) guarantee the card and the opt-in even if the planner forgot, put the complete output of `plan.mjs show` in the chat, verbatim, in a fenced code block, before the AskUserQuestion (never a summary instead), and ask the approval gate with `AskUserQuestion`: approve as written, edit first, or stop. Approval is never automatic.
 
 On approve: `plan.mjs approve`, `plan.mjs anchor`, invoke the `swarm-launch` skill. Note the wall clock when it starts and ends. When it returns, save the `result` object of the Workflow tool's output to `.doug/.state/last-report.json` with the Write tool and note the run id the Workflow tool printed (`wf_...`), the way `/doug-next` step 4 does: `plan.mjs replan`, `plan.mjs done`, `board.mjs record`, and `cost.mjs <run-id>` all read those two. If the report carries `paused`, follow `/doug-next` step 4's paused paragraph: name the tasks in `next` and ask with `AskUserQuestion` whether to open the gate; yes reopens with `plan.mjs gate open <level>` and a relaunch with `resumeFromRunId`, no leaves the card In flow and stops — `plan.mjs done` refuses while the last report is paused. A paused or failed batch changes nothing in this mechanism: the paused paragraph and `plan.mjs replan` both work from the plan file, which keeps `cards` through replan, and a second pass is detected the way `/doug-next` section 2 is, by the plan's `cards` matching this batch. Otherwise read the report as `swarm-launch` says, then `plan.mjs done` and `plan.mjs land`; a report that is not ok goes back through `plan.mjs replan` and the approval gate above, or by hand if the user says so — for a batch, "by hand" dissolves it: the first card continues by hand at step 3, and every other card of the batch goes back to Ready with `board.mjs move <id> ready`.
 
@@ -64,7 +66,7 @@ The session model is the lead and only the lead, on both tracks; it never implem
 
 First the research step when step 1 called for one: invoke the `research` skill. It names the agent (claude-code-guide for Claude Code questions, the plugin's read-only `researcher` agent otherwise), runs several researchers in parallel when there are several distinct questions, and writes one cited note to `.doug/.state/research/<id>.md`; read it before writing the brief, and treat a line marked unverified as a fact the code must not depend on.
 
-Then recall memory for the card: `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" brief-lessons <id>`, and paste its output verbatim, header, lesson lines with their ids, and `memoryUsed` line, into every tester, coder, and reviewer brief. When it prints no lessons, or exits nonzero, say so in the chat and go on: recall never blocks a card. Save each brief to `.doug/.state/reports/<id>/briefs/<n>-<seat>.md` before spawning its agent, and each reviewer report to `.doug/.state/reports/<id>/reviews/<n>.md` when it returns.
+Then recall memory for the card: `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" brief-lessons <id>`, and paste its output verbatim, header, lesson lines with their ids, and `memoryUsed` line, into every tester, coder, and reviewer brief. Then fetch the full text of each indexed lesson the card needs with `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" lesson show <id> --card <id>` and paste each output verbatim below that block in the same briefs; never cut or paraphrase a fetched lesson. When it prints no lessons, or exits nonzero, say so in the chat and go on: recall never blocks a card. Save each brief to `.doug/.state/reports/<id>/briefs/<n>-<seat>.md` before spawning its agent, and each reviewer report to `.doug/.state/reports/<id>/reviews/<n>.md` when it returns.
 
 On the lean lane and on a tests-only card, every brief carries the same `brief-lessons` block.
 
@@ -84,6 +86,8 @@ Before the commit the lead itself runs `node .doug/hooks/scripts/verify.mjs` (th
 
 Stay within the card's goal. A defect found on the way that the goal does not cover becomes a new hand-track card, not part of this commit.
 
+When a by-hand run stops a card after Start (a hook block it reports, a design question answered stop, a gate it cannot get green, an unresolved reviewer blocker, or the user saying stop), the lead runs the recording step once: `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" record <id> --hand --stop <reason> --detail "<one line>"`. `<reason>` is one of the card loop's stop reasons (`lib/card-loop.mjs` `STOP_REASONS`) or `user-stopped` when the user stopped it.
+
 ## 4. Record and land
 
 With the commit sha (the merge sha for a swarmed card) and the wall clock since step 1 (or since 2b's launch, for a swarmed card):

package/node_modules/@dougharness/flow/skills/doug-learn/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: doug-learn
-description: Log-then-propose self-improvement (card learn-signals). Counts signals from the outcomes/lessons store and the run trace, renders each candidate change - demote a violated prose rule to a hook, delete a rule nothing references, promote a repeated lesson, tighten a skill description - as a diff, and asks the user to approve each one before applying it. Only the user invokes this; it never applies a change on its own.
+description: Log-then-propose self-improvement (card learn-signals). Counts signals from the outcomes/lessons store and the run trace, renders each candidate change - demote a violated prose rule to a hook, delete a rule nothing references, promote a pitfall lesson recorded for 3 cards over 2 sessions (as a path-scoped `.claude/rules` file, or a CLAUDE.md Gotchas bullet when no files are known), tighten a skill description - as a diff, and asks the user to approve each one before applying it. Only the user invokes this; it never applies a change on its own.
 disable-model-invocation: true
 allowed-tools: AskUserQuestion, Read, Bash(node *learn.mjs *), Bash(git *)
 ---

package/node_modules/@dougharness/flow/skills/doug-next/SKILL.md

@@ -33,6 +33,8 @@ If `.doug/plan.json` is already a draft whose `card` is this id (or whose `cards
 
 A size L card with no `docs/specs/<card-id>/spec.md` is offered feature mode first (ADR 0012): before the planner, ask with `AskUserQuestion` whether to run `/doug-start <id>` (specification, optional pseudocode, architecture, refinement) or plan now; `/doug-start <id>` ends this loop and the card stays In flow. S and M cards go straight to the plan, and any card can still run `/doug-start <id>` on request. Under autopilot the offer is not asked and the card goes straight to the plan.
 
+Batch: ask the offer for each such card before any planner is spawned; a card answered `/doug-start <id>` is dropped from the batch and stays In flow for `/doug-start <id>`, and the rest of the batch goes on (one card left is a plain single-card run; none left ends this loop).
+
 If the card's goal depends on a fact outside the repository (a Claude Code hook contract, a CLI's output format, a third-party API), invoke the `research` skill first and add `Research note: <path>` to the planner's prompt; the planner writes the facts it relied on into the plan's goal with their sources.
 
 The planner runs on the `plan` row (see "Who does the work" above): read it with the `plan.mjs models` command, `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" models` (`roles.plan.model`, `roles.plan.effort`), and pass that row's model on every planner spawn below (omit `model` when the row says `inherit`).

package/node_modules/@dougharness/flow/skills/doug-start/SKILL.md

@@ -19,7 +19,8 @@ The Walking skeleton writes no phase file; it is done when the `walking-skeleton
 
 - Only a committed phase file counts as done: a phase file that exists but is uncommitted means that phase is still waiting at its gate, so the next run re-asks that gate, showing the file, and does not move on.
 - A phase file is written by the lead (this session). The spec-writer and researcher agents return text and write nothing.
-- Before writing a phase, check whether its file exists. If it does, write the new text to `.doug/.state/scratch/<name>.new`, show `git diff --no-index` of the two, and ask (AskUserQuestion: replace / keep / revise). Never overwrite a phase file without that answer.
+- Before writing a phase, check whether its file exists. If it does, write the new text to `.doug/.state/scratch/<name>.new`, show `git diff --no-index` of the two in the chat, in a fenced code block, before the AskUserQuestion, and ask (AskUserQuestion: replace / keep / revise). Never overwrite a phase file without that answer.
+- Show the file first: before every gate that asks about a phase file, put the file's complete text in the chat, verbatim, in a fenced code block, before the AskUserQuestion. Never replace it with a summary or a path, and never truncate it (a very long file may go over more than one message). After the block the lead may add a few lines (assumptions, open questions); the questions themselves go in the AskUserQuestion.
 - The gate after each phase asks AskUserQuestion with the options approve / revise / stop. Approve: commit the phase file (a plain message, no trailers) and go to the next phase. Revise: take the user's note, redraft, show the diff, ask again. Stop: leave the file uncommitted and end; a later `/doug-start` resumes at the first missing phase file.
 - At every gate the lead calls AskUserQuestion, even when the session looks non-interactive; a denied or unanswered call ends the phase there, and the lead does nothing past it (it names the phase that is waiting).
 
@@ -31,7 +32,7 @@ Start here: if `.doug/config.json` is missing, run `doug init --yes` first. It w
 
 Writes `docs/product/idea.md` (problem, users, success, non-goals). Spawn the spec-writer with the user's idea and ask it for those four sections:
 `Agent({ subagent_type: "doug-flow:spec-writer", prompt: "<the user's idea verbatim>. Draft docs/product/idea.md with sections: problem, users, success, non-goals. Return the file text." })`
-Write the file, then ask at the AskUserQuestion gate (approve / revise / stop).
+Write the file, show the file first (Phase rules), then ask at the AskUserQuestion gate (approve / revise / stop).
 
 ### 2. Architecture
 
@@ -39,7 +40,7 @@ Writes `docs/product/architecture.md` plus the ADR `docs/decisions/0001-stack.md
 `Agent({ subagent_type: "doug-flow:researcher", prompt: "<one stack question>. Cite each fact with its source." })`
 Then spawn the architect on the `plan` row's model (`node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" models`; omit `model` when it says `inherit`):
 `Agent({ subagent_type: "architect", model: "<the plan row's model>", prompt: "<the approved idea and the research>. Return the text of docs/product/architecture.md and, separately, the body of the stack ADR without its title line." })`
-Write `docs/product/architecture.md` from its returned text. `docs/decisions/` is proposal-only, so the lead never Writes it directly. Save the ADR body under `.doug/.state/scratch/` and run `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" decision propose --title "Stack" --file <body>`, which renders the diff for `docs/decisions/0001-stack.md` under `.doug/.state/learn/` and writes nothing else. Then ask at the AskUserQuestion gate (approve / revise / stop). On approve, run `node "${CLAUDE_PLUGIN_ROOT}/scripts/learn.mjs" apply <proposal-file>`, which writes the ADR, and commit. Unapproved, the proposal stays pending and the ADR does not exist.
+Write `docs/product/architecture.md` from its returned text. `docs/decisions/` is proposal-only, so the lead never Writes it directly. Save the ADR body under `.doug/.state/scratch/` and run `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" decision propose --title "Stack" --file <body>`, which renders the diff for `docs/decisions/0001-stack.md` under `.doug/.state/learn/` and writes nothing else. Show the file first (Phase rules) for `architecture.md` and for the proposal's ADR diff, then ask at the AskUserQuestion gate (approve / revise / stop). On approve, run `node "${CLAUDE_PLUGIN_ROOT}/scripts/learn.mjs" apply <proposal-file>`, which writes the ADR, and commit. Unapproved, the proposal stays pending and the ADR does not exist.
 
 ### 3. Walking skeleton
 
@@ -49,7 +50,7 @@ Writes the first card with `doug board add` (id `walking-skeleton`, size S, clas
 
 Writes `docs/product/scope.md` (v1 in one paragraph, then one line per card) and the board cards. Spawn the spec-writer with the approved idea and architecture; it returns the text of `scope.md` and the card list as one line per card (id, title, goal, size, class, column):
 `Agent({ subagent_type: "doug-flow:spec-writer", prompt: "<idea and architecture paths>. Draft docs/product/scope.md and its card list: id, title, goal, size, class, column. Return the file text." })`
-The lead never drafts the scope; it writes the returned `scope.md` and runs `doug board add` only for each card the user approved. A card counts as approved at the gate, or in advance in the conversation. Cards are written with `doug board add`, never by a script editing `.doug/board.json`. Put at most 7 to Ready for v1 and the rest to Backlog, each with a size; a large card then goes through feature mode (`/doug-start <card-id>`). Show the board (`doug board list`) and ask at the AskUserQuestion gate (approve / revise / stop).
+The lead never drafts the scope; it writes the returned `scope.md` and runs `doug board add` only for each card the user approved. A card counts as approved at the gate, or in advance in the conversation. Cards are written with `doug board add`, never by a script editing `.doug/board.json`. Put at most 7 to Ready for v1 and the rest to Backlog, each with a size; a large card then goes through feature mode (`/doug-start <card-id>`). Show the file first (Phase rules) for `scope.md`, show the board (`doug board list`) and ask at the AskUserQuestion gate (approve / revise / stop).
 
 ## Feature mode
 
@@ -59,21 +60,21 @@ Files live under `docs/specs/<card-id>/`. A goal with no card id gets a short ke
 
 Writes `spec.md`: what must be true when the work is done, as outcomes a command can check, plus non-goals and open questions.
 `Agent({ subagent_type: "doug-flow:spec-writer", prompt: "<card goal or the user's goal verbatim>. Draft docs/specs/<card-id>/spec.md: outcomes, non-goals, open questions. Return the file text." })`
-Write the file, then ask at the AskUserQuestion gate (approve / revise / stop).
+Write the file, show the file first (Phase rules), then ask at the AskUserQuestion gate (approve / revise / stop).
 
 ### 2. Pseudocode (optional)
 
-Writes `pseudocode.md`, only when the user asks for it at this gate (AskUserQuestion: write it / skip). Skip leaves no file and goes to Architecture; a missing `pseudocode.md` counts as skipped once `architecture.md` exists, or when the user said they skipped it; resuming with only `spec.md` asks write / skip once. When written, spawn the spec-writer again for the algorithm in plain steps, and gate it as above.
+Writes `pseudocode.md`, only when the user asks for it at this gate (AskUserQuestion: write it / skip). Skip leaves no file and goes to Architecture; a missing `pseudocode.md` counts as skipped once `architecture.md` exists, or when the user said they skipped it; resuming with only `spec.md` asks write / skip once. When written, spawn the spec-writer again for the algorithm in plain steps, and gate it as above: show the file first (Phase rules).
 
 ### 3. Architecture
 
-Writes `architecture.md` in the shape of the architect agent: modules, files, interfaces, the test for each. Every file it names will be owned by a plan task, so name each exactly. Spawn the project's `architect` agent on the `plan` row's model with `spec.md` (and `pseudocode.md` if present) and the code it touches: `Agent({ subagent_type: "architect", model: "<the plan row's model>", prompt: "<the spec path>. Return the text of docs/specs/<card-id>/architecture.md." })`. The lead writes its returned text to the file and never drafts it. Then ask at the AskUserQuestion gate (approve / revise / stop).
+Writes `architecture.md` in the shape of the architect agent: modules, files, interfaces, the test for each. Every file it names will be owned by a plan task, so name each exactly. Spawn the project's `architect` agent on the `plan` row's model with `spec.md` (and `pseudocode.md` if present) and the code it touches: `Agent({ subagent_type: "architect", model: "<the plan row's model>", prompt: "<the spec path>. Return the text of docs/specs/<card-id>/architecture.md." })`. The lead writes its returned text to the file and never drafts it. Show the file first (Phase rules), then ask at the AskUserQuestion gate (approve / revise / stop).
 
 ### 4. Refinement
 
 The planner writes an approvable plan whose tasks own the files `architecture.md` names. Read the `plan` row with `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" models` and pass its model (omit `model` when it says `inherit`):
 `Agent({ subagent_type: "doug-flow:planner", model: "<the plan row's model>", prompt: "<card goal>. Spec: docs/specs/<card-id>/spec.md. Architecture: docs/specs/<card-id>/architecture.md. Scripts: ${CLAUDE_PLUGIN_ROOT}/scripts. Write .doug/plan.json as a draft and return the rendered plan." })`
-Set the card when the argument was a board card id (`node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" set card <card-id>`), render it (`node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" show`) and ask at the AskUserQuestion gate (approve / revise / stop). The plan is approved with `/doug-approve`, by the user; this skill never approves it.
+Set the card when the argument was a board card id (`node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" set card <card-id>`), render it (`node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" show`), show the file first (Phase rules), meaning the plan's complete `show` output in the chat, and ask at the AskUserQuestion gate (approve / revise / stop). The plan is approved with `/doug-approve`, by the user; this skill never approves it.
 
 ### 5. Completion
 

package/node_modules/@dougharness/flow/skills/doug-swarm/SKILL.md

@@ -22,7 +22,7 @@ Put the card's title and goal (or the goal text) in the chat verbatim, in a fenc
 
 ## 2. Plan on the plan row
 
-The planner runs on the `plan` row, the same row `doug-plan` uses, not the `lead` row (the `lead` row is the swarm's own lead agent inside the workflow, a different job). Read it with the `plan.mjs models` command, `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" models` (`roles.plan.model`, `roles.plan.effort`). Spawn the planner on it: `Agent({ subagent_type: "doug-flow:planner", model: "<the plan row's model>", prompt: "Board card <id>, title \"<title>\": <goal>. This plan runs as a swarm: set \"swarm\": true in the plan file, and size every task M or L unless it is truly one bounded change (a size-S task keeps a single implementer). Scripts: ${CLAUDE_PLUGIN_ROOT}/scripts. Write .doug/plan.json and return the rendered plan." })` (for a goal, the prompt is the goal text with the same swarm sentence); omit `model` when the row says `inherit`. The planner's rules apply unchanged: disjoint file ownership per task, a verify command per task, acceptance criteria with commands, no tier set on its own.
+The planner runs on the `plan` row, the same row `doug-plan` uses, not the `lead` row (the `lead` row is the swarm's own lead agent inside the workflow, a different job). Read it with the `plan.mjs models` command, `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" models` (`roles.plan.model`, `roles.plan.effort`). Spawn the planner on it: `Agent({ subagent_type: "doug-flow:planner", model: "<the plan row's model>", prompt: "Board card <id>, title \"<title>\": <goal>. This plan runs as a swarm: set \"swarm\": true in the plan file, and size every task M or L unless it is truly one bounded change (a size-S task keeps a single implementer). The shape gate keeps a task off the lead unless it owns two or more source files (not counting its tests), and a size-S task never reaches the lead, so give each M or L task two or more source files. Scripts: ${CLAUDE_PLUGIN_ROOT}/scripts. Write .doug/plan.json and return the rendered plan." })` (for a goal, the prompt is the goal text with the same swarm sentence); omit `model` when the row says `inherit`. The planner's rules apply unchanged: disjoint file ownership per task, a verify command per task, acceptance criteria with commands, no tier set on its own.
 
 Then guarantee the opt-in and the card (`plan.mjs set swarm on`): `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" set swarm on`, and `plan.mjs set card <id>` for a card. `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" show` and put its complete output in the chat verbatim, in a fenced code block, before anything else; it prints `Swarm: on`. Name any task the planner sized S (it will not swarm) and any assumption it stated.
 

package/node_modules/@dougharness/flow/skills/run-report/SKILL.md

@@ -43,7 +43,7 @@ With the card id, the landing commit, the wall clock, and the gate line — one
 1. `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" record <id> --hand --commit <sha> --wall "<m> min" --gate "<gate line>" --summary "<one sentence>" --cost <usd>`, with `--note "<one line>"` when something about the build is worth keeping. `<usd>` is the card's measured cost, never an estimate: `node "${CLAUDE_PLUGIN_ROOT}/scripts/cost.mjs" --session <session> --since <openedAt>` prices the lead session and its subagents from the card's `openedAt` (in `.doug/.state/reports/<id>/condition.json`) to now, where `<session>` is `CLAUDE_CODE_SESSION_ID` (not the card id); take the session total's dollar figure. When nothing was measured (no condition.json, no session id, or cost.mjs exits non-zero), leave `--cost` out: the entry then has no Cost row, never a `$0`, and you never estimate one. This appends the hand-track entry to `docs/live-runs.md`; its table is the summary. It also promotes `.doug/.state/research/<id>.md` to `docs/research/<id>.md` when that note exists, printing one line saying so; add that path to the landing commit alongside `docs/live-runs.md`.
 2. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" import`, the same as above: its one-line output goes in the chat, an exit 1 naming Node is said in the chat and the landing goes on, and it is idempotent, supersedes a rewritten file, and never writes under the auto-memory directory.
 3. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" record <id> --hand --commit <sha> --wall "<m> min" --gate "<gate line>" [--cost <usd>] [--note "<one line>"]`, the same values step 1 used, leaving `--cost` out when step 1 did. It records one row in the local outcome log `.doug/.state/memory/memory.db` (uncommitted), keyed `hand:<sha>` so re-recording the same commit updates that row and track `hand`; a card that lands twice, in two commits, gets two rows. Its workflow-only columns (verified, review counts, adversary verdict, blocks, fix passes, budget, tokens, the report itself) are null because they do not exist on this track, never because they measured zero: no independent verifier ran, and the gate's own text is the `gate` column instead. The USD column is the measured `--cost`, null when none was given. It needs Node >=22.16 (node:sqlite). When it exits 1 naming Node, say so in the chat and go on, since the record is a log, not a gate.
-4. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" reflect --hand <id> --commit <sha> --rounds <n> [--review "<key>=<class>: <reason>"]... (the key is "`R<n>` or `<card>/R<n>`") [--harmful <id>]... [--note "<one line>"]`. It reads the briefs, reviewer reports and lessons.json doug-hand saved, applies helpful counters to the card's memoryUsed. A real block no longer bumps harmful; pass `--harmful <id>` once per recalled lesson the lead judges actually misled the work (it must be in a task's `memoryUsed`, else exit 1). Give `--harmful` on the report's first reflect: a rerun is "Already reflected" and ignores it. It proposes at most three lessons on the cheap row, filtered in code. Its one-line summary (with the measured cost) goes in the chat. An exit 1 naming the LLM pass is said in the chat and the landing goes on regardless — reflect is a log, not a gate, the same as record.
+4. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" reflect --hand <id> --commit <sha> --rounds <n> [--review "<key>=<class>: <reason>"]... (the key is "`R<n>` or `<card>/R<n>`") [--harmful <id>]... [--note "<one line>"]`. It reads the briefs, reviewer reports and lessons.json doug-hand saved, applies helpful counters to the card's memoryUsed (only lessons fetched with `lesson show <id> --card <id>`). A real block no longer bumps harmful; pass `--harmful <id>` once per recalled lesson the lead judges actually misled the work (it must be in a task's `memoryUsed`, else exit 1). Give `--harmful` on the report's first reflect: a rerun is "Already reflected" and ignores it. It proposes at most three lessons on the cheap row, filtered in code. Its one-line summary (with the measured cost) goes in the chat. An exit 1 naming the LLM pass is said in the chat and the landing goes on regardless — reflect is a log, not a gate, the same as record.
 
 Say the one-sentence summary record printed first, then the commit, the wall clock, and the gate line in the chat. In the hand form the landing block is printed by `board.mjs record` (both forms) and by `board.mjs summary --card` as their last three lines (Changed, Outcome, Learned; at most 100 words, `--note` feeds Learned); plain `summary` (no `--card`) prints no block. Your final message carries it verbatim, and the Stop gate blocks until it does.
 

package/node_modules/@dougharness/flow/workflows/card-queen.js

@@ -75,7 +75,11 @@ const BRIEF_RULES = {
     seats: ["tester", "coder", "reviewer"],
   },
   "lessons-verbatim": {
-    text: "Return the memory.mjs brief-lessons block for this card verbatim in lessons; never paraphrase it.",
+    text: "Run memory.mjs brief-lessons <card-id> <repo-root>, passing the REPO ROOT named in this brief as [dir], and return its block for this card verbatim in lessons; never paraphrase it.",
+    seats: ["lead"],
+  },
+  "lessons-fetch": {
+    text: "For each indexed lesson the card needs, run memory.mjs lesson show <id> <repo-root> --card <card-id>, passing the REPO ROOT named in this brief as [dir], and append its output verbatim to lessons below the brief-lessons block; never cut or paraphrase a fetched lesson.",
     seats: ["lead"],
   },
   "facts-cited": {
@@ -120,7 +124,7 @@ const BRIEF_RULES = {
   },
   "no-trailers": {
     text: "Commit without Co-Authored-By or Claude-Session trailers.",
-    seats: ["commit"],
+    seats: ["tester", "coder", "reviewer", "commit"],
   },
   "commit-foreground": {
     text: "Run git commit in the foreground with the Bash tool timeout set to 600000 ms: the pre-commit hook runs the full unit suite and takes over the 2-minute default.",
@@ -138,6 +142,11 @@ const BRIEF_RULES = {
     text: "Run the gate commands only. Never run git add, git commit, or any other command that writes to git; the commit seat is the only seat that commits.",
     seats: ["gate"],
   },
+  "gate-reinstall-missing-deps": {
+    text: "Before the gate commands, check that node_modules exists in the card worktree. Only when it is missing, run the INSTALL COMMAND and report it as the first commands item, then run the gate. Never install when node_modules is present.",
+    seats: ["gate"],
+    when: "install",
+  },
   "gate-timeout-is-load": {
     text: "When verify.mjs prints `exit timeout` for a command, report that command with timedOut: true; a timeout is load, not a red or a block, so leave blocked unset.",
     seats: ["gate"],
@@ -422,6 +431,7 @@ const effectiveMutations = (s) => (s.lane === "lean" ? [] : s.material.mutations
 
 function ruleApplies(rule, seat, s) {
   if (!rule.seats.includes(seat)) return false;
+  if (rule.when === "install") return s.install !== null && s.install !== undefined;
   if (rule.when === "full") return s.lane === "full";
   if (rule.when === "tests-only") return s.lane === "tests-only";
   if (rule.when === "mutations") {
@@ -456,7 +466,12 @@ function buildBrief(s) {
     gate: fixing && s.fixFor === "gate" ? cp(s.lastGate) : null,
     redTests: cp(s.redTests),
     answers: (s.answers || [])
-      .filter((a) => a.seat === seat && (a.round === undefined || a.round <= (s.seatRuns[seat] || 0) + 1))
+      .filter(
+        (a) =>
+          (a.seat === seat && (a.round === undefined || a.round <= (s.seatRuns[seat] || 0) + 1)) ||
+          // A reviewer answer reaches the build seat once the reviewer round it targets has run.
+          (seat === buildSeat(s) && a.seat === "reviewer" && (a.round ?? 1) <= (s.seatRuns.reviewer || 0)),
+      )
       .map((a) => ({ question: a.question, answer: a.answer })),
     writeTestsFirst: seat === "coder" && s.counters.coderRounds === 0 && (s.lane === "lean" || !s.testerAgent),
     researchNote: s.researchNote,
@@ -466,6 +481,7 @@ function buildBrief(s) {
     brief.install = s.install;
     brief.base = s.base;
   }
+  if (seat === "gate" && s.install) brief.install = s.install;
   if (seat === "gate" || seat === "reviewer") brief.gateCommand = s.gateCommand;
   if (seat === "commit") brief.gateTree = s.gateTree;
   return brief;
@@ -854,6 +870,18 @@ function next(state, handBack) {
       // An evidenced major gets the same one fix pass; a major without evidence and a minor stay advisory.
       const majors = findings.filter((f) => f.severity === "major" && nonBlank(f.evidence));
       if (blockers.length === 0 && majors.length === 0) return advance(s, "gate", "ok", { acc });
+      // A reviewer round that carried a user answer and still has an open finding gets one extra coder round.
+      const answered = (s.answers || []).some(
+        (a) => a.seat === "reviewer" && (a.round ?? 1) <= (s.seatRuns.reviewer || 0),
+      );
+      if (s.counters.fixPasses >= 1 && answered && !s.answerCoderUsed) {
+        return advance(s, buildSeat(s), "blockers", {
+          acc,
+          fixFor: "review",
+          answerCoderUsed: true,
+          lastFindings: findings.filter((f) => f.severity !== "minor"),
+        });
+      }
       if (s.counters.fixPasses >= 1) {
         if (blockers.length > 0) {
           return stopWith(
@@ -879,7 +907,16 @@ function next(state, handBack) {
       const lastGate = { commands: cp(H.commands), gateLine: H.gateLine };
       const waited = { ...s.acc, lockWaitMs: (s.acc.lockWaitMs || 0) + (Number.isInteger(H.lockWaitMs) ? H.lockWaitMs : 0) };
       s.acc = waited;
-      if (H.commands.every((c) => c.exitCode === 0)) {
+      const isInstall = (c) => s.install && typeof c.command === "string" && c.command.trim() === `cd ${s.worktree} && ${s.install}`;
+      const failedInstall = H.commands.find((c) => isInstall(c) && c.exitCode !== 0);
+      if (failedInstall) {
+        return stopWith({ ...s, lastGate }, "setup-failed", `gate reinstall exited ${failedInstall.exitCode === null ? "without a code" : failedInstall.exitCode}`);
+      }
+      const nonInstall = H.commands.filter((c) => !isInstall(c));
+      if (nonInstall.every((c) => c.exitCode === 0)) {
+        if (!nonInstall.some((c) => typeof c.command === "string" && c.command.includes(s.gateCommand))) {
+          return stopWith({ ...s, lastGate }, "hand-back-invalid", `gate hand-back has no run of the gate command ${s.gateCommand}`);
+        }
         return advance(s, "commit", "ok", { lastGate, gateTree: H.tree, acc: { ...waited, gateLine: H.gateLine } });
       }
       const redGates = s.counters.redGates + 1;
@@ -918,15 +955,17 @@ function briefPrompt(brief, { repoRoot, worktreePath } = {}) {
     out.push("ANSWERS FROM THE USER (to your design questions; build on them):\n" + bullets(b.answers.map((a) => `Q: ${a.question} A: ${a.answer}`)));
   }
   out.push("WORKTREE: " + worktreePath);
+  if (b.seat === "lead" && typeof repoRoot === "string" && repoRoot !== "") out.push("REPO ROOT: " + repoRoot);
   if (b.seat === "setup") {
     out.push(
       "SETUP:\n" +
         `Create the card worktree: git -C ${repoRoot} worktree add -b ${b.branch} ${worktreePath} ${b.base}\n` +
         (b.install
-          ? `Then run the install command in ${worktreePath}: ${b.install}`
+          ? `Then run the install command as this one literal command: cd ${worktreePath} && ${b.install}`
           : "There is no install command; skip the install and report install as null."),
     );
   }
+  if (b.seat === "gate" && b.install) out.push(`INSTALL COMMAND: cd ${worktreePath} && ${b.install}`);
   if (b.researchNote) out.push("RESEARCH NOTE:" + (b.researchNote.includes("\n") ? "\n" : " ") + b.researchNote);
   if (b.lessons) out.push("LESSONS BLOCK verbatim:\n" + b.lessons);
   if (b.facts.length > 0) out.push("FACTS (with sources):\n" + bullets(b.facts.map((f) => `${f.text} [${f.source}]`)));

package/node_modules/@dougharness/flow/workflows/doug-implement.js

@@ -3,7 +3,7 @@ export const meta = {
   description: 'Implement an approved Doug plan: one implementer per task in its own worktree, then verify, review, and integrate',
   whenToUse: 'After /doug-plan produced .doug/plan.json and the user approved it with /doug-approve. Pass the plan JSON as args.',
   phases: [
-    { title: 'Implement', detail: 'one implementer per task, fresh context, own worktree (with swarm on, a lead splits a full-shape task into worker briefs, workers implement them in parallel, and the lead merges); a task marked reuse checks out its recorded branch instead; a task whose dependency did not integrate is never launched; a block the checks can describe is fixed in place until the task budget, the fix-attempt ceiling, a pass that made no new commit, or two consecutive passes raising a new blocker stops it' },
+    { title: 'Implement', detail: 'one implementer per task, fresh context, own worktree (with swarm on, a lead splits a full-shape task into worker briefs, workers implement them in parallel, and the lead merges); a task marked reuse rebuilds the own commits of its recorded branch on the current base instead; a task whose dependency did not integrate is never launched; a block the checks can describe is fixed in place until the task budget, the fix-attempt ceiling, a pass that made no new commit, or two consecutive passes raising a new blocker stops it' },
     { title: 'Verify', detail: 'a separate verifier runs the task command in the worktree on the first pass; a fix pass runs one focused check over the fix delta instead, and the full verifier again only when the verifier is the stage that blocked; a task whose crew names more testers gets extra verifiers in parallel' },
     { title: 'Review', detail: 'spec compliance, then quality, against the diff on the first pass; on a fix pass the focused check carries scope and regression risk unless the reviewer is the stage that blocked; a task whose crew names two reviewers gets a second one in parallel with a distinct brief' },
     { title: 'Adversary', detail: 'codex-review (a different model, read-only) explores freely on the first pass and confirms the open findings on later passes, under one material blocker gate; when it cannot run, a Claude adversary on plan.adversary.fallback stands in; blockers stop integration' },
@@ -117,7 +117,7 @@ const roleModels = (plan.models && plan.models.roles) || {}
 // The adversary row may name "codex": the review runs on Codex (plan.adversary.command) and the Claude agent
 // that launches it and relays the verdict is only a relay, so it runs on haiku. `relay` is that agent's model.
 const ADVERSARY_RELAY_MODEL = 'haiku'
-// Checking out a reused branch is mechanical, so it runs on the same small model as the adversary relay.
+// Rebuilding a reused branch is a scripted run of listed git commands, so it runs on the same small model as the adversary relay.
 const CHECKOUT_MODEL = ADVERSARY_RELAY_MODEL
 // The fix-loop supervisor (card fix-loop-supervisor) runs on the `cheap` tier of the Models table; a table without
 // one puts it on the relay model, since reading a task's passes and writing a brief is small work.
@@ -706,6 +706,10 @@ function droppedWhy(f, task) {
 // Applies one pass to the ledger, stage by stage in the order the stages ran, and returns the ids that opened,
 // were confirmed fixed, and came back. A stage confirms an open entry by running and not reporting it: its own
 // stage, the focused check, and the confirmation adversary all count, and only on a pass that made a new commit.
+function explicitMinor(f) {
+  return ['minor', 'nit', 'note'].includes(String(f.severity == null ? '' : f.severity).trim().toLowerCase())
+}
+
 function updateLedger(ledger, r, pass, newCommit) {
   const opened = []
   const fixed = []
@@ -734,7 +738,7 @@ function updateLedger(ledger, r, pass, newCommit) {
         if (e.status !== 'open' || e.openedPass === pass || touched.has(e.id)) continue
         const covers = e.stage === stage || stage === 'check' || (stage === 'adversary' && pass > 1)
         if (!covers) continue
-        if (reReports.some(f => matchFinding(ledger, f) === e)) continue
+        if (reReports.some(f => !explicitMinor(f) && matchFinding(ledger, f) === e)) continue
         e.status = 'fixed'
         e.fixedPass = pass
         e.fixedCommit = r.commit || null
@@ -745,6 +749,10 @@ function updateLedger(ledger, r, pass, newCommit) {
     for (const f of reReports) {
       const entry = matchFinding(ledger, f)
       if (entry) {
+        // Card stall-on-repeat-minor (2026-10-25 decision, run wf_d9199b24-d9e): a re-report whose severity is
+        // explicitly minor/nit/note neither reopens a fixed entry nor keeps an open one open. Free text and
+        // blocker/major re-reports (and severity-less ones) still do.
+        if (explicitMinor(f)) continue
         touched.add(entry.id)
         if (f.evidence) entry.evidence = f.evidence
         if (entry.status === 'fixed') {
@@ -848,7 +856,7 @@ function implementPrompt(task, baseBranch, opts) {
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
     task.spec,
-    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons).slice(0, 2000)] : []),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons)] : []),
     ...(typeof task.codeContext === 'string' && task.codeContext ? ['', `Code the semantic index found relevant to this task (path:lines; read these first, they are not the files you own):`, String(task.codeContext).slice(0, 2000)] : []),
     ``,
     `Files you own (you may create or edit ONLY these): ${task.files.join(', ')}`,
@@ -876,11 +884,17 @@ function reusePrompt(task, baseBranch) {
     `Files the task owns: ${task.files.join(', ')}`,
     ``,
     `Steps, all inside your own worktree:`,
-    `1. git checkout ${task.reuse}. If git refuses because the branch is checked out in another worktree, that worktree is a leftover of the earlier pass under .claude/worktrees: find it with git worktree list --porcelain, remove it with git worktree remove --force <path>, and check out again.`,
+    `1. Put ${task.reuse} on the current base ${baseBranch}, because the earlier pass may have been cut from an integration branch that no longer exists. If any git checkout below refuses because the branch is checked out in another worktree, that worktree is a leftover of the earlier pass under .claude/worktrees: find it with git worktree list --porcelain, remove it with git worktree remove --force <path>, and run the checkout again.`,
+    `   a. List the branch's own commits: git log --no-merges --reverse --format=%H ${baseBranch}..${task.reuse}`,
+    `   b. For each, read its files with git show --name-only --format= <sha>. A commit with no files is dropped. A commit touching only files the task does not own belongs to another task: drop it. A commit touching both files the task owns and files it does not own means the branch carries work the task does not own: change nothing and return blocked=true with a reason naming the commit and the file. A commit touching only owned files is kept.`,
+    `   Then run git merge-base --is-ancestor ${baseBranch} ${task.reuse}. If it fails with exit 128 (the branch or the base does not exist), return blocked=true naming the missing one. When it exits 0 and step b kept every listed commit, the branch already sits on the current base: just git checkout ${task.reuse} and go to step 2. Otherwise rebuild it:`,
+    `   c. git checkout --detach ${baseBranch}`,
+    `   d. git cherry-pick -x each kept commit, in order. When a pick is empty because the base already has the change, run git cherry-pick --skip. On a conflict, run git cherry-pick --abort and return blocked=true with a reason naming the commit and the conflicting files (the branch ref was never moved, so the reviewed work stays intact).`,
+    `   e. git checkout -B ${task.reuse} to point the branch at the rebuilt HEAD (no base argument).`,
     plan.install
       ? `2. Run the project's install command (${plan.install}) before the checks run. Installing is not a file change; do not commit anything it changes. Should you commit at all, ${NO_TRAILERS}`
       : `2. If the task's verification command needs dependencies, run the project's install command. Installing is not a file change; do not commit anything it changes. Should you commit at all, ${NO_TRAILERS}`,
-    `3. Return taskId="${task.id}", branch="${task.reuse}", worktreePath = the absolute path of your worktree (git rev-parse --show-toplevel), filesTouched = the output of git diff --name-only ${baseBranch}...HEAD, commandsRun with real exit statuses, commit = the output of git rev-parse HEAD, summary "reused ${task.reuse} at <commit>", blocked=false. Report blocked=true with the reason only if the branch does not exist or cannot be checked out.`,
+    `3. Return taskId="${task.id}", branch="${task.reuse}", worktreePath = the absolute path of your worktree (git rev-parse --show-toplevel), filesTouched = the output of git diff --name-only ${baseBranch}...HEAD, commandsRun with real exit statuses, commit = the output of git rev-parse HEAD, summary "reused ${task.reuse} at <commit>", blocked=false. Report blocked=true with the reason only if the branch does not exist, cannot be checked out, or step 1 told you to.`,
   ].join('\n')
 }
 
@@ -902,7 +916,7 @@ function leadPrompt(task, baseBranch, opts) {
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
     task.spec,
-    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons).slice(0, 2000)] : []),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons)] : []),
     ...(typeof task.codeContext === 'string' && task.codeContext ? ['', `Code the semantic index found relevant to this task (path:lines; read these first, they are not the files you own):`, String(task.codeContext).slice(0, 2000)] : []),
     ``,
     `Files the task owns: ${task.files.join(', ')}`,
@@ -937,7 +951,7 @@ function workerPrompt(task, brief, n, lead) {
     `Brief ${brief.id}: ${brief.title}`,
     `Spec:`,
     brief.spec,
-    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons).slice(0, 2000)] : []),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons)] : []),
     ...(typeof task.codeContext === 'string' && task.codeContext ? ['', `Code the semantic index found relevant to this task (path:lines; read these first, they are not the files you own):`, String(task.codeContext).slice(0, 2000)] : []),
     ...(typeof lead.interfaces === 'string' && lead.interfaces ? ['', `Interfaces the briefs export or consume (the lead's design; conform to it, do not redesign it):`, lead.interfaces.slice(0, 2000)] : []),
     ...(siblings.length ? ['', `Sibling briefs of this task (their files are not yours to touch; conform to what they export):`, ...siblings.map(s => `  - ${s.id}: ${s.title} (${(Array.isArray(s.files) ? s.files : []).join(', ')})`)] : []),
@@ -1029,7 +1043,7 @@ function fixPrompt(task, r, pass, baseBranch, ledger, brief) {
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
     task.spec,
-    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons).slice(0, 2000)] : []),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons)] : []),
     ...(typeof task.codeContext === 'string' && task.codeContext ? ['', `Code the semantic index found relevant to this task (path:lines; read these first, they are not the files you own):`, String(task.codeContext).slice(0, 2000)] : []),
     ``,
     `Files you own (you may create or edit ONLY these): ${task.files.join(', ')}`,
@@ -1139,7 +1153,7 @@ function verifyPrompt(task, impl, baseBranch, seat = 1) {
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
     task.spec,
-    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons).slice(0, 2000)] : []),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons)] : []),
     ``,
     `Plan acceptance criteria (the spec must be consistent with these; a line starting with $ is the command that checks the criterion above it and exits 0 when it holds):`,
     ...acceptanceEntries(plan.acceptance || []).flatMap(a => a.command ? [`- ${a.text}`, `  $ ${a.command}`] : [`- ${a.text}`]),
@@ -1172,7 +1186,7 @@ function checkPrompt(task, impl, prevCommit, baseBranch, ledger) {
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
     task.spec,
-    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons).slice(0, 2000)] : []),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons)] : []),
     ``,
     `Plan acceptance criteria (the spec must be consistent with these; a line starting with $ is the command that checks the criterion above it and exits 0 when it holds):`,
     ...acceptanceEntries(plan.acceptance || []).flatMap(a => a.command ? [`- ${a.text}`, `  $ ${a.command}`] : [`- ${a.text}`]),
@@ -1300,7 +1314,7 @@ function reviewPrompt(task, impl, baseBranch, seat = 1) {
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
     task.spec,
-    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons).slice(0, 2000)] : []),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons)] : []),
     `Owned files: ${task.files.join(', ')}`,
     `Plan acceptance criteria:`,
     ...acceptanceEntries(plan.acceptance || []).flatMap(a => a.command ? [`- ${a.text}`, `  $ ${a.command}`] : [`- ${a.text}`]),
@@ -1343,7 +1357,7 @@ function adversaryPrompt(task, impl, baseBranch, pass, ledger) {
     `Task ${task.id}: ${task.title}`,
     ``,
     guard(task.spec),
-    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons).slice(0, 2000)] : []).map(guard),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons)] : []).map(guard),
     ``,
     ...(pass > 1 ? confirmationLines(pass, ledger, impl).map(guard) : [`This is the first pass of this task: explore freely and try to refute the change however you can.`]),
     ``,
@@ -1406,7 +1420,7 @@ function fallbackAdversaryPrompt(task, impl, baseBranch, why, pass, ledger) {
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
     task.spec,
-    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons).slice(0, 2000)] : []),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons)] : []),
     `Owned files: ${task.files.join(', ')}`,
     `Plan acceptance criteria:`,
     ...acceptanceEntries(plan.acceptance || []).flatMap(a => a.command ? [`- ${a.text}`, `  $ ${a.command}`] : [`- ${a.text}`]),
@@ -1866,11 +1880,12 @@ function isReady(r) {
   if (r.impl && r.impl.partial) return false
   // A finding the ledger already recorded as fixed and that came back keeps the task out even when every stage
   // passed. This is deliberately unconditional: updateLedger reopens on any re-report matched by id or fingerprint,
-  // whatever that re-report's own `blocking` flag or severity says - a passing check's free-text "F1: still returns
-  // 1..." reopens F1 ("still reopens and keeps entries on a real re-report"), and so does a passing-verdict
-  // adversary's *minor*-severity issue naming the same id ("blocks the pass when a finding the ledger recorded as
-  // fixed comes back"). Gating this on the reporting finding's own blocking flag would silently let either of those
-  // real reappearances through. A 'waived' report only stays out of the re-report list (card d-waiver-structural-rule)
+  // whatever that re-report's own `blocking` flag says, except that an explicit minor/nit/note severity no longer
+  // reopens (card stall-on-repeat-minor, 2026-10-25) - a passing check's free-text "F1: still returns
+  // 1..." reopens F1 ("still reopens and keeps entries on a real re-report"), and so does an adversary's
+  // blocker-severity issue naming the same id ("blocks the pass when a finding the ledger recorded as fixed comes
+  // back"). Gating this on the reporting finding's own blocking flag would silently let those real reappearances
+  // through. A 'waived' report only stays out of the re-report list (card d-waiver-structural-rule)
   // when the ledger's own entry for that id is itself a self-declared non-blocking note (confirmsFinding above); a
   // disputed waiver against a blocking entry reaches here as an ordinary re-report and can reopen or keep an entry
   // open exactly the same way.

package/node_modules/@dougharness/gates/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "doug-gates",
   "displayName": "Doug Gates",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Deterministic guardrails for Claude Code: protected paths, bash guard, secret scan on edits and commands, format on edit, edit-loop detection, a verification gate on Stop and on SubagentStop, a snapshot of the plan and session into the anchor before compaction and re-anchoring after it, and a run trace of subagents and tool calls. Configured by .doug/config.json.",
   "author": {
     "name": "Doug contributors"

package/node_modules/@dougharness/gates/lib/baseline.mjs

@@ -258,6 +258,15 @@ export function writeAgentStart(dir, cfg, sessionId, agentId) {
   try {
     const fp = treeFingerprint(dir, cfg, changedFiles(dir));
     if (!fp) return;
+    // card worktree-skip-origin-at-start: origin/HEAD's sha at start (null when unset), for the worktree skip.
+    let originHead = null;
+    try {
+      const o = execFileSync("git", ["rev-parse", "--verify", "-q", "refs/remotes/origin/HEAD^{commit}"], { cwd: dir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 }).trim();
+      if (/^[0-9a-f]{7,64}$/.test(o)) originHead = o;
+    } catch {
+      originHead = null;
+    }
+    fp.originHead = originHead;
     const file = agentStartFile(dir, sessionId, agentId);
     mkdirSync(join(file, ".."), { recursive: true });
     writeFileSync(file, JSON.stringify(fp));

package/node_modules/@dougharness/gates/lib/block-ledger.mjs

@@ -110,13 +110,15 @@ export function failingTestFilesFrom(output, dir) {
 //    them is in the standing tests_red_by_design claim (`redByDesignClaimFiles`).
 // 2. 'load-timeout' — at least one command timed out or was dropped for budget, and no failed command's
 //    captured output names a failing test file.
-// 3. 'race' — the working tree (`changedFiles(dir)`, as a set) differs now from `changedAtStart`. Either
+// 3. 'test-count' — the test-count ratchet is the block's only problem (`countProblems > 0` and it equals
+//    `totalProblems`).
+// 4. 'race' — the working tree (`changedFiles(dir)`, as a set) differs now from `changedAtStart`. Either
 //    side being unknown (null: no git, or git unavailable) is never a race. Skipped entirely once
 //    `budgetDeadline` (the gate's own hook-timeout deadline, gateBudget() in stop-gate.mjs) has already
 //    passed (review pass 2, item 4): a second `git status` here is exactly the kind of extra work that
 //    could push a slow gate past the platform's own hook timeout, discarding its block message (F1) — a
 //    deadline already blown is not worth spending on a label, so this falls through to 'real' instead.
-// 4. 'real' — otherwise.
+// 5. 'real' — otherwise.
 //
 // Never throws (review pass 2, item 2 MAJOR): this call sits between the gate's decision to block and the
 // blockStop call that carries it out (stop-gate.mjs), so an unguarded throw here would fail the *whole gate*
@@ -141,10 +143,10 @@ export function classifyFinalBlock({ countProblems, totalProblems, preVerificati
       if (allNamed.every((f) => claimSet.has(f))) return "expected-red";
     }
 
-    // card block-ledger-failing-output: the test-count ratchet is the block's only problem.
     const timedOutOrDropped = (Array.isArray(results) ? results : []).some((r) => r.timedOut || r.skipped === "budget");
     if (timedOutOrDropped && allNamed.length === 0) return "load-timeout";
 
+    // card block-ledger-failing-output: the test-count ratchet is the block's only problem.
     if (typeof countProblems === "number" && countProblems > 0 && totalProblems === countProblems) return "test-count";
 
     if (Array.isArray(changedAtStart) && !(typeof budgetDeadline === "number" && Date.now() >= budgetDeadline)) {