@pmelab/gtd 42.0.0 → 43.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "42.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
@@ -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
@@ -740,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
 ```
 
@@ -772,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,
@@ -828,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-D7MNY9QJ.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
@@ -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.
@@ -992,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
@@ -1022,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:
@@ -1106,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)\`
@@ -1829,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: [] }))
 });
@@ -1845,4 +1834,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 { 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 };

package/dist/chunks/{steering-oCDdQlpP.mjs → steering-D4LUQ-av.mjs}

@@ -13349,8 +13349,8 @@ const eolOf = (content) => content.includes("\r\n") ? "\r\n" : "\n";
 const PREFIX_RE$1 = /^(H|A):\s*/;
 const lineOf = (node, which) => toLspPosition(node.position[which]).line;
 /** The item's own blocks joined — never the item node's span, which can run past its last line into the next bullet's marker. */
-const itemText = (content, item) => item.children.map((child) => sourceText(content, child)).join(" ").trim();
-const prefixOf = (content, item) => PREFIX_RE$1.exec(itemText(content, item));
+const itemText$1 = (content, item) => item.children.map((child) => sourceText(content, child)).join(" ").trim();
+const prefixOf = (content, item) => PREFIX_RE$1.exec(itemText$1(content, item));
 /** A thread is a definition whose body OPENS with a list whose first item carries a prefix — anything else stays a one-shot footnote. */
 const isThreadBody = (content, children) => {
 	const first = children[0];
@@ -13370,7 +13370,7 @@ const entryOf = (content, item, previous, report) => {
 		return;
 	}
 	const author = match[1] === "H" ? "me" : "agent";
-	const text = itemText(content, item).slice(match[0].length).trim();
+	const text = itemText$1(content, item).slice(match[0].length).trim();
 	if (text === "") report(`empty "${match[1]}:" entry — write your own words there`, start, end);
 	if (previous === void 0 && author === "agent") report(`the agent never starts a thread — the first entry must be "H:"`, start, end);
 	else if (previous === author) report(`two consecutive "${match[1]}:" entries — entries must alternate`, start, end);
@@ -15086,6 +15086,9 @@ const qaDescriptor = {
 };
 //#endregion
 //#region src/steering/review.ts
+const ANSWER_LEAD = "Tick exactly one:";
+const ANSWER_FIX = "fix as suggested";
+const ANSWER_WONT_FIX = "won't fix";
 /**
 * The canonical sample. Every detail here is load-bearing for the formatter
 * round-trip: both footnote bodies exceed 80 characters so a reflow actually
@@ -15352,16 +15355,42 @@ const parseHunk = (content, lines, title, item) => {
 		errors: [hunkSecondPointerFinding(content, lines, item, token, sourceLine, title, file), hunkLineWithoutRangeFinding(content, item, token, sourceLine, title, file)].filter((e) => e !== void 0)
 	};
 };
+const itemText = (content, item) => item.children.map((c) => sourceText(content, c)).join(" ").replace(/^\[[ xX]\]\s*/, "").trim();
+/**
+* The task list right after the `Tick exactly one:` paragraph, with that
+* paragraph's index. Read by position, never by label, so an edited label or
+* a free text opening with `./path` is still an answer, not a pointer. Any
+* count but three boxes is kept, and reads as unanswered.
+*/
+const answerListOf = (content, body) => {
+	const lead = body.findIndex((n, i) => n.type === "paragraph" && sourceText(content, n) === "Tick exactly one:" && body[i + 1]?.type === "list" && body[i + 1].children.every((item) => item.checked != null));
+	if (lead === -1) return void 0;
+	const list = body[lead + 1];
+	const last = list.children.length - 1;
+	return {
+		lead,
+		list,
+		options: list.children.map((item, i) => {
+			const text = itemText(content, item);
+			return {
+				checked: item.checked === true,
+				text: i === last && text.toLowerCase() === "_your answer_".toLowerCase() ? "" : text
+			};
+		})
+	};
+};
 /** Splits one chunk's body nodes into its file pointers (hunk pointers are task items, collected recursively at ANY nesting depth via `taskItems` — a nested hunk is the same kind of hunk as a top-level one) and description prose. The description is the chunk's own leading run and never a node that contains a hunk pointer: it stops at the first node whose `taskItems` include a real pointer (at any depth — a blockquote wrapping a pointer list stops it just as a top-level list would). Every node kind in what's left before that point contributes — a `footnoteDefinition` is the one exception, excluded by `blockNodesOfRun` itself (it's a note, never document content). */
 const parseChunkBody = (content, lines, title, body) => {
-	const firstPointerIndex = body.findIndex((n) => taskItems(n).some((item) => hasPointerToken(content, item)));
-	const leadingRun = firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex);
+	const answer = answerListOf(content, body);
+	const isAnswer = (n) => answer !== void 0 && (n === answer.list || n === body[answer.lead]);
+	const firstPointerIndex = body.findIndex((n) => !isAnswer(n) && taskItems(n).some((item) => hasPointerToken(content, item)));
+	const leadingRun = (firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex)).filter((n) => !isAnswer(n));
 	const descriptionNodes = blockNodesOfRun(content, leadingRun);
 	const descriptionInline = collapseImages(blockRunInline(content, leadingRun));
 	const description = leadingRun.filter((n) => n.type !== "footnoteDefinition").map((n) => sourceText(content, n)).join(" ").trim();
 	const files = [];
 	const errors = [];
-	for (const item of body.flatMap((n) => taskItems(n))) {
+	for (const item of body.filter((n) => !isAnswer(n)).flatMap((n) => taskItems(n))) {
 		const parsed = parseHunk(content, lines, title, item);
 		if (!parsed) continue;
 		files.push(parsed.file);
@@ -15372,7 +15401,9 @@ const parseChunkBody = (content, lines, title, body) => {
 		descriptionNodes,
 		descriptionInline,
 		files,
-		errors
+		errors,
+		...answer === void 0 ? {} : { answers: answer.options },
+		boxed: body.some((n) => !isAnswer(n) && taskItems(n).length > 0)
 	};
 };
 /** Splits the tree's top-level nodes into consecutive `##` chunk blocks — a `## ` line found only inside a fence never becomes a heading node at all, so it's never mistaken for a chunk. */
@@ -15408,9 +15439,9 @@ const parseChangesets = (tree, content, lines) => {
 	const errors = [];
 	for (const { heading, headingLine, body } of splitChunks(tree)) {
 		const title = headingText$1(content, heading);
-		const { description, descriptionNodes, descriptionInline, files, errors: bodyErrors } = parseChunkBody(content, lines, title, body);
+		const { description, descriptionNodes, descriptionInline, files, answers, boxed, errors: bodyErrors } = parseChunkBody(content, lines, title, body);
 		errors.push(...bodyErrors);
-		if (files.length === 0 && body.some((n) => taskItems(n).length > 0)) errors.push({
+		if (files.length === 0 && boxed) errors.push({
 			message: `Chunk "${title}" has no file pointers`,
 			line: headingLine,
 			range: nodeRange(heading)
@@ -15421,7 +15452,8 @@ const parseChangesets = (tree, content, lines) => {
 			descriptionNodes,
 			descriptionInline,
 			files,
-			headingLine
+			headingLine,
+			...answers === void 0 ? {} : { answers }
 		});
 	}
 	if (changesets.length === 0) errors.push({ message: "REVIEW.md has no '##' chunks" });
@@ -15502,7 +15534,9 @@ const isHunkPointerItem = (content, item) => {
 * clear, so a caller can skip the write and leave the mtime untouched.
 */
 const reviewClearTicks = (content) => {
-	const offsets = taskItems(parseMarkdown(content)).filter((item) => item.checked === true && isHunkPointerItem(content, item)).map((item) => checkboxOffset(content, item)).filter((o) => o !== void 0).sort((a, b) => a - b);
+	const tree = parseMarkdown(content);
+	const answers = new Set(splitChunks(tree).flatMap(({ body }) => answerListOf(content, body)?.list.children ?? []));
+	const offsets = taskItems(tree).filter((item) => item.checked === true && !answers.has(item) && isHunkPointerItem(content, item)).map((item) => checkboxOffset(content, item)).filter((o) => o !== void 0).sort((a, b) => a - b);
 	if (offsets.length === 0) return content;
 	let result = "";
 	let cursor = 0;
@@ -15936,6 +15970,55 @@ const reviewRisks = (content) => parseReviewDoc(content).changesets.flatMap((chu
 	id: `risk-${i + 1}`,
 	...r
 }));
+const CHOICES = [
+	"fix",
+	"wontfix",
+	"answer"
+];
+const decisionOf = (chunk) => {
+	if (chunk.answers?.length !== 3) return void 0;
+	const ticked = chunk.answers.flatMap((o, i) => o.checked ? [i] : []);
+	if (ticked.length !== 1) return void 0;
+	const i = ticked[0];
+	const text = i === 2 ? chunk.answers[2].text : "";
+	if (i === 2 && text === "") return void 0;
+	return {
+		anchor: chunk.title,
+		body: chunk.description,
+		choice: CHOICES[i],
+		text
+	};
+};
+/**
+* Notes whose answer boxes do not hold exactly one tick (a ticked free-text
+* slot filled in), with their 1-based heading line and why; and, given the
+* file `before` the edit, every note whose boxes were deleted.
+*/
+const unansweredNotes = (content, before) => {
+	const now = parseReviewDoc(content).changesets;
+	const boxed = new Set(now.filter((c) => c.answers !== void 0).map((c) => c.title));
+	const removed = (before === void 0 ? [] : parseReviewDoc(before).changesets).filter((c) => c.answers !== void 0 && !boxed.has(c.title)).map((c) => ({
+		title: c.title,
+		line: 0,
+		reason: "its answer boxes were deleted — restore them"
+	}));
+	return [...now.filter((c) => c.answers !== void 0 && decisionOf(c) === void 0).map((c) => ({
+		title: c.title,
+		line: c.headingLine + 1,
+		reason: c.answers.length === 3 ? "tick exactly one box" : `it has ${c.answers.length} boxes — restore the three gtd wrote`
+	})), ...removed];
+};
+/** Every answer in `after` that `before` did not already hold for the same note, in document order. */
+const reviewDecisions = (before, after) => {
+	const prior = new Map(parseReviewDoc(before).changesets.map((c) => [c.title, c]));
+	return parseReviewDoc(after).changesets.flatMap((chunk) => {
+		const decision = decisionOf(chunk);
+		if (decision === void 0) return [];
+		const was = prior.get(chunk.title);
+		const old = was === void 0 ? void 0 : decisionOf(was);
+		return old?.choice === decision.choice && old.text === decision.text ? [] : [decision];
+	});
+};
 //#endregion
 //#region src/steering/Edits.ts
 /** Splices `edits` into `content`, sorted last-to-first so an earlier range's offset is never invalidated by a later edit. Positions are 0-based line/character over `\n`-split lines. */
@@ -16304,4 +16387,4 @@ const viewOf = (format, content) => ({
 /** Every OPEN thread — last entry is the agent's — as `{ name, line, firstMe }` (0-based line). `[]` for a format with no thread concept. */
 const openThreads = (format, content) => format.openThreads?.(content) ?? [];
 //#endregion
-export { headingSections as C, headingSectionBodies as S, openThreadFindings as _, unansweredQuestions as a, parseThreadsWithFindings as b, stripCodeThreads as c, reviewNotes as d, reviewRisks as f, THREAD_REPLY_ACTION_TITLE as g, FOOTNOTE_ACTION_TITLE as h, steeringFormatOrFreeForm as i, freeFormFormat as l, isAnswered as m, openThreads as n, viewOf as o, FREE_TEXT_PLACEHOLDER as p, steeringFormatFor as r, parseCodeThreads as s, BUILT_IN_MODE_NAMES as t, applySteeringEdits as u, parseFootnotes as v, formatFinding as w, getParseCount as x, parseThreads as y };
+export { parseFootnotes as C, headingSectionBodies as D, getParseCount as E, headingSections as O, openThreadFindings as S, parseThreadsWithFindings as T, unansweredNotes as _, unansweredQuestions as a, FOOTNOTE_ACTION_TITLE as b, stripCodeThreads as c, ANSWER_FIX as d, ANSWER_LEAD as f, reviewRisks as g, reviewNotes as h, steeringFormatOrFreeForm as i, formatFinding as k, freeFormFormat as l, reviewDecisions as m, openThreads as n, viewOf as o, ANSWER_WONT_FIX as p, steeringFormatFor as r, parseCodeThreads as s, BUILT_IN_MODE_NAMES as t, applySteeringEdits as u, FREE_TEXT_PLACEHOLDER as v, parseThreads as w, THREAD_REPLY_ACTION_TITLE as x, isAnswered as y };

package/dist/chunks/{tail-D2o2h5cc.mjs → tail-C_xn8U7U.mjs}

@@ -1,6 +1,6 @@
 import { answered, head, judge, mark, numeric, read, refuse, removeScript, run, scope, sectionBodies, showScript, vars, writeScript } from "../flows.mjs";
 import { fixFindings, lensEntriesOf, lensOf, qualityLap as qualityLap$1, reviewToHandOff } from "../workflow-kit.mjs";
-import { C as fixCheck, D as reviewMissing, O as reviewQuality, T as fixRisks, X as handOffAwaitReviewMessage, at as qualityTriageMessage, d as guarded, f as healthy, h as QUALITY, it as qualityFindingsFile, k as reviewing, l as escalation, w as fixQuality, x as awaitReview, y as REVIEW } from "./reserved-D7MNY9QJ.mjs";
+import { C as fixCheck, D as reviewMissing, J as handOffAwaitReviewMessage, O as reviewQuality, T as fixRisks, d as guarded, f as healthy, h as QUALITY, k as reviewing, l as escalation, nt as qualityFindingsFile, rt as qualityTriageMessage, w as fixQuality, x as awaitReview, y as REVIEW } from "./reserved-COEMFEpy.mjs";
 //#region src/workflows/shared/lenses.ts
 const NO_FINDINGS = {
 	notes: [],