@pmelab/gtd 42.0.0 → 44.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "42.0.0",
+  "version": "44.0.0",
   "description": "Drive the gtd loop inside Claude Code: agent turns run as subagents, gtd decides every beat",
   "author": {
     "name": "Philipp Melab"

package/README.md

@@ -339,10 +339,10 @@ Then, in any repository:
 ```
 
 That starts a process from your requirements and drives it until it needs you.
-The requirements go to the top of `.gtd/TODO.md`; deferred review notes already
-there stay. A long, multi-line requirements paste still starts a process; if
-Claude Code never expanded the paste, gtd says it could not read it, and you add
-the requirements to the top of `.gtd/TODO.md` and run `/gtd`. `/gtd fix`,
+The requirements go to the top of `.gtd/TODO.md`, above whatever it already
+holds. A long, multi-line requirements paste still starts a process; if Claude
+Code never expanded the paste, gtd says it could not read it, and you add the
+requirements to the top of `.gtd/TODO.md` and run `/gtd`. `/gtd fix`,
 `/gtd review [base]`, `/gtd rollout <flag>` and `/gtd cleanup <flag>` (where the
 config exports them) take the doors described below; text whose word count does
 not fit a door's args (bare `/gtd rollout` included) starts a process from that
@@ -522,37 +522,41 @@ noted in steps 3 and 4 below.
 
 4. **You review.** After the last slice's quality lap gtd writes the review
    document itself (`build.review.composing`; no reviewer turn runs): one `## `
-   chunk per design note the lap left, then — for reference, no tick boxes, no
-   answer needed — what was **fixed automatically** (with the fixing commit) and
-   what was **dropped as noise**. On `refactor-first` the refactor slice gets
-   one of its own first, before the feature is built; see
-   [the naive pass](#the-naive-pass). Review the diff yourself (`gtd base`
-   prints its base). Land with no change to approve, or write what is wrong —
-   disagreeing with a fix or a drop means writing a note of your own. Approving
-   ends the process (at the refactor review, it moves on to the feature);
-   feedback is judged note by note, each as `edit`, `question`, `nit` or
-   `praise`. An `edit` sends the process back to step 2 for re-derived
-   requirements — the built criteria keep their IDs (reworded in place when
-   their behaviour changes) and new behaviour gets new ones — then the
-   implementation is amended to meet them, with no new naive pass or seam judge,
-   every criterion's coverage is judged again, the quality lap runs, and you
-   review again. At the refactor review an `edit` re-derives the refactor
-   instead. A `question` is answered inline under your note and the process
-   stops at the review again — no new plan. A `nit` is fixed in one batch, the
-   suite must go green (a red one gets fix turns first), then a fresh review of
-   the change stops at the review again. `praise` is dropped; a round of only
-   praise signs off. When a round mixes them, questions are answered and nits
-   fixed first, then the edits are planned — risk: the planning lap may redo nit
-   fixes it touches.
+   chunk per design note the lap left, each ending in three tick boxes — **fix
+   as suggested**, **won't fix**, or **your own answer** written over
+   `_your answer_` — then, for reference, no tick boxes, no answer needed — what
+   was **fixed automatically** (with the fixing commit) and what was **dropped
+   as noise**. On `refactor-first` the refactor slice gets one of its own first,
+   before the feature is built; see [the naive pass](#the-naive-pass). Review
+   the diff yourself (`gtd base` prints its base). **Every note needs exactly
+   one tick before `gtd land` accepts the review** (`answer-completeness`; an
+   open `- H:` thread waiting on the agent is the one exception). Fix as
+   suggested joins the nit batch below, unjudged; won't fix drops the note and
+   records it as `Gtd-Mark: wontfix=<title>` on the gate's commit; your own
+   answer is judged like a note. A note you answered is left out of the fresh
+   review after a nit fix; a round that also answered a question restores the
+   review instead, your ticks kept. Land with every note answered and nothing
+   else changed to approve, or write what is wrong — disagreeing with a fix or a
+   drop means writing a note of your own. Approving ends the process (at the
+   refactor review, it moves on to the feature); feedback is judged note by
+   note, each as `edit`, `question`, `nit` or `praise`. An `edit` sends the
+   process back to step 2 for re-derived requirements — the built criteria keep
+   their IDs (reworded in place when their behaviour changes) and new behaviour
+   gets new ones — then the implementation is amended to meet them, with no new
+   naive pass or seam judge, every criterion's coverage is judged again, the
+   quality lap runs, and you review again. At the refactor review an `edit`
+   re-derives the refactor instead. A `question` is answered inline under your
+   note and the process stops at the review again — no new plan. A `nit` is
+   fixed in one batch, the suite must go green (a red one gets fix turns first),
+   then a fresh review of the change stops at the review again. `praise` is
+   dropped; a round of only praise signs off. When a round mixes them, questions
+   are answered and nits fixed first, then the edits are planned — risk: the
+   planning lap may redo nit fixes it touches.
 
    Each `edit` note also gets a severity tier from four judge questions
-   (security, reversibility, blast radius, new concept). `critical` and `should`
-   notes are re-planned this round; `could` notes are deferred. A leading `!` on
-   a note forces `critical` and skips the judge. Deferral appends to the
-   committed `.gtd/TODO.md`; it never starts a process on its own, and it ships
-   in the branch/PR unless you delete it. Landing clean at the gate after a
-   deferral signs off without the deferred notes; the gate lists them. To pull
-   one in, edit its line in `.gtd/TODO.md` when you start a process.
+   (security, reversibility, blast radius, new concept). Every tier is
+   re-planned this round, `critical` first, then `should`, then `could`; nothing
+   is deferred. A leading `!` on a note forces `critical` and skips the judge.
    `reviewSeverityMinP` sets the confidence floor (see
    [configuration](docs/configuration.md)). A hand-edit to code always plans a
    lap. Only a confident non-`edit` verdict skips the replan — a note whose
@@ -584,24 +588,28 @@ the agent may overturn the answer. See
 for its `ui:` settings.
 
 The bundled workflows are named `feature` (the ordinary start above), `review`
-and `fix`. They are independent: `review` and `fix` never plan, and they meet
-only in `.gtd/REVIEW.md`. Each brings its own door. This command:
+and `fix`. `review` and `fix` never plan. Each brings its own door. This
+command:
 
 ```bash
 gtd door review <commitish>
 ```
 
-starts a pure review of everything from `<commitish>` to HEAD. It goes straight
-to the quality lap and a review, with no planning and no building; unlike
-`feature`, its lap fixes every finding and a reviewer turn
-(`build.review.reviewing`) writes `.gtd/REVIEW.md`, risks and all. Sign off and
-it closes. Leave notes and the process ends with `.gtd/REVIEW.md` (and the
-reviewer's original, `.gtd/REVIEW.orig.md`) left for `gtd door fix`. Until `fix`
-consumes them, starting `feature` or `review` is refused; remove both files to
-abandon the hand-off. `gtd door fix` fixes those notes and every `Risk:` in one
-turn, then asks for your review of the fix. With no review waiting, it repairs a
-red baseline as its own reviewed commit instead. `gtd doors` lists the doors of
-the workflows your `gtd.config.ts` exports, plus any it adds.
+starts a review of everything from `<commitish>` to HEAD — the same review a
+`feature` process ends with, minus planning and building. A green gate, then the
+quality lenses: mechanical findings are fixed, noise is dropped, and the rest
+become notes in `.gtd/REVIEW.md`, one tick box each. Tick `fix as suggested` or
+write your own answer and the process fixes it in place — your own answers that
+ask for a change are collected into `.gtd/REQUIREMENTS.md` and built by one
+`feedback.fixing` turn, with no design phase and no criteria — under the health
+loop, then asks for your review again. Sign off (or tick `won't fix`) and it
+closes; nothing is left behind. A note asking for new behaviour belongs in a
+`feature` process: tick `won't fix` and start one. `gtd door fix` repairs a red
+baseline as its own reviewed commit; a note at its review is left in
+`.gtd/REVIEW.md` (beside the reviewer's original, `.gtd/REVIEW.orig.md`) for the
+next `gtd door fix`, and until that runs, starting `feature` or `review` is
+refused — remove both files to abandon the hand-off. `gtd doors` lists the doors
+of the workflows your `gtd.config.ts` exports, plus any it adds.
 `gtd --workflow <name>` starts any workflow by name.
 
 The workflow itself is a plain async TypeScript function, and the
@@ -740,6 +748,7 @@ full trail with `gtd history fetch | sh`, then `gtd history show <ref>`.
 gtd history list                 # one line per kept process
 gtd history show <ref>           # replay its steps, judge verdicts and approvals
 gtd history metrics [ref...]     # how the kept processes went, per process and in total
+gtd history judges [ref...]      # how often each judge's verdicts were overturned
 gtd history fetch | sh           # pull every kept ref from origin
 ```
 
@@ -772,6 +781,45 @@ process kept from that branch. A rate is `null` without a decided slice. Each
 process names its `workflow` (`null` for the default one); the total spans every
 ref measured, so name the refs to leave another workflow's processes out.
 
+`gtd history judges` calibrates three of the bundled `feature` workflow's judges
+from the `Gtd-Judge` verdicts the kept refs recorded. It never replays and asks
+no model. A verdict is **overturned** when later history contradicts it:
+
+- **retry** (`health.judge`) — an `identical` verdict, when the next fix turn's
+  check went green anyway (no outcome when a person edited code in between)
+- **triage** (`quality.triage`) — a `mechanical` or `noise` verdict the review
+  listed under _Fixed automatically_ or _Dropped as noise_, when the human
+  edited that finding's line there or wrote under it
+- **clear** (`design.clear`) — a `yes` that skipped design (landed on
+  `design.normalise`), when a later human design step in the same process
+  changed the acceptance criteria
+
+Any other verdict has no outcome. The report counts verdicts, scored verdicts
+and overturns per judge and per `p` bucket (`0.8-0.9: 1/2` — one of two
+overturned). `--var <threshold>=<value>` re-decides every past verdict under
+another threshold and prints the decisions that would change, against the
+threshold each process recorded (a process that recorded none is left out):
+
+```sh
+gtd history judges --var qualityTriageMinP=0.9
+# what-if qualityTriageMinP=0.9: 7 noise drops become notes (2 overturned)
+```
+
+The thresholds are `judgeIdenticalMinP` (retry) and `qualityTriageMinP`
+(triage). The judge's evidence-budget cut is not recorded, so a cut verdict is
+scored and re-decides as if it was whole. A retry verdict on an empty report is
+not scored, as the flow drops it. `--json` prints
+`{ processes, total, whatIf }`, each process and the total with its `judges`.
+`--jsonl` prints one line per verdict instead — `process`, `judge`, `commit`,
+`step`, `question`, `state` (the evidence the tree still shows: the finding, the
+two check reports, the sketch without its numbered criteria), `answer`, `p` and
+`outcome` (`overturned`, `held` or `null`) — ready to fine-tune a local model
+on:
+
+```sh
+gtd history judges --jsonl > judges.jsonl
+```
+
 `gtd history fetch` only prints a fetch script; pipe it into `sh` to run it.
 Beyond that one ship push, refs are not pushed or fetched by default. The ref
 holds every step commit, including steering files and code a later step removed,
@@ -828,8 +876,8 @@ install for any of these but `./testkit`: gtd resolves a `gtd.config.ts`'s
 The `gtd` bin's commands — `next`, `land`, `abandon`, `restore`, `validate`,
 `check`, `uncheck`, `install`, `summary`, `base`, `door`, `doors`, `slices`,
 `version`, `help`, `history list`, `history show`, `history metrics`,
-`history fetch`, `strays`, and the tools `ui`, `lsp`, `loop`, `context-hook`,
-`judge` (`judge answer`, `judge run`) — are listed in the
+`history judges`, `history fetch`, `strays`, and the tools `ui`, `lsp`, `loop`,
+`context-hook`, `judge` (`judge answer`, `judge run`) — are listed in the
 [CLI reference](https://github.com/pmelab/gtd/blob/main/docs/cli.md).
 `gtd slices` lists the spans a flow's `slice()` calls mark. It refuses (exit 1)
 when HEAD neither closes nor sits inside a process, or when today's config

package/claude/hooks/sketch.ts

@@ -1,5 +1,5 @@
 // New requirements go above what the steering file already holds, untouched:
-// a deferred review note the start diff alters reads as the human's edit.
+// anything already there that the start diff alters reads as the human's edit.
 export function withRequirements(existing: string, requirements: string): string {
   const head = `${requirements.trimEnd()}\n`
   return existing.trim() ? `${head}\n${existing}` : head

package/dist/chunks/{reserved-D7MNY9QJ.mjs → reserved-DJk_6-ju.mjs}

@@ -1,4 +1,5 @@
 import { accessFor, agent, answered, changesSince, check, codeThreads, defineWorkflow, displayPath, env, head, human, judge, mark, numeric, quote, read, refuse, scope, skillsFor, start, vars } from "../flows.mjs";
+import { d as ANSWER_FIX, f as ANSWER_LEAD, p as ANSWER_WONT_FIX, v as FREE_TEXT_PLACEHOLDER } from "./steering-D4LUQ-av.mjs";
 import { escalation as escalation$1, gate as gate$1, healthy as healthy$1, lensScopes, lensesOf, removedAssertions } from "../workflow-kit.mjs";
 import { c as String$, g as standardSchemaV1, h as optionalWith, l as Struct, n as Boolean$, s as Number$ } from "./Schema-C6fLlQzx.mjs";
 //#region src/workflows/shared/registry.ts
@@ -437,9 +438,9 @@ const SUMMARY_TITLES = [
 const unboxed = (body) => body.replace(/^(\s*(?:>\s*)*(?:[-*+]|\d+[.)])\s+)\[[ xX]\]\s?/gm, "$1");
 const short = (hash) => hash.slice(0, 7);
 /**
-* \`.gtd/REVIEW.md\` as gtd writes it: one chunk per note, then the fixed and
-* noise lists, with no tick boxes. Chunk titles are made unique — notes are
-* matched to their chunk by title.
+* \`.gtd/REVIEW.md\` as gtd writes it: one chunk per note, each ending in its
+* answer boxes, then the fixed and noise lists. Chunk titles are made unique —
+* notes and answers are matched to their chunk by title.
 */
 const composedReview = (base, report) => {
 	const used = new Set(SUMMARY_TITLES);
@@ -450,11 +451,16 @@ const composedReview = (base, report) => {
 		return name;
 	};
 	const chunk = (title, body) => `## ${title}\n\n${body.trim()}`;
+	const answerBoxes = `${ANSWER_LEAD}\n\n- [ ] ${ANSWER_FIX}\n- [ ] ${ANSWER_WONT_FIX}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`;
+	const notes = report.notes.map((n) => ({
+		...n,
+		title: unique(n.title)
+	})).filter((n) => report.answered?.has(n.title) !== true);
 	const weakened = (report.weakened ?? []).flatMap(({ path, lines }) => lines.map((a) => `- ${path} — ${a.scenario} — ${a.line}`));
 	const chunks = [
-		...report.nitFix === void 0 ? [] : [chunk("Fixed from your notes", `Your nits were fixed in ${short(report.nitFix)}; the list below is from before.`)],
+		...report.nitFix === void 0 ? [] : [chunk("Fixed from your notes", `Your nits and fix-as-suggested notes were worked on in ${short(report.nitFix)}; the notes you answered are left out — check the diff.`)],
 		...weakened.length === 0 ? [] : [chunk("Weakened scenarios", `These scenarios lost an assertion the review base had:\n\n${weakened.join("\n")}`)],
-		...report.notes.map((n) => chunk(unique(n.title), n.unresolved === true ? `_The fixer left this unresolved._\n\n${unboxed(n.body)}` : n.unclear === true ? `_A fix turn removed this while renaming another finding — check whether it was fixed._\n\n${unboxed(n.body)}` : unboxed(n.body) || "_No detail given._")),
+		...notes.map((n) => chunk(n.title, `${n.unresolved === true ? `_The fixer left this unresolved._\n\n${unboxed(n.body)}` : n.unclear === true ? `_A fix turn removed this while renaming another finding — check whether it was fixed._\n\n${unboxed(n.body)}` : unboxed(n.body) || "_No detail given._"}\n\n${answerBoxes}`)),
 		...report.fixed.length === 0 ? [] : [chunk("Fixed automatically", report.fixed.map((f) => `- ${f.title} (${short(f.commit)})`).join("\n"))],
 		...report.noise.length === 0 ? [] : [chunk("Dropped as noise", report.noise.map((f) => `- ${f.title} (p=${f.p})`).join("\n"))]
 	];
@@ -537,10 +543,6 @@ ${stateFileRules}
 ${footnoteFoldIn}${codeThreadReplies()}
 - The only state file this turn touches is \`.gtd/REQUIREMENTS.md\`
   — no other files for notes or output
-- Lines of a \`## Deferred review notes\` section of \`.gtd/TODO.md\`
-  that the start diff does not touch are parked by review, never folded;
-  the human's edits to such a line (or its removal) are input like any
-  other part of the start diff
 - \`.gtd/TODO.md\` is the likely home of the sketch that started
   this process — the human's input, folded into the concerns
   below like any other part of the start diff; never a state
@@ -833,8 +835,12 @@ const buildReviewAwaitReviewMessage = (base) => `\`.gtd/REVIEW.md\` holds what t
 per finding that needs your judgement — it questions a criterion or the
 approach, or the fixer could not resolve it — then, for reference only, what
 was **fixed automatically** (with the fixing commit) and what was **dropped
-as noise**. Nothing there needs an answer; disagreeing with a fix or a drop
-means writing a note of your own.
+as noise**. Each finding chunk ends in three boxes — tick exactly one:
+\`fix as suggested\` (fixed in the nit batch below), \`won't fix\` (dropped,
+recorded in the commit), or write your own answer over \`_your answer_\` and
+tick it (judged like a note). Every landing here is refused until each
+finding holds exactly one tick. The fixed and noise lists need no answer;
+disagreeing with a fix or a drop means writing a note of your own.
 
 Review the diff yourself, with whatever tool you like — gtd checks
 nothing out and touches no ref; \`gtd base\` prints this same hash any
@@ -844,8 +850,8 @@ working tree:
     git diff ${base}
 When you've been through the whole diff, run \`gtd land\`:
 
-- **Sign off** — leave no comment — no note in
-  \`.gtd/REVIEW.md\`, no code edit — to close the process.
+- **Sign off** — answer every finding, leave no other comment — no note
+  in \`.gtd/REVIEW.md\`, no code edit — to close the process.
   Every turn commit stays on the
   branch; run \`gtd summary\` afterward for a closing-message
   prompt.
@@ -972,6 +978,15 @@ ${notes.length === 0 ? "(none)\n" : notesCapture(notes)}
 The reviewer's risks are:
 
 ${risks.length === 0 ? "(none)\n" : notesCapture(risks)}`;
+const reviewFeedbackFixPrompt = () => `${stateFileRules}
+- Read \`.gtd/REQUIREMENTS.md\` — the concerns the human's review asked for,
+  one \`## \` heading each, in build order
+- Build every concern in this one turn; an answered question is context,
+  not a concern
+- Where a change is behavioural, add a test that fails without it
+- Leave \`.gtd/REQUIREMENTS.md\` untouched — the next step removes it
+- Leave everything uncommitted and finish your turn
+`;
 const buildReviewReviewMissingMessage = (commit) => `The review round committed no \`.gtd/REVIEW.md\` (at ${commit}), so there is
 nothing to sign off on.
 
@@ -992,27 +1007,6 @@ const wrapItem = (item) => {
 	} else line = line === "" ? word : `${line} ${word}`;
 	return [...out, line];
 };
-/** Appends one section of `notes` to `.gtd/TODO.md`, wrapped the way oxfmt writes it; an existing file is only ever appended to. */
-const deferNotesScript = (notes, round) => {
-	return `mkdir -p .gtd
-if [ -s .gtd/TODO.md ]; then
-  [ -z "$(tail -c1 .gtd/TODO.md)" ] || printf '\\n' >> .gtd/TODO.md
-  printf '\\n' >> .gtd/TODO.md
-fi
-printf '%s\\n' ${[
-		`## Deferred review notes (${round.slice(0, 7)})`,
-		"",
-		...notes.flatMap((n) => wrapItem(`- ${noteHead(n)}: ${n.text.replace(/\s+/g, " ")}`))
-	].map(quote).join(" ")} >> .gtd/TODO.md
-`;
-};
-/** The gate right after a deferral: landing clean signs off without these notes. */
-const buildReviewAwaitAfterDeferMessage = (base, deferred) => `${buildReviewAwaitReviewMessage(base)}
-Deferred to \`.gtd/TODO.md\` just now, NOT acted on in this process — landing
-clean signs off without them:
-
-${deferred.map((n) => `- ${noteHead(n)}: ${n.text.replace(/\s*\n\s*/g, " ")}`).join("\n")}
-`;
 const buildReviewTriageMessage = () => `Judging each note the human added to \`.gtd/REVIEW.md\` (a line note, a
 footnote, or prose under a chunk) with one verdict: \`edit\` (a change
 request), \`question\`, \`nit\` (a small fix needing no re-plan) or
@@ -1022,16 +1016,18 @@ default; a skipped judgment never dismisses a note).
 
 Also judge each note's severity, one id per note: \`note-<n>.security\`,
 \`note-<n>.reversibility\`, \`note-<n>.blastRadius\` and
-\`note-<n>.newConcept\`.
+\`note-<n>.newConcept\`. An own answer under a finding's boxes is judged
+the same way, keyed \`answer-<n>\`.
 `;
 const closedFold = (round, target) => round === "edits" ? `- Fold every hand-edit and every note the human left that round into
-  \`${target}\`
+  \`${target}\` — a note ticked \`fix as suggested\` or answered in its
+  own words included; one ticked \`won't fix\` is dropped
 ` : round === "notes" ? `- Fold each note that asks for a change into \`${target}\`
 ` : `- Fold each \`edit\` note the capture lists, no other note, and every
   hand-edit, into \`${target}\`
 `;
 /** `refactor` retargets the prompt at `.gtd/REFACTOR.md` and fences it to the strays. A concern outside the fence is not folded; if nothing at all is written the landing is refused, but a partly buildable round drops the rest silently. */
-const buildReviewCollectingPrompt = (capture, refactor) => {
+const buildReviewCollectingPrompt = (capture, refactor, round) => {
 	const target = refactor ? ".gtd/REFACTOR.md" : ".gtd/REQUIREMENTS.md";
 	const fence = refactor ? `- The next refactor may change only these paths, plus an existing test
   file's call sites, and never a flag read:
@@ -1106,12 +1102,16 @@ ${refactor ? refactor.round === "reply" ? `- This turn replies inside \`.gtd/REV
 ${closedFold(refactor.round, target)}` : `- This turn writes \`${target}\` (the folded concerns) and
   replies inside \`.gtd/REVIEW.md\` (thread replies only; the file stays
   in the tree) — you classify, you do not build
-- Fold every concluded thread, ticked answer and hand-edit — and each
-  \`edit\` note the capture lists, no other note — into
-  \`${target}\` and delete the folded threads from
-  \`.gtd/REVIEW.md\`; append one \`- A:\` reply to each thread
-  whose last entry is a \`- H:\` question
-`}- When the capture names an answering commit, carry each answered
+- Fold every concluded thread and hand-edit — and each \`edit\` note
+  the capture lists, no other note — into \`${target}\` and
+  delete the folded threads from \`.gtd/REVIEW.md\`; append one \`- A:\`
+  reply to each thread whose last entry is a \`- H:\` question
+${round === "edits" ? `- A hand-edit round routes no answer box itself: fold each note
+  ticked \`fix as suggested\` or answered in its own words, too; drop one
+  ticked \`won't fix\`
+` : `- Never fold a note's ticked answer box the capture does not list: gtd
+  routes those itself
+`}`}- When the capture names an answering commit, carry each answered
   question into \`${target}\`'s \`## Answered Questions\` as
   \`### <the note>\` plus its answer — the lap replaces \`.gtd/REVIEW.md\`
 - Keep capture order, and carry each note's \`(tier: reason)\`
@@ -1615,6 +1615,36 @@ const awaitReview = (base, message = buildReviewAwaitReviewMessage(base)) => hum
 	base,
 	acceptClean: true
 });
+/** Answer every `question` note inline in `.gtd/REVIEW.md`. */
+const answerReviewQuestions = (notes) => agentWithSkills("review.answer-review-questions", buildReviewAnswerQuestionsPrompt(notes), {
+	label: "Answering your questions",
+	file: REVIEW,
+	mode: "review",
+	model: planner(),
+	system: reviewerSystem()
+});
+/** Fix every `nit` note in one turn. */
+const fixNits = (notes, access, rules) => {
+	const fixing = (name) => agentWithSkills(name, buildReviewFixNitsPrompt(notes, rules), {
+		label: "Fixing your nits",
+		file: REVIEW,
+		model: planner(),
+		system: reviewerSystem()
+	});
+	return access === void 0 ? fixing("review.fix.nits.fixing") : scope({
+		name: "review.fix.nits",
+		access
+	}, () => fixing("fixing"));
+};
+/** Turn the review round `capture` describes into `.gtd/REQUIREMENTS.md`, or change nothing. */
+const collecting = (capture, round) => agentWithSkills("review.collecting", buildReviewCollectingPrompt(capture, void 0, round), {
+	label: "Collecting your feedback",
+	file: REQUIREMENTS,
+	mode: "qa",
+	model: planner(),
+	system: reviewerSystem(),
+	allowEmpty: true
+});
 /** The round at commit `round` left no `.gtd/REVIEW.md`. */
 const reviewMissing = (round) => human("review.review-missing", {
 	message: buildReviewReviewMissingMessage(round),
@@ -1811,6 +1841,7 @@ const skills = (vars) => {
 	return {
 		design: ["spec-driven-development", "planning-and-task-breakdown"],
 		notes: ["incremental-implementation", "code-simplification"],
+		feedback: ["test-driven-development", "incremental-implementation"],
 		...build,
 		...Object.fromEntries(Object.entries(build).map(([name, list]) => [`refactor.${name}`, list])),
 		refactor: ["ponytail"],
@@ -1829,11 +1860,9 @@ const skills = (vars) => {
 const access = (vars) => ({
 	design: { write: [] },
 	"build.review": { write: [".gtd/REVIEW.md"] },
-	"build.review.defer": { write: [".gtd/TODO.md"] },
 	"build.review.fix.nits": {},
 	"build.review.fix.risks": {},
 	"refactor.build.review": { write: [".gtd/REVIEW.md"] },
-	"refactor.build.review.defer": { write: [".gtd/TODO.md"] },
 	...lensScopes("build.quality", lensesOf(vars.qualityReviews ?? ""), () => ({ write: [] })),
 	...lensScopes("refactor.build.quality", lensesOf(vars.refactorQualityReviews ?? ""), () => ({ write: [] }))
 });
@@ -1845,4 +1874,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { implementFixPrompt as $, agentWithSkills as A, registryEntry as At, coverageMessage as B, fixCheck as C, unwindFailure as Ct, reviewMissing as D, flagMentions as Dt, planner as E, testFileGlobs as Et, buildReviewTriageMessage as F, designGateAnswerMessage as G, coveringPrompt as H, builderSystem as I, finisherSystem as J, designSystem as K, clearCriteriaMessage as L, buildReviewAwaitAfterDeferMessage as M, buildReviewCollectingPrompt as N, reviewQuality as O, flagReferences as Ot, buildReviewFixNitsPrompt as P, implementBuildingPrompt as Q, clearCriteriaQuestion as R, coder as S, unwindFailedMessage as St, fixRisks as T, envDefaults as Tt, criterionLine as U, coverageQuestion as V, deferNotesScript as W, handOffAwaitReviewMessage as X, fixReviewNotesPrompt as Y, idleMessage as Z, REFACTOR_NOTE as _, seamByHandMessage as _t, flagModeOn as a, qualityTriageMessage as at, SLICES as b, startGateBlockedMessage as bt, baseline as c, refactorDroppedRefusal as ct, guarded as d, refactorRules as dt, naiveApplyFailure as et, healthy as f, reviewEditNotesCapture as ft, REFACTOR as g, reviewerSystem as gt, QUALITY as h, reviewNotesCapture as ht, skills as i, qualityFindingsFile as it, buildReviewAnswerQuestionsPrompt as j, requireFlag as jt, reviewing as k, flipProblems as kt, escalation as l, refactorFixPrompt as lt, HANDOFF as m, reviewGateBlockedMessage as mt, summary as n, normaliseCriteriaScript as nt, flagShipped as o, qualityUnresolvedMessage as ot, FEEDBACK as p, reviewEditsCapture as pt, designTriagePrompt as q, access as r, oversizedMessage as rt, shipped as s, refactorBuildingPrompt as st, steering as t, naivePassPrompt as tt, gate as u, refactorNotePrompt as ut, REQUIREMENTS as v, seamSteerMessage as vt, fixQuality as w, defaults as wt, awaitReview as x, uncoveredMessage as xt, REVIEW as y, slicingPrompt as yt, composedReview as z };
+export { naiveApplyFailure as $, reviewMissing as A, registryEntry as At, coverageMessage as B, coder as C, unwindFailure as Ct, fixQuality as D, flagMentions as Dt, fixNits as E, testFileGlobs as Et, buildReviewTriageMessage as F, designSystem as G, coveringPrompt as H, builderSystem as I, fixReviewNotesPrompt as J, designTriagePrompt as K, clearCriteriaMessage as L, reviewing as M, agentWithSkills as N, fixRisks as O, flagReferences as Ot, buildReviewCollectingPrompt as P, implementFixPrompt as Q, clearCriteriaQuestion as R, awaitReview as S, unwindFailedMessage as St, fixCheck as T, envDefaults as Tt, criterionLine as U, coverageQuestion as V, designGateAnswerMessage as W, idleMessage as X, handOffAwaitReviewMessage as Y, implementBuildingPrompt as Z, REFACTOR_NOTE as _, seamByHandMessage as _t, flagModeOn as a, qualityUnresolvedMessage as at, SLICES as b, startGateBlockedMessage as bt, baseline as c, refactorFixPrompt as ct, guarded as d, reviewEditNotesCapture as dt, naivePassPrompt as et, healthy as f, reviewEditsCapture as ft, REFACTOR as g, reviewerSystem as gt, QUALITY as h, reviewNotesCapture as ht, skills as i, qualityTriageMessage as it, reviewQuality as j, requireFlag as jt, planner as k, flipProblems as kt, escalation as l, refactorNotePrompt as lt, HANDOFF as m, reviewGateBlockedMessage as mt, summary as n, oversizedMessage as nt, flagShipped as o, refactorBuildingPrompt as ot, FEEDBACK as p, reviewFeedbackFixPrompt as pt, finisherSystem as q, access as r, qualityFindingsFile as rt, shipped as s, refactorDroppedRefusal as st, steering as t, normaliseCriteriaScript as tt, gate as u, refactorRules as ut, REQUIREMENTS as v, seamSteerMessage as vt, collecting as w, defaults as wt, answerReviewQuestions as x, uncoveredMessage as xt, REVIEW as y, slicingPrompt as yt, composedReview as z };