@pmelab/gtd 24.3.0 → 25.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "24.3.0",
+  "version": "25.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

@@ -44,12 +44,6 @@ the read side to its agent. `read` is not a security boundary unless your driver
 enforces it at the OS level. See
 [Configuration](https://github.com/pmelab/gtd/blob/main/docs/configuration.md#file-access).
 
-> **`fastTestCommand` is required, with no fallback to `testCommand`.** Set it
-> (everything but e2e) as a workflow option in `gtd.config.ts`
-> (`feature({ fastTestCommand: "npm run test:fast" })`) or as
-> `GTD_FASTTESTCOMMAND`; gtd stops at the start gate, writing `.gtd/SETUP.md`,
-> until it is.
-
 > **A repository's `gtd.config.ts` is code, and gtd runs it.** A custom workflow
 > is a TypeScript module, and every gtd command that looks at workflow state —
 > `gtd next`, `gtd lsp`, `gtd door` and `gtd doors` included, not just
@@ -400,20 +394,21 @@ noted in steps 3 and 4 below.
    questions and all. Every plan gets the technical pass: its document has four
    sections, in order — `## Interfaces`, `## Call Stacks`, `## E2E Scenarios`,
    `## Unit Tests` — behind a leading `## Open Questions` when there are any.
-   `## E2E Scenarios` is never empty: it holds the scenarios, or, when nothing
+   `## E2E Scenarios` is never empty: it names each user-visible behaviour in
+   plain words (the builder writes the scenario itself), or, when nothing
    user-visible changes, the line `No e2e change.` with a one-line reason.
 
-3. **You wait.** The work is split into packages and built one at a time, each
-   one starting from the unit tests it declares (a build turn missing one is
-   refused), checked against the fast suite and fixed until it passes before
-   moving on. A package that rewords a frozen `.feature` step stops at a wording
-   gate: accept the change, or reject it and the original is restored. After the
-   last package a full run (e2e included) has its own fix loop before the
-   quality lap. Two points along the process are judged rather than always
-   asking you outright — each stops and hands you a verdict to make
-   (`gtd judge answer`, or land with a clean tree to accept the conservative
-   default, which never skips work;
-   `gtd judge run --provider fixed --answers <path>` — or the
+3. **You wait.** The work is split into vertical slices and built one at a time,
+   each one starting from the unit and e2e tests it declares (a build turn
+   missing one is refused), checked against the full suite (`testCommand`) and
+   fixed until it passes before moving on — so keep that suite fast; gtd has no
+   lighter one. Scenario wording is not frozen: you sign the scenarios off once,
+   in the review's `## Scenarios` chunk, where any assertion an existing
+   scenario lost is marked `Weakened:`. After the last package the quality lap
+   runs. Two points along the process are judged rather than always asking you
+   outright — each stops and hands you a verdict to make (`gtd judge answer`, or
+   land with a clean tree to accept the conservative default, which never skips
+   work; `gtd judge run --provider fixed --answers <path>` — or the
    `GTD_JUDGE_ANSWERS` env var, inline JSON — answers one from a file, piped
    between `gtd judge --json` and `gtd judge answer`;
    `gtd judge run --provider jev` asks TypeSafe's Jev instead, with the key in
@@ -475,10 +470,21 @@ noted in steps 3 and 4 below.
    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. A hand-edit to code
-   always plans a lap. Only a confident non-`edit` verdict skips the replan — a
-   note whose evidence was cut, or that got no verdict, counts as `edit`. The
-   same `gtd judge answer` / conservative-default shape as step 3's own judged
+   — 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.
+   `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
+   evidence was cut, or that got no verdict, counts as `edit`. The same
+   `gtd judge answer` / conservative-default shape as step 3's own judged
    points.
 
 You never talk to it. Every exchange is a file in `.gtd/` that you edit in your

package/dist/chunks/{reserved-DJwU5C4z.mjs → reserved-6pAgFGgB.mjs}

@@ -1,7 +1,6 @@
-import { accessFor, agent, answered, check, codeThreads, defineWorkflow, env, head, human, judge, numeric, quote, read, refuse, removeScript, run, scope, skillsFor, start, vars } from "../flows.mjs";
-import { escalation as escalation$1, fixFindings, gate as gate$1, healthy as healthy$1, holdWording as holdWording$1, lensScopes, lensesOf, qualityLap as qualityLap$1, reviewToHandOff, untilSettled } from "../workflow-kit.mjs";
+import { accessFor, agent, answered, changesSince, check, codeThreads, defineWorkflow, env, head, human, judge, numeric, quote, read, refuse, removeScript, run, scope, showScript, skillsFor, start, vars } from "../flows.mjs";
+import { escalation as escalation$1, fixFindings, gate as gate$1, healthy as healthy$1, lensScopes, lensesOf, qualityLap as qualityLap$1, removedAssertions, reviewToHandOff } from "../workflow-kit.mjs";
 import { c as String$, g as standardSchemaV1, h as optionalWith, l as Struct } from "./Schema-B5yK7QrT.mjs";
-import { dirname } from "node:path";
 //#region src/workflows/shared/prose.ts
 const skillsPreamble = `- Load whatever's listed here that your harness actually has installed,
   skip anything it doesn't — silently, never stopping or asking about a
@@ -310,6 +309,10 @@ ${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
@@ -453,7 +456,8 @@ ${footnoteFoldIn}${codeThreadReplies()}
 - Every open point here is TECHNICAL — triage already resolved
   the product ones, one phase earlier. PERMISSIVE: answer it
   yourself unless you genuinely cannot defend a default; a wrong
-  technical call is still caught by the full run and the quality lap
+  technical call is still caught by each package's suite run and the
+  quality lap
 - The narrow exception: a simplification that drops something
   \`.gtd/REQUIREMENTS.md\` mentions is an open question, not a
   silent default
@@ -465,11 +469,13 @@ ${footnoteFoldIn}${codeThreadReplies()}
      only, as fenced TypeScript (or the repository's language)
   3. \`## Call Stacks\` — seam level, entry point → module
      boundary; one line per hop, never per line of code
-  4. \`## E2E Scenarios\` — Gherkin in fenced \`gherkin\` blocks
-     (whatever e2e framework the repository uses), each preceded
-     by a line \`- e2e: <path>\`. With no user-visible
-     behaviour change, the literal line \`No e2e change.\` plus a
-     one-line reason — never empty or missing
+  4. \`## E2E Scenarios\` — one line per user-visible behaviour,
+     \`- e2e: <path> — <behaviour> (covers <concern>)\`, in plain
+     words: the builder writes the scenario in the repository's
+     own e2e framework, so never spell out Gherkin here. With no
+     user-visible behaviour change, the literal line
+     \`No e2e change.\` plus a one-line reason — never empty or
+     missing
   5. \`## Unit Tests\` — one \`### <interface>\` per entry of
      \`## Interfaces\`, each test a line
      \`- unit: <path> — <behaviour> (covers <concern>)\`;
@@ -495,35 +501,31 @@ const architectureDecomposePrompt = () => `${styleBlock}
 ${stateFileRules}
 - The only state files this turn touches are the package files
   under \`.gtd/packages/\` — no other files for notes or output.
-  Never delete \`.gtd/ARCHITECTURE.md\`: the build tail's full run
-  still needs it, and package files may reference it
+  Never delete \`.gtd/ARCHITECTURE.md\`: package files may
+  reference it, and it is removed with the last package
 - Work from \`.gtd/ARCHITECTURE.md\` if you wrote it earlier this
   conversation, otherwise read it (the converged technical
   plan). It already lists the concerns, interfaces, e2e scenarios
   and unit tests — this turn groups them into packages. A
   \`## Merged Concerns\` heading there records merges, never a
   concern of its own: write no package file for it
-- A package is a consecutive run of \`## Unit Tests\` entries that go
-  green together on the fast suite, at most ~8 unit-test entries
-  each. Keep the merge rule: concerns whose footprints centre on the
-  same files stay in one package unless the later one only consumes
-  an interface the earlier one creates. Prefer fewer, larger
-  packages. Order them so each stays green on the fast suite —
-  interface-introducing packages first
+- A package is one concern's slice, and each must leave the full
+  suite green — every package boundary costs a full run, so write
+  as few as the concerns allow. Keep the merge rule: concerns whose
+  footprints centre on the same files stay in one package unless
+  the later one only consumes an interface the earlier one creates.
+  Order them interface-introducing packages first
 - Write the packages under \`.gtd/packages/\`, each carrying its
   requirement(s) — both, independently, if merged — its tasks, and
   each task's acceptance criteria as \`- [ ]\` checkboxes and
   relevant paths:
-  - \`.gtd/packages/00-e2e-scenarios.md\` — package 0: it writes
-    \`## E2E Scenarios\` as tests in the repository's own e2e
-    framework and leaves them red. Write no such file when
-    \`## E2E Scenarios\` says "No e2e change."
-  - \`01-…\` onward — the unit-test packages. A requirement no test
-    covers (docs, README, deletions, config) becomes a chore
-    package, or a task of one; chore packages declare no tests
-  - the last numbered package is the wiring package: CLI entry,
-    workflow composition, config. A red e2e after it is a bug, not
-    missing work
+  - \`01-…\` onward — one vertical slice each: the unit tests,
+    the code, the wiring (CLI entry, workflow composition, config)
+    and every \`## E2E Scenarios\` entry its concern covers, so the
+    slice ends with its scenarios passing. A requirement no test
+    covers (docs, README, deletions, config) is a task of the slice
+    it belongs to; only one no slice owns becomes a chore package,
+    which declares no tests
 - Every package with tests has a \`## Tests\` section, one line per
   declared test, copied from the architecture entries:
   \`- unit: \\\`<path>\\\`\` or \`- e2e: \\\`<path>\\\`\`. Chore packages have
@@ -569,10 +571,10 @@ const packagesItemBuildingPrompt = (pkg) => `${stateFileRules}
 - Write the tests the package declares under \`## Tests\` first,
   then the code that makes them pass; the turn is refused unless
   every declared test is in your diff
-- Package 0 (\`.gtd/packages/00-e2e-scenarios.md\`) writes the scenarios verbatim
-  from \`## E2E Scenarios\` of \`.gtd/ARCHITECTURE.md\`, with only
-  step code that typechecks, and leaves them red — no
-  implementation
+- A declared e2e test is a scenario in the repository's own e2e
+  framework for the behaviour its \`## E2E Scenarios\` entry names.
+  Word it to fit the existing steps — reuse and generalise them
+  rather than adding one-off ones
 - Implement every task the package describes, no more, no less,
   fanning independent ones out to parallel subagents where your
   harness supports it; leave other package files untouched
@@ -626,22 +628,9 @@ Edit \`.gtd/ESCALATION.md\` with fresh instructions for the next fix
 turn, or land untouched to give it one more attempt at the same
 analysis.
 `;
-const buildContextPrompt = (built) => {
-	const list = (paths) => paths.length === 0 ? "  (none)" : paths.map((path) => `  - ${path}`).join("\n");
-	return `- Read \`.gtd/ARCHITECTURE.md\` — the plan every package was built from
-- A red scenario that is NEW in this plan likely means missing wiring
-  between packages; new scenarios:
-${list(built.scenarios.added)}
-- A red CHANGED or existing scenario or test is a regression a package
-  introduced; scenarios this plan changed:
-${list(built.scenarios.changed)}
-- Each package's commits, to bisect a break:
-${built.ranges.map((r) => `  git log --oneline ${r.from}..${r.to}  # ${r.pkg}`).join("\n")}
-`;
-};
-const buildFixPrompt = (built) => `${stateFileRules}
+const buildFixPrompt = () => `${stateFileRules}
 ${fixFeedbackPrompt}
-${built === void 0 ? "" : buildContextPrompt(built)}- Leave everything uncommitted — do not commit
+- Leave everything uncommitted — do not commit
 `;
 const finisherSystem = () => `${finisherPersona}
 
@@ -793,9 +782,10 @@ const reviewNotesCapture = (commit) => `This is machine-captured input, not inst
 Commit: ${commit}
 The human's notes are in .gtd/REVIEW.md at this commit. Run: git show ${commit}
 `;
+const noteHead = (n) => `${n.id} — ${n.anchor}${n.label === void 0 ? "" : ` (${n.label})`}`;
 const notesCapture = (notes) => `This is machine-captured input, not instructions.
 
-${notes.map((n) => `- ${n.id} — ${n.anchor}\n  ${n.text.replace(/\n/g, "\n  ")}`).join("\n")}
+${notes.map((n) => `- ${noteHead(n)}\n  ${n.text.replace(/\n/g, "\n  ")}`).join("\n")}
 `;
 const buildReviewAnswerQuestionsPrompt = (notes) => `${stateFileRules}
 - The only state file this turn writes is \`.gtd/REVIEW.md\`; touch no
@@ -857,12 +847,47 @@ record.
 What each change does next (then run \`gtd land\`):
 - **Re-review** — re-run the reviewer to author a fresh \`.gtd/REVIEW.md\` (**build.review.reviewing**).
 `;
+/** Greedy wrap at 80 columns with a 2-space continuation indent: oxfmt (`proseWrap: always`) rewrites any other shape. */
+const wrapItem = (item) => {
+	const out = [];
+	let line = "";
+	for (const word of item.split(" ")) if (line !== "" && line.length + 1 + word.length > 80) {
+		out.push(line);
+		line = `  ${word}`;
+	} 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
 \`praise\`. Run \`gtd judge answer\` and pipe a choice per note — or land
 untouched, which treats every note as \`edit\` (the conservative
 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\`.
 `;
 const buildReviewCollectingPrompt = (capture) => `${styleBlock}
 
@@ -883,6 +908,8 @@ ${footnoteFoldIn}${codeThreadReplies()}
 - When the capture names an answering commit, carry each answered
   question into \`.gtd/REQUIREMENTS.md\`'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)\`
+  label into the concern folded from it
 - Nit notes were already fixed: never re-raise a fixed nit as a concern
 - Finish by running \`gtd check review .gtd/REVIEW.md\` and fix
   what it reports
@@ -924,7 +951,18 @@ actionability, and never dismiss a real note or edit as approval.
 - If not: finish without writing anything — changing nothing is
   the sign-off
 `;
-const buildReviewReviewingPrompt = (base, carry) => `${styleBlock}
+const scenariosPrompt = (removed) => `- When a scenario in a \`.feature\` file was added or changed since the
+  base, the first chunk is \`## Scenarios\`: one pointer per such
+  scenario, its note saying in plain words what behaviour it now pins
+  down — the human signs off the scenarios here, nowhere else
+${removed.length === 0 ? "" : `- These assertions of scenarios that existed at the base are gone:
+${removed.map(({ path, lines }) => lines.map((a) => `    ${path} — ${a.scenario} — ${a.line}\n`).join("")).join("")}  Open the note of each scenario that lost one with \`Weakened:\`,
+  naming the lost line and whether \`.gtd/REQUIREMENTS.md\` asked
+  for it. A scenario that no longer exists has no pointer of its own:
+  put its \`Weakened:\` note on a pointer of the chunk covering its
+  removal
+`}`;
+const buildReviewReviewingPrompt = (base, carry, removed = []) => `${styleBlock}
 
 ${styleFormatContract}
 
@@ -966,7 +1004,7 @@ review the changes:
   A note sitting entirely on the line(s) beneath the pointer is
   also valid. Either way, the note must never start with a bare \`./path\` token
   — that parses as a second pointer, not a note
-No diff is given — read the changes yourself. The range runs
+${scenariosPrompt(removed)}No diff is given — read the changes yourself. The range runs
 from \`${base}\` to the working tree (committed turns
 plus anything pending); on a feedback round that's the previous
 review's boundary, so it covers only what's new.
@@ -1013,20 +1051,6 @@ ${it.processCostByModel.map((m) => `- ${m.model}: ${m.cost}\n`).join("")}
 Print the closing message and stop — this writes nothing itself.
 `;
 };
-const scenarioWordingMessage = (at, drifted) => `The e2e scenario wording was frozen when package 0 landed, and the last
-turn changed it. Removed lines are marked \`-\`, added ones \`+\`:
-
-${drifted.map(({ path, lines }) => `${path}\n${lines.join("\n")}`).join("\n\n")}
-
-To accept the change, land untouched.
-
-To reject it, run
-
-    git checkout ${at} -- ${drifted.map(({ path }) => quote(path)).join(" ")}
-
-and land. Restoring only some of the files is a partial accept: every file
-still differing from the frozen wording is accepted.
-`;
 //#endregion
 //#region src/workflows/shared/steps.ts
 const FEEDBACK = ".gtd/FEEDBACK.md";
@@ -1037,7 +1061,7 @@ const REVIEW = ".gtd/REVIEW.md";
 const QUALITY = ".gtd/QUALITY.md";
 const planner = () => env.plannerModel ?? "";
 const coder = () => env.coderModel ?? "";
-const fixCheck = (built) => agentWithSkills("fix", buildFixPrompt(built), {
+const fixCheck = () => agentWithSkills("fix", buildFixPrompt(), {
 	label: "Fixing the check",
 	file: FEEDBACK,
 	model: coder(),
@@ -1093,7 +1117,7 @@ const fixQuality = () => agentWithSkills("fix.quality.fixing", buildFixQualityPr
 	allowEmpty: true
 });
 /** Write `.gtd/REVIEW.md` over everything since `base`, carrying the answers of commit `carry` when given. */
-const reviewing = (base, carry) => agentWithSkills("review.reviewing", buildReviewReviewingPrompt(base, carry), {
+const reviewing = (base, carry) => agentWithSkills("review.reviewing", buildReviewReviewingPrompt(base, carry, removedAssertions(changesSince(base))), {
 	label: "Reviewing",
 	file: REVIEW,
 	mode: "review",
@@ -1109,37 +1133,24 @@ const fixRisks = (notes) => agentWithSkills("review.fix.risks.fixing", buildRevi
 	system: reviewerSystem(),
 	allowEmpty: true
 });
-const awaitReview = (base, message = buildReviewAwaitReviewMessage(base)) => human("review.await-review", {
+const awaitReview = (base, message = buildReviewAwaitReviewMessage(base), acceptClean = false) => human("review.await-review", {
 	message,
 	label: "Awaiting your review",
 	file: REVIEW,
 	mode: "review",
-	base
+	base,
+	...acceptClean ? { acceptClean } : {}
 });
 /** The round at commit `round` left no `.gtd/REVIEW.md`. */
 const reviewMissing = (round) => human("review.review-missing", {
 	message: buildReviewReviewMissingMessage(round),
 	label: "Nothing to review"
 });
-//#endregion
-//#region src/workflows/shared/health.ts
-/** Written while `fastTestCommand` is unset; its presence rests the process at the check. */
-const SETUP = ".gtd/SETUP.md";
-const SETUP_TEXT = "The bundled workflow needs the `fastTestCommand` setting: the fast suite (everything but e2e).\nSet it as a workflow option in `gtd.config.ts` or as GTD_FASTTESTCOMMAND.";
-/** Shell lines for a check's preamble: unset (blank after trim) setting writes `SETUP` and skips the suite. */
-const fastSuiteGuard = () => (env.fastTestCommand ?? "").trim() === "" ? [
-	`mkdir -p ${quote(dirname(SETUP))}`,
-	`printf '%s\\n' ${quote(SETUP_TEXT)} > ${quote(SETUP)}`,
-	`printf '%s\\n' ${quote(SETUP_TEXT)} >&2`,
-	"exit 0"
-] : [`rm -f ${quote(SETUP)}`];
-const unconfigured = () => read(SETUP) !== void 0;
 /** Run the suite as step `name`; resolves `true` when it passed. A failure is in `.gtd/FEEDBACK.md`. */
-const baseline = (name, label = "Checking the baseline") => untilSettled(() => check(name, env.testCommand ?? "", {
+const baseline = (name, label = "Checking the baseline") => check(name, env.testCommand ?? "", {
 	report: FEEDBACK,
-	label,
-	preamble: fastSuiteGuard()
-}), unconfigured);
+	label
+});
 const escalationSteps = {
 	limit: 2,
 	describe: describeEscalation,
@@ -1177,22 +1188,18 @@ const sameFailure = async (previous, current) => {
 	});
 	return comparable && truncated.length === 0 && answered(answers.verdict, "identical", numeric(vars.judgeIdenticalMinP, Infinity));
 };
-const runSuite = (options) => {
-	const fast = options.suite === "fast";
-	return check("health.check", (fast ? env.fastTestCommand : env.testCommand) ?? "", {
-		report: FEEDBACK,
-		label: "Running checks",
-		sweepOnGreen: [ESCALATION, ...options.sweepOnGreen ?? []],
-		...fast ? { preamble: fastSuiteGuard() } : {}
-	});
-};
+const runSuite = (options) => check("health.check", env.testCommand ?? "", {
+	report: FEEDBACK,
+	label: "Running checks",
+	sweepOnGreen: [ESCALATION, ...options.sweepOnGreen ?? []]
+});
 /**
 * Loop until the suite is green: check, and on red run `fix` — escalating
 * first once `FIX_CAP` fixes are spent, or a judge calls the failure
 * identical to the previous round's.
 */
 const healthy = (fix, options = {}) => healthy$1(fix, {
-	check: options.suite === "fast" ? () => untilSettled(() => runSuite(options), unconfigured) : () => runSuite(options),
+	check: () => runSuite(options),
 	report: FEEDBACK,
 	fixCap: 3,
 	fixesSoFar: options.fixesSoFar ?? 0,
@@ -1214,12 +1221,12 @@ const defaults = {
 	judgeBudgetBytes: "32768",
 	judgeIdenticalMinP: "0.7",
 	reviewNoteActionable: "0.7",
+	reviewSeverityMinP: "0.7",
 	qualityReviews: "correctness, owasp-security, ponytail-review, test-audit, conventions, spec-challenge"
 };
 /** Environment settings. */
 const envDefaults = {
 	testCommand: "npm test",
-	fastTestCommand: "",
 	plannerModel: "smart",
 	coderModel: "base"
 };
@@ -1231,9 +1238,9 @@ const ShippedOptions = Struct({
 	judgeBudgetBytes: setting,
 	judgeIdenticalMinP: setting,
 	reviewNoteActionable: setting,
+	reviewSeverityMinP: setting,
 	qualityReviews: setting,
 	testCommand: setting,
-	fastTestCommand: setting,
 	plannerModel: setting,
 	coderModel: setting
 });
@@ -1253,21 +1260,6 @@ const shipped = (flow, doors, base) => defineWorkflow(standardSchemaV1(ShippedOp
 	base
 }));
 //#endregion
-//#region src/workflows/shared/scenarios.ts
-/** After a turn: stop at `scenario-wording` while wording drifted; accept moves the snapshot. */
-const holdWording = (frozen) => holdWording$1(frozen, (at, drifted) => human("scenario-wording", {
-	message: scenarioWordingMessage(at, drifted),
-	label: "Scenario wording changed",
-	acceptClean: true,
-	base: at
-}));
-/** `turn`, then `holdWording`; `within` names the scope the gate rests in. */
-const guarded = (frozen, turn, within) => async () => {
-	await turn();
-	if (within === void 0) await holdWording(frozen);
-	else await scope(within, () => holdWording(frozen));
-};
-//#endregion
 //#region src/workflows/shared/tail.ts
 /** The reviewer's own `.gtd/REVIEW.md`, kept beside the human's notes so `fix` can tell them apart. */
 const REVIEW_ORIG = ".gtd/REVIEW.orig.md";
@@ -1278,8 +1270,8 @@ const REVIEW_ORIG = ".gtd/REVIEW.orig.md";
 */
 const qualityLap = () => qualityLap$1(lensesOf(vars.qualityReviews ?? ""), reviewQuality, QUALITY);
 /** Resolves `true` once `.gtd/QUALITY.md` is resolved, `false` when the fix cap escalated instead. */
-const fixQualityFindings = (escalations, frozen) => fixFindings({
-	fix: guarded(frozen, fixQuality),
+const fixQualityFindings = (escalations) => fixFindings({
+	fix: fixQuality,
 	findings: QUALITY,
 	cap: 3,
 	escalate: () => escalation(escalations)
@@ -1295,34 +1287,25 @@ const refusePendingHandOff = () => {
 };
 /**
 * The build tail: fix (when entered red), keep green, the quality lap, then
-* `finish` — the human review, as the calling workflow runs it.
+* `finish` — the human review, as the calling workflow runs it. `green`: the
+* caller just left the full suite green (the package loop), so no run opens it.
 */
-const tail = (fixFirst, finish, built) => scope("build", async () => {
-	const frozen = built?.frozen;
+const tail = (fixFirst, finish, green = false) => scope("build", async () => {
 	const escalations = { rounds: 0 };
-	const guardedFix = guarded(frozen, () => fixCheck());
+	const fix = fixCheck;
 	const repair = async () => {
-		await guardedFix();
-		await healthy(guardedFix, {
+		await fix();
+		await healthy(fix, {
 			fixesSoFar: 1,
 			escalations
 		});
 	};
 	if (fixFirst) await repair();
-	else await healthy(guarded(frozen, () => fixCheck(built)), {
-		escalations,
-		sweepOnGreen: [ARCHITECTURE]
-	});
-	if (await qualityLap() === "findings") if (await fixQualityFindings(escalations, frozen)) await healthy(guardedFix, { escalations });
+	else if (!green) await healthy(fix, { escalations });
+	if (await qualityLap() === "findings") if (await fixQualityFindings(escalations)) await healthy(fix, { escalations });
 	else await repair();
-	return finish(escalations, frozen);
+	return finish(escalations);
 });
-const handOffScript = (reviewed) => [
-	"#!/usr/bin/env sh",
-	"set -e",
-	`git show ${quote(`${reviewed}:${REVIEW}`)} > ${quote(REVIEW_ORIG)}`,
-	""
-].join("\n");
 /**
 * The review and fix workflows' human review since `base`: a sign-off closes
 * `.gtd/REVIEW.md`; a note leaves it, with the reviewer's own version as
@@ -1332,11 +1315,11 @@ const handOffReview = (base, escalations) => reviewToHandOff(base, {
 	file: REVIEW,
 	reviewing,
 	fixRisks,
-	keepGreen: () => healthy(() => fixCheck(), { escalations }),
+	keepGreen: () => healthy(fixCheck, { escalations }),
 	awaitReview: (b) => awaitReview(b, handOffAwaitReviewMessage(b)),
 	reviewMissing,
 	close: closeReview,
-	handOff: (reviewed) => run("review.handing-off", handOffScript(reviewed), { label: "Handing your notes to fix" }),
+	handOff: (reviewed) => run("review.handing-off", showScript(reviewed, REVIEW, REVIEW_ORIG), { label: "Handing your notes to fix" }),
 	threadsPending: "gtd land: open-threads: a thread in .gtd/REVIEW.md or an `H:` code comment waits on the agent — nothing answers it here; delete it, or turn it into a note for fix.",
 	unparsed: "gtd land: review-doc: your edit to .gtd/REVIEW.md contains no note fix can read — restore the deleted chunk, or write the note as a line under its entry.",
 	deleted: "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note to hand to fix."
@@ -1372,6 +1355,7 @@ const access = (vars) => ({
 	architecture: { write: [".gtd/REQUIREMENTS.md"] },
 	"architecture.decompose": { write: [".gtd/packages/**", ".gtd/ARCHITECTURE.md"] },
 	"build.review": { write: [".gtd/REVIEW.md"] },
+	"build.review.defer": { write: [".gtd/TODO.md"] },
 	"build.review.fix.nits": {},
 	"build.review.fix.risks": {},
 	...lensScopes("build.quality", lensesOf(vars.qualityReviews ?? ""), () => ({ write: [] }))
@@ -1385,4 +1369,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { unwindFailure as $, architectureAuthorPrompt as A, designTriagePrompt as B, fixCheck as C, reviewing as D, reviewMissing as E, buildReviewFixNitsPrompt as F, packagesItemFixSuitePrompt as G, fixReviewNotesPrompt as H, buildReviewTriageMessage as I, reviewGateBlockedMessage as J, reviewEditNotesCapture as K, builderSystem as L, architectureGateAnswerMessage as M, buildReviewAnswerQuestionsPrompt as N, agentWithSkills as O, buildReviewCollectingPrompt as P, unwindFailedMessage as Q, designGateAnswerMessage as R, coder as S, planner as T, idleMessage as U, finisherSystem as V, packagesItemBuildingPrompt as W, reviewerSystem as X, reviewNotesCapture as Y, startGateBlockedMessage as Z, ARCHITECTURE as _, REVIEW_ORIG as a, REVIEW as b, refusePendingHandOff as c, shipped as d, defaults as f, healthy as g, gate as h, skills as i, architectureDecomposePrompt as j, architectSystem as k, tail as l, baseline as m, summary as n, closeReview as o, envDefaults as p, reviewEditsCapture as q, access as r, handOffTail as s, steering as t, guarded as u, FEEDBACK as v, fixRisks as w, awaitReview as x, REQUIREMENTS as y, designSystem as z };
+export { unwindFailedMessage as $, architectureDecomposePrompt as A, designSystem as B, fixRisks as C, agentWithSkills as D, reviewing as E, buildReviewFixNitsPrompt as F, packagesItemBuildingPrompt as G, finisherSystem as H, buildReviewTriageMessage as I, reviewEditsCapture as J, packagesItemFixSuitePrompt as K, builderSystem as L, buildReviewAnswerQuestionsPrompt as M, buildReviewAwaitAfterDeferMessage as N, architectSystem as O, buildReviewCollectingPrompt as P, startGateBlockedMessage as Q, deferNotesScript as R, fixCheck as S, reviewMissing as T, fixReviewNotesPrompt as U, designTriagePrompt as V, idleMessage as W, reviewNotesCapture as X, reviewGateBlockedMessage as Y, reviewerSystem as Z, FEEDBACK as _, REVIEW_ORIG as a, awaitReview as b, refusePendingHandOff as c, defaults as d, unwindFailure as et, envDefaults as f, ARCHITECTURE as g, healthy as h, skills as i, architectureGateAnswerMessage as j, architectureAuthorPrompt as k, tail as l, gate as m, summary as n, closeReview as o, baseline as p, reviewEditNotesCapture as q, access as r, handOffTail as s, steering as t, shipped as u, REQUIREMENTS as v, planner as w, coder as x, REVIEW as y, designGateAnswerMessage as z };

package/dist/chunks/{steering-D-PvRC5W.mjs → steering-DVILanVf.mjs}

@@ -1,4 +1,12 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+//#region src/steering/SteeringFormat.ts
+/** `file:line:col: message` — the shape editors and grep already jump on. Stored 0-based, printed 1-based. A finding with a `line` but no `range`, or none at all, degrades to the shorter forms. */
+const formatFinding = (file, finding) => {
+	if (finding.line === void 0) return finding.message;
+	const col = finding.range !== void 0 ? `:${finding.range.start.character + 1}` : "";
+	return `${file}:${finding.line + 1}${col}: ${finding.message}`;
+};
+//#endregion
 //#region node_modules/mdast-util-to-string/lib/index.js
 /**
 * @typedef {import('mdast').Nodes} Nodes
@@ -15912,10 +15920,13 @@ const reviewNotes = (before, after) => {
 	return [...parseReviewDoc(after).changesets.flatMap((chunk) => {
 		const prior = oldChunks.get(chunk.title);
 		return [...chunkNote(chunk, prior), ...pointerNotes(chunk, prior)];
-	}), ...footnoteNotes(before, after)].sort((a, b) => a.line - b.line).map((f, i) => ({
-		id: `note-${i + 1}`,
-		...f.note
-	}));
+	}), ...footnoteNotes(before, after)].sort((a, b) => a.line - b.line).map((f, i) => {
+		return {
+			id: `note-${i + 1}`,
+			...f.note,
+			forced: /^!(\s|$)/.test(f.note.text)
+		};
+	});
 };
 /** Pointer notes the reviewer opened with `Risk:`, in document order — the ones the workflow fixes before the human gate. */
 const reviewRisks = (content) => parseReviewDoc(content).changesets.flatMap((chunk) => chunk.files.flatMap((file) => file.note?.startsWith("Risk:") ? [{
@@ -16293,4 +16304,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, getParseCount as x, parseThreads as y };
+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 };

package/dist/flows.mjs

@@ -237,6 +237,13 @@ const moveScript = (from, to) => [
 	`mv -- ${quote(from)} ${quote(to)}`,
 	""
 ].join("\n");
+/** Write `path` as committed at `ref` to `to`. */
+const showScript = (ref, path, to) => [
+	"#!/usr/bin/env sh",
+	"set -e",
+	`git show ${quote(`${ref}:${path}`)} > ${quote(to)}`,
+	""
+].join("\n");
 //#endregion
 //#region src/flows/helpers.ts
 /** Whether a judge answered `expected` at a probability of at least `minP`. */
@@ -515,6 +522,7 @@ var flows_exports = /* @__PURE__ */ __exportAll({
 	scope: () => scope,
 	sectionBodies: () => sectionBodies,
 	sections: () => sections,
+	showScript: () => showScript,
 	skillsFor: () => skillsFor,
 	start: () => start,
 	threads: () => threads,
@@ -522,4 +530,4 @@ var flows_exports = /* @__PURE__ */ __exportAll({
 	wrote: () => wrote
 });
 //#endregion
-export { FLOWS_PROTOCOL, FlowsProtocolError, accessFor, agent, answered, changes, changesSince, check, checkScript, codeChanges, codeThreads, configProblems, configure, defineConfig, defineWorkflow, env, glob, hasThreadFor, head, human, installContext, isFactoryWorkflow, judge, moveScript, numeric, openQuestions, protocolMismatch, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireRevert, requireThreadsClosed, restart, restoreScript, revertScript, run, scope, sectionBodies, sections, skillsFor, start, flows_exports as t, threads, vars, wrote };
+export { FLOWS_PROTOCOL, FlowsProtocolError, accessFor, agent, answered, changes, changesSince, check, checkScript, codeChanges, codeThreads, configProblems, configure, defineConfig, defineWorkflow, env, glob, hasThreadFor, head, human, installContext, isFactoryWorkflow, judge, moveScript, numeric, openQuestions, protocolMismatch, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireRevert, requireThreadsClosed, restart, restoreScript, revertScript, run, scope, sectionBodies, sections, showScript, skillsFor, start, flows_exports as t, threads, vars, wrote };