@pmelab/gtd 41.0.0 → 43.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "41.0.0",
+  "version": "43.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
@@ -490,14 +490,22 @@ noted in steps 3 and 4 below.
    `spec-challenge` run on the planner model (`smart`), the other three on the
    coder model (`base`); a `qualityReviews` entry `<lens>=<model>` picks a
    lens's own. Each traces the change from its own angle and records every
-   finding, blocking or not; one fix turn then fixes ALL of them once, with no
-   re-review after the fix. A clean turn means approval only when that lens
-   found nothing at all. This lap is where code quality is looked at, and every
-   round pays for it. It never replaces step 4 — your review stays the final
-   gate, and nothing here skips it. Findings the fix cap leaves in
-   `.gtd/QUALITY.md` rest at `build.quality-unresolved` until you delete or
-   empty the file; the suite then runs on any hand edits before the review. The
-   `fix` door (below) repairs a red baseline through this same lap.
+   finding, blocking or not, as its own `## ` chunk of `.gtd/QUALITY.md`. A
+   clean turn means approval only when that lens found nothing at all. The
+   lenses are the only agentic review: a judge (`build.quality.triage`) then
+   classifies each finding — `mechanical` ones are fixed by the fix turn
+   (`build.fix.quality.fixing`, up to three turns), `noise` is dropped with its
+   `p` recorded as `Gtd-Mark: noise=<id> p=<p> <title>`, and `design` ones
+   (questioning a criterion or the approach) become notes for your review. An
+   unsure verdict (below `qualityTriageMinP`, `0.7`) is `design`; mechanical
+   findings the fix turns leave become notes too. This lap is where code quality
+   is looked at, and every round pays for it. It never replaces step 4 — your
+   review stays the final gate, and nothing here skips it. Between
+   [coarse slices](#coarse-slices) no review follows, so there the fix turn
+   fixes every finding, and those the fix cap leaves rest at
+   `build.quality-unresolved` until you delete or empty `.gtd/QUALITY.md`; the
+   suite then runs on any hand edits before the next slice. The `fix` door
+   (below) repairs a red baseline through the untriaged lap.
 
    A red suite that keeps failing past a few fix attempts escalates instead of
    retrying forever: an agent turn reads the failing output and writes
@@ -512,39 +520,43 @@ noted in steps 3 and 4 below.
    `Gtd-Mark: flaky=<check>` (see
    [Re-check before a person](docs/configuration.md#re-check-before-a-person)).
 
-4. **You review.** After the last slice's quality lap you get a review document
-   over the whole change, listing what changed and what to look at (on
-   `refactor-first` the refactor slice gets one of its own first, before the
-   feature is built; see [the naive pass](#the-naive-pass)). Before you see it,
-   an automatic risk-fix pass (`build.review.fix.risks.fixing`) runs. Any risk
-   the reviewer names (a note opening with `Risk:`) is fixed first, the suite
-   kept green, and the review rewritten — once per review round, so a risk the
-   rewrite still names reaches you unfixed; risk: a fix lands with no check that
-   the risk was real. Tick the boxes to approve, or write what is wrong.
-   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.
+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, 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,14 +596,16 @@ gtd door review <commitish>
 ```
 
 starts a pure review of everything from `<commitish>` to HEAD. It goes straight
-to step 4, with no planning and no building. 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.
+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.
 `gtd --workflow <name>` starts any workflow by name.
 
 The workflow itself is a plain async TypeScript function, and the
@@ -730,6 +744,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
 ```
 
@@ -762,6 +777,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,
@@ -818,8 +872,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-Ch4LLrEj.mjs → reserved-COEMFEpy.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
@@ -130,6 +131,7 @@ const defaults = {
 	judgeIdenticalMinP: "0.7",
 	reviewNoteActionable: "0.7",
 	reviewSeverityMinP: "0.7",
+	qualityTriageMinP: "0.7",
 	refactorFlagPattern: "\\bGTD_FLAG_\\w+",
 	seamAllow: [...testFileGlobs, ".gtd/**"].join(", "),
 	flagMode: "true",
@@ -420,6 +422,51 @@ carries it.
 What each change does next (then run \`gtd land\`):
 - **Continue** — having undone the sketch by hand, check the test baseline is green and start triage (**start-gate.check**).
 `;
+const qualityTriageMessage = () => `Judging each quality finding. Run \`gtd judge answer\` and pipe a
+\`mechanical\`/\`noise\`/\`design\` verdict per finding ID — or land without a
+verdict, which hands every finding to the review as a note.
+`;
+/** \`.gtd/QUALITY.md\` holding only \`findings\`, one \`## \` chunk each. */
+const qualityFindingsFile = (findings) => `# Quality\n\n${findings.map((f) => `## ${f.title}\n\n${f.body}`.trim()).join("\n\n")}\n`;
+const SUMMARY_TITLES = [
+	"Weakened scenarios",
+	"Fixed from your notes",
+	"Fixed automatically",
+	"Dropped as noise",
+	"Nothing to note"
+];
+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, 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);
+	const unique = (title) => {
+		let name = title;
+		for (let n = 2; used.has(name); n++) name = `${title} (${n})`;
+		used.add(name);
+		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 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")}`)],
+		...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"))]
+	];
+	const body = chunks.length > 0 ? chunks : [chunk("Nothing to note", "No quality lens raised anything for you — or none ran. Review the diff yourself.")];
+	return `# Review: ${short(base)}\n\n<!-- base: ${base} -->\n\n${body.join("\n\n")}\n`;
+};
 const qualityUnresolvedMessage = () => `The quality lap's fix turns hit their cap and \`.gtd/QUALITY.md\` still
 holds findings. Nothing after this fixes them, so the process will not
 go on with them open.
@@ -496,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
@@ -728,8 +771,10 @@ const finisherSystem = () => `${finisherPersona}
 ${agentConduct}`;
 const buildFixQualityPrompt = (rules) => `${stateFileRules}
 - Read \`.gtd/QUALITY.md\` — one \`## \` chunk per finding a quality
-  dimension wrote. Merge duplicate findings across dimensions
-  FIRST, then fix every finding in every chunk, blocking or not
+  dimension wrote. Fix every finding in every chunk, blocking or not;
+  where dimensions repeat one, fix the shared cause once
+- Delete each finding's \`## \` chunk once it is resolved; never
+  rename, merge or reword a chunk you leave
 - When findings conflict, missing test signal beats line count —
   a test is never deleted to satisfy a simplification finding
 - Delete \`.gtd/QUALITY.md\` once every finding is resolved
@@ -772,9 +817,9 @@ const buildQualityReviewingPrompt = (lens, brief, base = start()) => `${stateFil
   behaviour removed — decide that by reasoning, never by running a
   mutation-testing tool. A test that pins a bug is a finding, not
   praise
-- APPEND every finding you have, blocking or not, as a \`## \`
-  chunk to \`.gtd/QUALITY.md\` — never overwrite what an earlier
-  dimension already wrote there
+- APPEND every finding you have, blocking or not, as its own
+  \`## <one-line title>\` chunk to \`.gtd/QUALITY.md\` — one finding per
+  chunk, never overwrite what an earlier dimension already wrote there
 - Write nothing only when this lens found nothing at all — then a
   clean turn IS this dimension's approval
 ${brief ? `
@@ -786,12 +831,16 @@ ${brief}
 const reviewerSystem = () => `${reviewerPersona}
 
 ${agentConduct}`;
-const buildReviewAwaitReviewMessage = (base) => `\`.gtd/REVIEW.md\` holds the review record for the process — one
-\`- [ ]\` checkbox per reviewable item, grouped into chunks. Tick a box
-(\`- [x]\`) as you review each hunk; ticking only records that you've read
-it, it is not sign-off. Ticks are read-progress only: landing clears
-every box back to \`- [ ]\` on disk and nothing records which hunks
-you read — there is no persisted trail of it.
+const buildReviewAwaitReviewMessage = (base) => `\`.gtd/REVIEW.md\` holds what the quality lenses left for you: one chunk
+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**. 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
@@ -801,9 +850,9 @@ 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,
-  whatever the boxes say. Every turn commit stays on the
+- **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.
 - **Ask a question** — start a thread (\`- H: <question>\`) on a
@@ -949,27 +998,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
@@ -979,16 +1007,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:
@@ -1063,12 +1093,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)\`
@@ -1691,6 +1725,7 @@ const ShippedOptions = Struct({
 	judgeIdenticalMinP: setting,
 	reviewNoteActionable: setting,
 	reviewSeverityMinP: setting,
+	qualityTriageMinP: setting,
 	refactorFlagPattern: setting,
 	seamAllow: setting,
 	sliceMaxCriteria: setting,
@@ -1785,11 +1820,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: [] }))
 });
@@ -1801,4 +1834,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { naiveApplyFailure as $, agentWithSkills as A, coverageQuestion as B, fixCheck as C, testFileGlobs as Ct, reviewMissing as D, registryEntry as Dt, planner as E, flipProblems as Et, buildReviewTriageMessage as F, designSystem as G, criterionLine as H, builderSystem as I, fixReviewNotesPrompt as J, designTriagePrompt as K, clearCriteriaMessage as L, buildReviewAwaitAfterDeferMessage as M, buildReviewCollectingPrompt as N, reviewQuality as O, requireFlag as Ot, buildReviewFixNitsPrompt as P, implementFixPrompt as Q, clearCriteriaQuestion as R, coder as S, envDefaults as St, fixRisks as T, flagReferences as Tt, deferNotesScript as U, coveringPrompt as V, designGateAnswerMessage as W, idleMessage as X, handOffAwaitReviewMessage as Y, implementBuildingPrompt as Z, REFACTOR_NOTE as _, startGateBlockedMessage as _t, flagModeOn as a, refactorDroppedRefusal as at, SLICES as b, unwindFailure as bt, baseline as c, refactorRules as ct, guarded as d, reviewGateBlockedMessage as dt, naivePassPrompt as et, healthy as f, reviewNotesCapture as ft, REFACTOR as g, slicingPrompt as gt, QUALITY as h, seamSteerMessage as ht, skills as i, refactorBuildingPrompt as it, buildReviewAnswerQuestionsPrompt as j, reviewing as k, escalation as l, reviewEditNotesCapture as lt, HANDOFF as m, seamByHandMessage as mt, summary as n, oversizedMessage as nt, flagShipped as o, refactorFixPrompt as ot, FEEDBACK as p, reviewerSystem as pt, finisherSystem as q, access as r, qualityUnresolvedMessage as rt, shipped as s, refactorNotePrompt as st, steering as t, normaliseCriteriaScript as tt, gate as u, reviewEditsCapture as ut, REQUIREMENTS as v, uncoveredMessage as vt, fixQuality as w, flagMentions as wt, awaitReview as x, defaults as xt, REVIEW as y, unwindFailedMessage as yt, coverageMessage as z };
+export { naivePassPrompt as $, agentWithSkills as A, coverageQuestion as B, fixCheck as C, envDefaults as Ct, reviewMissing as D, flipProblems as Dt, planner as E, flagReferences as Et, builderSystem as F, designTriagePrompt as G, criterionLine as H, clearCriteriaMessage as I, handOffAwaitReviewMessage as J, finisherSystem as K, clearCriteriaQuestion as L, buildReviewCollectingPrompt as M, buildReviewFixNitsPrompt as N, reviewQuality as O, registryEntry as Ot, buildReviewTriageMessage as P, naiveApplyFailure as Q, composedReview as R, coder as S, defaults as St, fixRisks as T, flagMentions as Tt, designGateAnswerMessage as U, coveringPrompt as V, designSystem as W, implementBuildingPrompt as X, idleMessage as Y, implementFixPrompt as Z, REFACTOR_NOTE as _, slicingPrompt as _t, flagModeOn as a, refactorBuildingPrompt as at, SLICES as b, unwindFailedMessage as bt, baseline as c, refactorNotePrompt as ct, guarded as d, reviewEditsCapture as dt, normaliseCriteriaScript as et, healthy as f, reviewGateBlockedMessage as ft, REFACTOR as g, seamSteerMessage as gt, QUALITY as h, seamByHandMessage as ht, skills as i, qualityUnresolvedMessage as it, buildReviewAnswerQuestionsPrompt as j, reviewing as k, requireFlag as kt, escalation as l, refactorRules as lt, HANDOFF as m, reviewerSystem as mt, summary as n, qualityFindingsFile as nt, flagShipped as o, refactorDroppedRefusal as ot, FEEDBACK as p, reviewNotesCapture as pt, fixReviewNotesPrompt as q, access as r, qualityTriageMessage as rt, shipped as s, refactorFixPrompt as st, steering as t, oversizedMessage as tt, gate as u, reviewEditNotesCapture as ut, REQUIREMENTS as v, startGateBlockedMessage as vt, fixQuality as w, testFileGlobs as wt, awaitReview as x, unwindFailure as xt, REVIEW as y, uncoveredMessage as yt, coverageMessage as z };