@pmelab/gtd 39.0.0 → 41.0.0

package/.claude-plugin/plugin.json

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

@@ -419,10 +419,9 @@ phone UI does not show them).
 
 ### The workflow it ships with
 
-One built-in workflow drives all of that. From where you sit, it has three
+One built-in workflow drives all of that. From where you sit, it has four
 moments — everything between them runs without you, with the judged exceptions
-noted in step 3 below — plus a fourth, review, only on `refactor-first` or when
-you open the `review` door.
+noted in steps 3 and 4 below.
 
 1. **You sketch.** Change anything, or write the idea into `.gtd/TODO.md`. Rough
    is fine; it is treated as a sketch, not as work.
@@ -449,14 +448,12 @@ you open the `review` door.
    against the full suite (`testCommand`) and fixed until it passes — so keep
    that suite fast; gtd has no lighter one. Scenario wording is not frozen: a
    review's `## Scenarios` chunk marks any assertion an existing scenario lost
-   as `Weakened:` — **risk: `feature` has no review, so a build turn that
-   weakens a scenario reaches `idle` unflagged unless you open the `review`
-   door.** After the build the quality lap runs, and the process ends: the
-   feature workflow has no human review of the finished change. Two points along
-   the process (one with flag mode off) 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
+   as `Weakened:`, so you sign the scenarios off at step 4. After the build the
+   quality lap runs. Three points along the process (two with flag mode off) 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
@@ -474,6 +471,8 @@ you open the `review` door.
      or get rejected and retried?
    - Every red round after the first: was the failure identical, new, or
      progress?
+   - After you review: is each of your notes an edit, a question, a nit or
+     praise?
 
    gtd itself never calls a judge: `gtd loop`, the Claude Code mod and the
    reference driver answer these through `gtd judge run` (auto selection: jev
@@ -485,22 +484,20 @@ you open the `review` door.
    and skip a gate unattended.**
 
    Once the change is built, the whole change goes through a qualitative review
-   lap: six lenses, one turn each, in order — `correctness`, `owasp-security`,
-   `ponytail-review`, `test-audit`, `conventions`, `spec-challenge`.
-   `correctness`, `owasp-security` and `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 is the last look the
-   feature workflow takes: the process ends at `idle` once it is clean (and the
-   suite green), with no review rest — **risk: nothing re-reads the code the
-   single fix turn writes; only the suite gates 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. **Nobody
-   signs the finished change off unless you open the `review` door** (below).
-   The `fix` door repairs a red baseline through this same lap.
+   lap before you see anything: six lenses, one turn each, in order —
+   `correctness`, `owasp-security`, `ponytail-review`, `test-audit`,
+   `conventions`, `spec-challenge`. `correctness`, `owasp-security` and
+   `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.
 
    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
@@ -509,33 +506,36 @@ you open the `review` door.
    as-is, handing that document to the next fix turn as its instruction. Two
    such rounds with no fix is the terminal stop: the last analysis stays on disk
    instead of a third being written, and editing it is what gets the next
-   attempt anywhere new. Before any escalation or red-baseline stop the suite
-   runs once more; a pass there continues without you and is recorded as
+   attempt anywhere new. A loop the retry judge still calls progress at the cap
+   gets one extra fix turn first. Before any escalation or red-baseline stop the
+   suite runs once more; a pass there continues without you and is recorded as
    `Gtd-Mark: flaky=<check>` (see
    [Re-check before a person](docs/configuration.md#re-check-before-a-person)).
 
-4. **You review — the refactor, or on request.** The feature workflow asks for
-   one review only on `refactor-first`: of the refactor slice, before the
-   feature is built (see [the naive pass](#the-naive-pass)). For the finished
-   change run `gtd door review <commitish>` (`/gtd review [base]`); that review
-   hands notes to `fix` instead of re-planning (below). Either way you get a
-   review document listing what changed and what to look at. Before you see it,
+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. At the
-   refactor review, approving moves on to the feature; feedback is judged note
-   by note (a third judged point), each as `edit`, `question`, `nit` or
-   `praise`. An `edit` re-derives the refactor (in a custom workflow built on
-   `buildTail`, it sends the process back to step 2 for re-derived
-   requirements). 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.
+   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.
 
    Each `edit` note also gets a severity tier from four judge questions
    (security, reversibility, blast radius, new concept). `critical` and `should`
@@ -555,7 +555,7 @@ you open the `review` door.
 You never talk to it. Every exchange is a file in `.gtd/` that you edit in your
 own editor, and every answer you give is a commit. Your test suite is the gate
 throughout: a red baseline stops the process before it starts, and a red build
-is fixed before the process ends.
+is fixed before review.
 
 Prefer a phone or another device over your editor? `gtd ui` opens the file whose
 turn it is as a small web app, over Tailscale — including a step that names no
@@ -635,14 +635,15 @@ criterion ID the naive pass's tests named, and the suite must be green with
 them. A wrong approach is retried twice, then rests for you to steer or overrule
 it. `gtd slices` lists the `refactor` and `feature` slices. A refactor that
 already carried the whole feature leaves the rebuild only the carried-over
-tests, and the feature's quality lap covers the whole change. Once the
+tests, and the feature's quality lap and review cover the whole change. Once the
 implementation is green, a judge checks every criterion ID has a covering test:
 an uncovered one goes back to the agent (twice, then to you) instead of ending
 the feature, and each covered ID is recorded as a `Gtd-Mark: covers=<id>`
 trailer. See
 [Acceptance-criteria coverage](docs/configuration.md#acceptance-criteria-coverage).
-Feedback at the refactor review re-runs the refactor, never design; a
-refactor-review change the refactor cannot build is refused, and the only way
+Feedback at the feature review re-runs design and the implementation, never the
+naive pass; feedback at the refactor review re-runs the refactor, never design;
+a refactor-review change the refactor cannot build is refused, and the only way
 out is `gtd abandon`. A process from 27.5.0 or later whose judge ruled
 `refactor-first` must `gtd abandon` too. Each slice's quality lap reviews only
 that slice. Details in
@@ -652,10 +653,11 @@ that slice. Details in
 criteria than the cap is built in slices: after design an agent groups related
 criteria (same flow or subsystem) into `.gtd/SLICES.md`, as few slices as the
 cap allows, and each slice — naive pass, refactor and rebuild when judged so,
-health loop, quality lap — runs in order from where the previous one landed.
-`gtd slices` lists them as `feature-1`, `feature-2`, … (`refactor-<n>` ahead of
-a refactored one). A change within the cap is one `feature` slice, as before.
-See [Coarse slices](docs/configuration.md#coarse-slices).
+health loop, quality lap — runs in order from where the previous one landed; the
+review follows the last one and covers the whole change. `gtd slices` lists them
+as `feature-1`, `feature-2`, … (`refactor-<n>` ahead of a refactored one). A
+change within the cap is one `feature` slice, as before. See
+[Coarse slices](docs/configuration.md#coarse-slices).
 
 **Flag mode (`flagMode`, on by default).** On, the naive pass's judge runs as
 above and a rebuilt implementation is asked for a new release flag (none at a

package/dist/chunks/{reserved-B6tTYjeb.mjs → reserved-Ch4LLrEj.mjs}

@@ -421,14 +421,14 @@ 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 qualityUnresolvedMessage = () => `The quality lap's fix turns hit their cap and \`.gtd/QUALITY.md\` still
-holds findings. Nothing reviews the change after this, so the process
-will not end with them open.
+holds findings. Nothing after this fixes them, so the process will not
+go on with them open.
 
 Fix what matters by hand, then delete or empty \`.gtd/QUALITY.md\` —
 dropping a finding is your call to make.
 
 What each change does next (then run \`gtd land\`):
-- **Delete or empty \`.gtd/QUALITY.md\`** — the suite runs on your edits, then the process ends (**idle**).
+- **Delete or empty \`.gtd/QUALITY.md\`** — the suite runs on your edits, then the next slice is built, or after the last one you review the change (**build.review.reviewing**).
 - **Anything else** — rests here again.
 `;
 const startGateBlockedMessage = () => `The test baseline is red — gtd will not start new work on a broken suite.
@@ -466,8 +466,10 @@ reword a criterion in place, append a new one with the next unused
 number, delete a dropped one — never renumber, never reuse an ID. When
 the file holds no list (a review loop-back rewrites it), recover the
 last settled one from history (\`git log -p -- .gtd/REQUIREMENTS.md\`)
-and carry its IDs over. Landing is refused while a criterion has no ID or
-two share one.
+and carry its IDs over: after a review a built criterion keeps its ID,
+reworded in place when the review changes its behaviour, and new
+behaviour gets a new ID. Landing is refused while a criterion has no ID
+or two share one.
 `;
 const riskTierBlock = `
 ## Risk tier and production signals
@@ -1630,7 +1632,7 @@ const retryQuestion = (comparable) => comparable ? {
 	instructions: "state carries tailsNotComparable: one of the two check reports came back empty. There is nothing to compare here; answer from criteria alone. `identical` is FORBIDDEN here.",
 	criteria: "new-failure: a materially different failure than before. progress: still red, but closer to green — the default if genuinely unsure."
 };
-const sameFailure = async (previous, current) => {
+const compare = async (previous, current) => {
 	const comparable = current.trim() !== "" && previous.trim() !== "";
 	const { answers, truncated } = await judge("health.judge", {
 		questions: [retryQuestion(comparable)],
@@ -1641,7 +1643,10 @@ const sameFailure = async (previous, current) => {
 		message: healthJudgeMessage(),
 		label: "Judging the retry"
 	});
-	return comparable && truncated.length === 0 && answered(answers.verdict, "identical", numeric(vars.judgeIdenticalMinP, Infinity));
+	if (!comparable || truncated.length > 0) return void 0;
+	const minP = numeric(vars.judgeIdenticalMinP, Infinity);
+	if (answered(answers.verdict, "identical", minP)) return "identical";
+	return answered(answers.verdict, "progress", minP) ? "progress" : void 0;
 };
 const healthSweep = (options) => [ESCALATION, ...options.sweepOnGreen ?? []];
 const runSuite = (options) => check("health.check", env.testCommand ?? "", {
@@ -1652,7 +1657,8 @@ const runSuite = (options) => check("health.check", env.testCommand ?? "", {
 /**
 * 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. An escalation re-runs the suite once
+* identical to the previous round's. A judge calling it progress at the cap
+* buys one extra fix per run of fixes. An escalation re-runs the suite once
 * first; a green re-run ends the loop.
 */
 const healthy = (fix, options = {}) => healthy$1(guarded(fix, options.guard), {
@@ -1660,7 +1666,7 @@ const healthy = (fix, options = {}) => healthy$1(guarded(fix, options.guard), {
 	report: FEEDBACK,
 	fixCap: 3,
 	fixesSoFar: options.fixesSoFar ?? 0,
-	sameFailure,
+	compare,
 	escalations: options.escalations ?? { rounds: 0 },
 	recheck: () => recheck("health.recheck", "health.check", { sweepOnGreen: healthSweep(options) }),
 	escalation: guardedSteps(options.guard, options.describeGuard, options.guardRests, options.rules)

package/dist/chunks/{tail-_CZTP7Hu.mjs → tail-lY1UmJrU.mjs}

@@ -1,6 +1,6 @@
 import { read, refuse, removeScript, run, scope, showScript, vars } 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, Y as handOffAwaitReviewMessage, d as guarded, f as healthy, h as QUALITY, k as reviewing, l as escalation, w as fixQuality, x as awaitReview, y as REVIEW } from "./reserved-B6tTYjeb.mjs";
+import { C as fixCheck, D as reviewMissing, O as reviewQuality, T as fixRisks, Y as handOffAwaitReviewMessage, d as guarded, f as healthy, h as QUALITY, k as reviewing, l as escalation, w as fixQuality, x as awaitReview, y as REVIEW } from "./reserved-Ch4LLrEj.mjs";
 //#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";

package/dist/workflow-kit.mjs

@@ -22,13 +22,33 @@ const recheckReport = async (health) => {
 	if (health.recheck === void 0) return void 0;
 	return await health.recheck() || stripStamp(read(health.report) ?? "");
 };
+/** Escalate unless the re-check passes: `true` then, else the report the next round compares against. */
+const escalated = async (health, current) => {
+	const rechecked = await recheckReport(health);
+	if (rechecked === true) {
+		health.escalations.rounds = 0;
+		return true;
+	}
+	await escalation(health.escalations, health.escalation);
+	return rechecked ?? current;
+};
+const nextMove = async (health, fixes, cap, previous, current) => {
+	const capped = fixes >= cap;
+	if (capped && cap > health.fixCap) return "escalate";
+	const verdict = previous === void 0 ? void 0 : await health.compare(previous, current);
+	if (capped && verdict === "progress") return "extend";
+	return verdict === "identical" || capped ? "escalate" : void 0;
+};
 /**
 * Loop until the suite is green: check, and on red run `fix` — escalating
-* first once `fixCap` fixes are spent, or `sameFailure` calls the failure
-* identical to the previous round's, unless `recheck` passes.
+* first once `fixCap` fixes are spent, or `compare` calls the failure
+* identical to the previous round's, unless `recheck` passes. A round that
+* reaches the cap while `compare` calls it progress raises the cap by one fix,
+* once per run of fixes between escalations.
 */
 const healthy = async (fix, health) => {
 	let fixes = health.fixesSoFar ?? 0;
+	let cap = health.fixCap;
 	let previous;
 	for (;;) {
 		if (await health.check()) {
@@ -36,17 +56,15 @@ const healthy = async (fix, health) => {
 			return;
 		}
 		const current = stripStamp(read(health.report) ?? "");
-		const stuck = previous !== void 0 && await health.sameFailure(previous, current);
+		const move = await nextMove(health, fixes, cap, previous, current);
 		previous = current;
-		if (stuck || fixes >= health.fixCap) {
-			const rechecked = await recheckReport(health);
-			if (rechecked === true) {
-				health.escalations.rounds = 0;
-				return;
-			}
-			previous = rechecked ?? previous;
-			await escalation(health.escalations, health.escalation);
+		if (move === "extend") cap++;
+		else if (move === "escalate") {
+			const after = await escalated(health, current);
+			if (after === true) return;
+			previous = after;
 			fixes = 0;
+			cap = health.fixCap;
 		}
 		fixes++;
 		await fix();

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { Dt as registryEntry, Ot as requireFlag, S as coder, St as envDefaults, Tt as flagReferences, i as skills, n as summary, o as flagShipped, r as access, t as steering, xt as defaults } from "../chunks/reserved-B6tTYjeb.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-_CZTP7Hu.mjs";
+import { Dt as registryEntry, Ot as requireFlag, S as coder, St as envDefaults, Tt as flagReferences, i as skills, n as summary, o as flagShipped, r as access, t as steering, xt as defaults } from "../chunks/reserved-Ch4LLrEj.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-lY1UmJrU.mjs";
 //#region src/workflows/cleanup/cleanup.ts
 const removingPrompt = (name, registry) => `Clean up the release flag "${name}", which is default-on: delete its entry in ${registry}, and remove every \`GTD_FLAG_${name.toUpperCase()}\` check from the shipped sources. Keep the flag-on path; delete code only the off path reached, including tests that pin the off path.`;
 const cleanupFlow = async () => {

package/dist/workflows/feature.mjs

@@ -1,7 +1,7 @@
 import { agent, answered, applyScript, changes, changesSince, check, codeChanges, env, hasThreadFor, head, human, judge, judgeDiffShape, kept, mark, matches, numeric, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireRevert, requireThreadsClosed, restoreScript, revertScript, run, scope, slice, start, vars, wrote } from "../flows.mjs";
 import { lensEntriesOf, review as review$1 } from "../workflow-kit.mjs";
-import { $ as naiveApplyFailure, A as agentWithSkills, B as coverageQuestion, C as fixCheck, Ct as testFileGlobs, D as reviewMissing, E as planner, F as buildReviewTriageMessage, G as designSystem, H as criterionLine, I as builderSystem, K as designTriagePrompt, L as clearCriteriaMessage, M as buildReviewAwaitAfterDeferMessage, N as buildReviewCollectingPrompt, P as buildReviewFixNitsPrompt, Q as implementFixPrompt, R as clearCriteriaQuestion, S as coder, St as envDefaults, T as fixRisks, U as deferNotesScript, V as coveringPrompt, W as designGateAnswerMessage, X as idleMessage, Z as implementBuildingPrompt, _ as REFACTOR_NOTE, _t as startGateBlockedMessage, a as flagModeOn, at as refactorDroppedRefusal, b as SLICES, bt as unwindFailure, ct as refactorRules, d as guarded, et as naivePassPrompt, f as healthy, ft as reviewNotesCapture, g as REFACTOR, gt as slicingPrompt, h as QUALITY, ht as seamSteerMessage, i as skills, it as refactorBuildingPrompt, j as buildReviewAnswerQuestionsPrompt, k as reviewing, lt as reviewEditNotesCapture, m as HANDOFF, mt as seamByHandMessage, n as summary, nt as oversizedMessage, ot as refactorFixPrompt, p as FEEDBACK, pt as reviewerSystem, r as access, rt as qualityUnresolvedMessage, s as shipped, st as refactorNotePrompt, t as steering, tt as normaliseCriteriaScript, u as gate, ut as reviewEditsCapture, v as REQUIREMENTS, vt as uncoveredMessage, x as awaitReview, xt as defaults, y as REVIEW, yt as unwindFailedMessage, z as coverageMessage } from "../chunks/reserved-B6tTYjeb.mjs";
-import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-_CZTP7Hu.mjs";
+import { $ as naiveApplyFailure, A as agentWithSkills, B as coverageQuestion, C as fixCheck, Ct as testFileGlobs, D as reviewMissing, E as planner, F as buildReviewTriageMessage, G as designSystem, H as criterionLine, I as builderSystem, K as designTriagePrompt, L as clearCriteriaMessage, M as buildReviewAwaitAfterDeferMessage, N as buildReviewCollectingPrompt, P as buildReviewFixNitsPrompt, Q as implementFixPrompt, R as clearCriteriaQuestion, S as coder, St as envDefaults, T as fixRisks, U as deferNotesScript, V as coveringPrompt, W as designGateAnswerMessage, X as idleMessage, Z as implementBuildingPrompt, _ as REFACTOR_NOTE, _t as startGateBlockedMessage, a as flagModeOn, at as refactorDroppedRefusal, b as SLICES, bt as unwindFailure, ct as refactorRules, d as guarded, et as naivePassPrompt, f as healthy, ft as reviewNotesCapture, g as REFACTOR, gt as slicingPrompt, h as QUALITY, ht as seamSteerMessage, i as skills, it as refactorBuildingPrompt, j as buildReviewAnswerQuestionsPrompt, k as reviewing, lt as reviewEditNotesCapture, m as HANDOFF, mt as seamByHandMessage, n as summary, nt as oversizedMessage, ot as refactorFixPrompt, p as FEEDBACK, pt as reviewerSystem, r as access, rt as qualityUnresolvedMessage, s as shipped, st as refactorNotePrompt, t as steering, tt as normaliseCriteriaScript, u as gate, ut as reviewEditsCapture, v as REQUIREMENTS, vt as uncoveredMessage, x as awaitReview, xt as defaults, y as REVIEW, yt as unwindFailedMessage, z as coverageMessage } from "../chunks/reserved-Ch4LLrEj.mjs";
+import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-lY1UmJrU.mjs";
 import { posix } from "node:path";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {
@@ -112,6 +112,19 @@ const requireCriteria = (file) => {
 	if (criteria.length > 0 && unnamed.length === 0 && twice.length === 0) return;
 	refuse(`gtd land: acceptance-criteria: ${file} has ${criteria.length === 0 ? `no "## Acceptance Criteria" list` : unnamed.length > 0 ? `${unnamed.length} criterion without an ID:\n${unnamed.map((c) => `  - ${c.text}`).join("\n")}` : `duplicate IDs: ${[...new Set(twice)].join(", ")}`} — list every criterion under "## Acceptance Criteria" as "- AC-<n>: <checkable criterion>", each ID unique and never reused`);
 };
+const idNumber = (id) => Number(id.slice(3));
+/** Why `listed` renumbers or reuses an earlier ID; `undefined` when it does neither. */
+const unstableIds = (listed, ids) => {
+	const top = Math.max(0, ...ids.used.map(idNumber));
+	const reused = listed.filter((id) => !ids.closed.includes(id) && idNumber(id) <= top);
+	if (reused.length === 0) return void 0;
+	return `numbers ${reused.join(", ")} at or below AC-${top}, an ID already handed out — keep a built criterion's ID (reword it in place when the review changes it), and number new ones from AC-${top + 1}`;
+};
+/** Refuse criteria in `file` that renumber or reuse an earlier ID. */
+const requireStableIds = (file, ids) => {
+	const why = unstableIds(criterionIds(read(file) ?? ""), ids);
+	if (why !== void 0) refuse(`gtd land: criteria-ids: ${file} ${why}`);
+};
 /** Refuse a turn that changed the acceptance criteria in `file`: after the design gate only another design lap may. */
 const requireCriteriaFrozen = (file) => {
 	const change = changes().get(file);
@@ -267,13 +280,14 @@ const noteGate = async (file, answer) => {
 	if (!hasThreadFor("agent", file)) requireAnswers(file);
 	return true;
 };
-/** Triage the sketch since `base` into requirements, until no product question is open. */
-const design = (base) => scope("design", async () => {
+/** Triage the sketch since `base` into requirements, until no product question is open; `guard` holds every round's criteria. */
+const design = (base, guard) => scope("design", async () => {
 	do {
 		await triage(base);
 		requireProgress(REQUIREMENTS);
 		requireReplies(REQUIREMENTS);
 		requireCriteria(REQUIREMENTS);
+		guard?.();
 	} while (await noteGate(REQUIREMENTS, answerProductQuestions));
 });
 //#endregion
@@ -1085,27 +1099,31 @@ const build = (options) => continuing(phase("build", requireCriteriaIfEdited), a
 		}
 	};
 });
-function implement(first, tier, amend) {
-	const options = typeof first === "object" && first !== null ? first : {
+async function implement(first, tier, amend) {
+	await implementing(typeof first === "object" && first !== null ? first : {
 		reference: first,
 		tier,
 		amend
-	};
-	return scope("implement", async () => {
-		const since = head();
-		const acceptance = options.rebuild?.acceptance;
-		const built = options.naive === void 0 || !await applied(options.naive);
-		if (built) await build(options);
-		else requireCriteriaFrozen(REQUIREMENTS);
-		if (built && acceptance !== void 0) requireAcceptance({
-			...acceptance,
-			ids: settled(acceptance.ids, options.slice)
-		}, since);
-		await green(built && acceptance !== void 0 ? () => requireAcceptanceKept(acceptance) : void 0);
-		await requireCoverage(options.base, options.slice);
-		await closing(options.more === true);
 	});
 }
+/** `implement`, resolving with the criterion IDs the requirements listed when it closed. */
+const implementing = (options) => scope("implement", async () => {
+	const since = head();
+	const acceptance = options.rebuild?.acceptance;
+	const built = options.naive === void 0 || !await applied(options.naive);
+	if (built) await build(options);
+	else requireCriteriaFrozen(REQUIREMENTS);
+	if (built && acceptance !== void 0) requireAcceptance({
+		...acceptance,
+		ids: settled(acceptance.ids, options.slice)
+	}, since);
+	await green(built && acceptance !== void 0 ? () => requireAcceptanceKept(acceptance) : void 0);
+	await requireCoverage(options.base, options.slice);
+	const ids = criterionIds(read(".gtd/REQUIREMENTS.md") ?? "");
+	await closing(moreToBuild(options.more));
+	return ids;
+});
+const moreToBuild = (more) => typeof more === "function" ? more() : more === true;
 /** The last slice's closing, for a last slice a steer left with no criterion to build. */
 const closeOut = () => scope("implement", () => closing(false));
 /** A slice with `more` after it keeps the criteria and the slicing for the next one. */
@@ -1340,32 +1358,37 @@ const unwind = () => {
 const buildFeature = async (firstBase) => {
 	const tier = riskTierOn() ? recordRisk() : void 0;
 	const slices = await slicing();
+	const handedOut = new Set(listedIds());
 	const one = slices.length === 1;
+	const built = (i) => sliceIds(sliceCriteria(slices, i))?.length !== 0;
 	for (const i of slices.keys()) {
-		const more = i < slices.length - 1;
-		const criteria = sliceCriteria(slices, i);
-		if (sliceIds(criteria)?.length === 0) {
-			if (!more) await closeOut();
-			continue;
-		}
+		if (!built(i)) continue;
 		const n = one ? "" : `-${i + 1}`;
 		await buildSlice(i === 0 ? firstBase : head(), {
 			tier,
-			criteria,
+			criteria: sliceCriteria(slices, i),
 			refactor: `refactor${n}`,
 			feature: `feature${n}`,
-			more
+			more: () => slices.some((_, j) => j > i && built(j)),
+			reviewBase: one ? void 0 : firstBase,
+			handedOut
 		});
 	}
 };
-/** A naive pass (judged only with `flagMode` on), then implement and the quality lap. */
+const listedIds = () => criterionIds(read(".gtd/REQUIREMENTS.md") ?? "");
+const gather = (handedOut) => {
+	for (const id of listedIds()) handedOut.add(id);
+	return [...handedOut];
+};
+/** A naive pass (judged only with `flagMode` on), then implement and the quality lap; after the last slice, the review. */
 const buildSlice = async (sliceBase, build) => {
 	const seam = await seamBuild(sliceBase, {
 		criteria: build.criteria,
 		refactor: build.refactor
 	});
+	const used = gather(build.handedOut);
 	await slice(build.feature, async () => {
-		await implement({
+		const closed = await implementing({
 			reference: seam.reference,
 			tier: build.tier,
 			afterRefactor: seam.refactored,
@@ -1375,14 +1398,23 @@ const buildSlice = async (sliceBase, build) => {
 			base: build.criteria === void 0 ? void 0 : sliceBase,
 			more: build.more
 		});
+		const more = build.more();
 		const carried = seam.rebuild?.acceptance?.tests ?? [];
 		const base = seam.refactored === true && !changesSince(seam.base).some((c) => isCode$1(c.path) && !carried.includes(c.path)) ? sliceBase : seam.base;
-		const guard = build.more ? () => requireCriteriaFrozen(REQUIREMENTS) : void 0;
-		await tail(settleQuality, {
-			green: true,
-			lensBase: base,
-			guard,
-			guardRests: false
+		if (more) {
+			const guard = () => requireCriteriaFrozen(REQUIREMENTS);
+			await tail(settleQuality, {
+				green: true,
+				lensBase: base,
+				guard,
+				guardRests: false
+			});
+			return;
+		}
+		const reviewBase = build.reviewBase ?? base;
+		await featureFeedback(await reviewedTail(reviewBase, base), base, {
+			closed,
+			used
 		});
 	});
 };
@@ -1398,6 +1430,35 @@ const settleQuality = async () => {
 	}
 	if (rested) await healthy(() => fixCheck());
 };
+/** The quality lap, then the human review since `base`. */
+const reviewedTail = (base, lensBase, lap) => tail(async (escalations) => {
+	await settleQuality();
+	return review(base, escalations, { lap });
+}, {
+	green: true,
+	lensBase
+});
+const featureFeedback = async (first, lensBase, ids) => {
+	let outcome = first;
+	let closed = ids.closed;
+	const handedOut = /* @__PURE__ */ new Set([...ids.used, ...ids.closed]);
+	while (outcome.verdict === "feedback") {
+		await reUnwind(outcome);
+		const lap = {
+			closed,
+			used: [...handedOut]
+		};
+		await design(outcome.base, () => {
+			requireStableIds(REQUIREMENTS, lap);
+			gather(handedOut);
+		});
+		closed = await implementing({
+			tier: riskTierOn() ? recordRisk() : void 0,
+			amend: true
+		});
+		outcome = await reviewedTail(outcome.base, lensBase, "feedback");
+	}
+};
 /** Design — skipped when the sketch's own criteria are judged clear — then `buildFeature`. */
 const planAndBuild = async (firstBase, stated) => {
 	if (!await skipDesign(riskTierOn() ? void 0 : stated)) await design(firstBase);
@@ -1444,4 +1505,4 @@ const feature = shipped(ordinaryStart);
 //#region src/workflows/feature/index.ts
 var feature_default = feature;
 //#endregion
-export { COMMENT, REFACTOR_PACKAGE, acceptanceFault, access, afterTail, answerProductQuestions, answerReviewQuestions, buildFeature, buildTail, closeOut, collecting, criteriaOf, criterionIds, feature_default as default, defaults, deferNotes, design, envDefaults, feature, fixNits, holdsCallSites, implement, isTestFile, judgeSeam, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, triage, unwind };
+export { COMMENT, REFACTOR_PACKAGE, acceptanceFault, access, afterTail, answerProductQuestions, answerReviewQuestions, buildFeature, buildTail, closeOut, collecting, criteriaOf, criterionIds, feature_default as default, defaults, deferNotes, design, envDefaults, feature, fixNits, holdsCallSites, implement, implementing, isTestFile, judgeSeam, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireStableIds, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, triage, unstableIds, unwind };

package/dist/workflows/fix.mjs

@@ -1,7 +1,7 @@
 import { read, refuse, removeScript, run, scope, start } from "../flows.mjs";
 import { d as reviewNotes, f as reviewRisks } from "../chunks/steering-DVILanVf.mjs";
-import { A as agentWithSkills, J as fixReviewNotesPrompt, S as coder, St as envDefaults, c as baseline, i as skills, n as summary, q as finisherSystem, r as access, s as shipped, t as steering, xt as defaults, y as REVIEW } from "../chunks/reserved-B6tTYjeb.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-_CZTP7Hu.mjs";
+import { A as agentWithSkills, J as fixReviewNotesPrompt, S as coder, St as envDefaults, c as baseline, i as skills, n as summary, q as finisherSystem, r as access, s as shipped, t as steering, xt as defaults, y as REVIEW } from "../chunks/reserved-Ch4LLrEj.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-lY1UmJrU.mjs";
 //#region src/workflows/fix/fix.ts
 /**
 * Fix every note a human left in a handed-off `.gtd/REVIEW.md` and every

package/dist/workflows/review.mjs

@@ -1,6 +1,6 @@
 import { start } from "../flows.mjs";
-import { St as envDefaults, dt as reviewGateBlockedMessage, i as skills, n as summary, r as access, s as shipped, t as steering, u as gate, xt as defaults } from "../chunks/reserved-B6tTYjeb.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-_CZTP7Hu.mjs";
+import { St as envDefaults, dt as reviewGateBlockedMessage, i as skills, n as summary, r as access, s as shipped, t as steering, u as gate, xt as defaults } from "../chunks/reserved-Ch4LLrEj.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-lY1UmJrU.mjs";
 //#region src/workflows/review/review.ts
 /**
 * Pure review of everything since `reviewBase`: a green gate, the quality

package/dist/workflows/rollout.mjs

@@ -1,5 +1,5 @@
 import { agent, changesSince, glob, head, mark, read, refuse, removeScript, run, scope, vars } from "../flows.mjs";
-import { Et as flipProblems, Ot as requireFlag, S as coder, St as envDefaults, i as skills, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, wt as flagMentions, xt as defaults } from "../chunks/reserved-B6tTYjeb.mjs";
+import { Et as flipProblems, Ot as requireFlag, S as coder, St as envDefaults, i as skills, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, wt as flagMentions, xt as defaults } from "../chunks/reserved-Ch4LLrEj.mjs";
 //#region src/workflows/rollout/rollout.ts
 const flippingPrompt = (name, registry) => `Roll out the release flag "${name}": in ${registry}, set \`defaultOn: true\` on its entry. Change nothing else — no other entry, no other field, no other file, no comments.`;
 const suiteBlockedMessage = () => "The suite is red after the rollout. Fix it by hand — a rollout may only touch the flag's registry entry — then land.";