@pmelab/gtd 39.0.0 → 41.0.0

package/dist/workflows.mjs

@@ -456,13 +456,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$1(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$1 = async (fix, health) => {
 	let fixes = health.fixesSoFar ?? 0;
+	let cap = health.fixCap;
 	let previous;
 	for (;;) {
 		if (await health.check()) {
@@ -470,17 +490,15 @@ const healthy$1 = 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$1(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();
@@ -17233,14 +17251,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.
@@ -17278,8 +17296,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
@@ -18446,7 +18466,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$1 = async (previous, current) => {
 	const comparable = current.trim() !== "" && previous.trim() !== "";
 	const { answers, truncated } = await judge("health.judge", {
 		questions: [retryQuestion(comparable)],
@@ -18457,7 +18477,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 ?? "", {
@@ -18468,7 +18491,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), {
@@ -18476,7 +18500,7 @@ const healthy = (fix, options = {}) => healthy$1(guarded(fix, options.guard), {
 	report: FEEDBACK,
 	fixCap: 3,
 	fixesSoFar: options.fixesSoFar ?? 0,
-	sameFailure,
+	compare: compare$1,
 	escalations: options.escalations ?? { rounds: 0 },
 	recheck: () => recheck("health.recheck", "health.check", { sweepOnGreen: healthSweep(options) }),
 	escalation: guardedSteps(options.guard, options.describeGuard, options.guardRests, options.rules)
@@ -38095,6 +38119,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);
@@ -38250,13 +38287,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
@@ -39068,27 +39106,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$1();
-		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$1();
+	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. */
@@ -39323,32 +39365,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$1(), {
 			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,
@@ -39358,14 +39405,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
 		});
 	});
 };
@@ -39381,6 +39437,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$1(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);
@@ -39606,4 +39691,4 @@ var workflows_default = feature;
 */
 const doors = {};
 //#endregion
-export { COMMENT, ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, HANDOFF, QUALITY, REFACTOR, REFACTOR_NOTE, REFACTOR_PACKAGE, REQUIREMENTS, REVIEW, REVIEW_ORIG, SLICES, ShippedOptions, acceptanceFault, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, awaitReview, base, baseline, buildFeature, buildTail, builtInLenses, cleanup, cleanupFlow, closeOut, closeReview, coder, collecting, criteriaOf, criterionIds, workflows_default as default, defaults, deferNotes, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, holdsCallSites, implement, isTestFile, judgeSeam, lensEntriesOf, lensOf, lensesOf, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, recheck, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireTestCallSitesOnly, requireWithin, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewedRefactor, reviewing, rollout, rolloutFlow, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, tail, threads, triage, unwind };
+export { COMMENT, ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, HANDOFF, QUALITY, REFACTOR, REFACTOR_NOTE, REFACTOR_PACKAGE, REQUIREMENTS, REVIEW, REVIEW_ORIG, SLICES, ShippedOptions, acceptanceFault, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, awaitReview, base, baseline, buildFeature, buildTail, builtInLenses, cleanup, cleanupFlow, closeOut, closeReview, coder, collecting, criteriaOf, criterionIds, workflows_default as default, defaults, deferNotes, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, holdsCallSites, implement, implementing, isTestFile, judgeSeam, lensEntriesOf, lensOf, lensesOf, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, recheck, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireStableIds, requireTestCallSitesOnly, requireWithin, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewedRefactor, reviewing, rollout, rolloutFlow, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, tail, threads, triage, unstableIds, unwind };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "39.0.0",
+  "version": "41.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/skills/authoring/SKILL.md

@@ -224,8 +224,9 @@ workflow.
 
 In the bundled default, `planAndBuild` runs the design phase, then
 `buildFeature`: the naive pass and its seam judge, then the implementation (the
-pass itself on `land`) and the quality lap, ending with no human review. Add a
-human sign-off before the build:
+pass itself on `land`), the quality lap and the human review (a review feedback
+lap re-runs design inside `buildFeature` and does not pass it again). Add a
+human sign-off before the first build:
 
 ```ts
 const planAndBuild = async (firstBase: string): Promise<void> => {

package/src/workflow-kit/health.ts

@@ -32,6 +32,8 @@ export const untilSettled = async (
   }
 }
 
+export type RetryVerdict = "identical" | "progress"
+
 export interface Health {
   /** One counted run of the suite; resolves `true` when green. */
   readonly check: () => Promise<boolean>
@@ -39,8 +41,8 @@ export interface Health {
   readonly report: string
   readonly fixCap: number
   readonly fixesSoFar?: number
-  /** Whether two consecutive red reports are the same failure; `true` escalates at once. */
-  readonly sameFailure: (previous: string, current: string) => Promise<boolean>
+  /** How a red report compares to the previous round's: `identical` escalates at once, `progress` at the cap earns one extra fix. */
+  readonly compare: (previous: string, current: string) => Promise<RetryVerdict | undefined>
   /** Shared with other callers in the same run of red checks. */
   readonly escalations: EscalationCount
   readonly escalation: EscalationSteps
@@ -58,13 +60,42 @@ const recheckReport = async (health: Health): Promise<true | string | undefined>
   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: Health, current: string): Promise<true | string> => {
+  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: Health,
+  fixes: number,
+  cap: number,
+  previous: string | undefined,
+  current: string,
+): Promise<"extend" | "escalate" | undefined> => {
+  const capped = fixes >= cap
+  // Past a raised cap the loop escalates whatever the judge would answer.
+  if (capped && cap > health.fixCap) return "escalate"
+  const verdict = previous === undefined ? undefined : await health.compare(previous, current)
+  if (capped && verdict === "progress") return "extend"
+  return verdict === "identical" || capped ? "escalate" : undefined
+}
+
 /**
  * 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.
  */
 export const healthy = async (fix: () => Promise<void>, health: Health): Promise<void> => {
   let fixes = health.fixesSoFar ?? 0
+  let cap = health.fixCap
   let previous: string | undefined
   for (;;) {
     if (await health.check()) {
@@ -72,17 +103,15 @@ export const healthy = async (fix: () => Promise<void>, health: Health): Promise
       return
     }
     const current = stripStamp(read(health.report) ?? "")
-    const stuck = previous !== undefined && (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/src/workflows/feature/coverage.feature

@@ -55,19 +55,19 @@ Feature: a feature is done only when every acceptance criterion has a passing te
     And the output of gtd "judge" contains "add is unchanged."
     And the output of gtd "judge" contains "[AC-1] subtracts"
 
-  Scenario: every ID covered ends the feature and marks the IDs it covers
+  Scenario: every ID covered moves on to the review and marks the IDs it covers
     Given judge step "implement.coverage" answers:
       """
       [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"yes","p":0.9}]
       """
     When the process is driven
-    Then the process rests at "idle"
+    Then the process rests at "build.review.reviewing"
     And the commit subjects end with:
       """
       gtd(check): implement.applying → implement.health.check
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
-      gtd(check): implement.closing → idle
+      gtd(check): implement.closing → build.review.reviewing
       """
     And the commit "gtd(judge): implement.coverage → implement.closing" has a body containing "Gtd-Mark: covers=AC-1"
     And the commit "gtd(judge): implement.coverage → implement.closing" has a body containing "Gtd-Mark: covers=AC-2"
@@ -132,7 +132,7 @@ Feature: a feature is done only when every acceptance criterion has a passing te
       """
     Then driving the process is refused with "criteria-frozen"
 
-  Scenario: overruling at the gate ends the feature, recording the uncovered IDs
+  Scenario: overruling at the gate moves on to the review, recording the uncovered IDs
     Given judge step "implement.coverage" answers:
       """
       [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"no","p":0.9}]
@@ -144,7 +144,7 @@ Feature: a feature is done only when every acceptance criterion has a passing te
       """
     And step "implement.uncovered" changes nothing
     When the process is driven
-    Then the process rests at "idle"
+    Then the process rests at "build.review.reviewing"
     And the commit "gtd(human): implement.uncovered → implement.closing" has a body containing "Gtd-Mark: covers=AC-1"
     And the commit "gtd(human): implement.uncovered → implement.closing" has a body containing "Gtd-Mark: uncovered=AC-2"
 

package/src/workflows/feature/criteria.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest"
 import type { Change } from "../../flows/index.js"
-import { criteriaOf, criterionIds, statedCriteria } from "./criteria.js"
+import { criteriaOf, criterionIds, statedCriteria, unstableIds } from "./criteria.js"
 
 const added = (path: string, after: string): Change => ({
   path,
@@ -120,3 +120,22 @@ describe("criterionIds", () => {
     expect(criterionIds(requirements, { except: ["AC-1", "AC-3"] })).toEqual(["AC-2", "AC-4"])
   })
 })
+
+describe("unstableIds", () => {
+  const ids = { closed: ["AC-1", "AC-3"], used: ["AC-1", "AC-2", "AC-3"] }
+
+  it("accepts built IDs kept or dropped and new ones numbered above all handed out", () => {
+    expect(unstableIds(["AC-3", "AC-4", "AC-7"], ids)).toBeUndefined()
+    expect(unstableIds([], ids)).toBeUndefined()
+  })
+
+  it("names a new ID that reuses a number handed out before, even a narrowed-away one", () => {
+    expect(unstableIds(["AC-1", "AC-2", "AC-3"], ids)).toMatch(
+      /^numbers AC-2 at or below AC-3, .* from AC-4$/,
+    )
+  })
+
+  it("names every reused ID", () => {
+    expect(unstableIds(["AC-0", "AC-2"], ids)).toMatch(/^numbers AC-0, AC-2 at or below AC-3/)
+  })
+})

package/src/workflows/feature/criteria.ts

@@ -151,6 +151,30 @@ export const requireCriteria = (file: string): void => {
   )
 }
 
+/** The IDs a review's feedback lap must respect. */
+export interface StableIds {
+  /** Listed when the build closed: each may stay, reworded or not, or go. */
+  readonly closed: readonly string[]
+  /** Every ID handed out so far: any other is numbered above all of them. */
+  readonly used: readonly string[]
+}
+
+const idNumber = (id: string): number => Number(id.slice("AC-".length))
+
+/** Why `listed` renumbers or reuses an earlier ID; `undefined` when it does neither. */
+export const unstableIds = (listed: readonly string[], ids: StableIds): string | undefined => {
+  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 undefined
+  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. */
+export const requireStableIds = (file: string, ids: StableIds): void => {
+  const why = unstableIds(criterionIds(read(file) ?? ""), ids)
+  if (why !== undefined) 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. */
 export const requireCriteriaFrozen = (file: string): void => {
   const change = changes().get(file)

package/src/workflows/feature/fast-path.feature

@@ -3,7 +3,7 @@ Feature: a trivial change takes the same few beats at either risk tier
 
   With GTD_FLAG_RISK_TIER on, a one-line copy fix goes
   from idle through the naive pass, the seam judge's land, the applied pass and
-  the quality lap back to idle. Low tier walks exactly the steps high does; only
+  the quality lap to the review gate. Low tier walks exactly the steps high does; only
   the summary differs.
 
   Background:
@@ -32,7 +32,7 @@ Feature: a trivial change takes the same few beats at either risk tier
       """
     And step "build.quality.correctness.reviewing" changes nothing
 
-  Scenario Outline: a one-line fix runs idle to idle with the same beats at either tier
+  Scenario Outline: a one-line fix runs from idle to the review gate with the same beats at either tier
     Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
       """
       # Requirements
@@ -64,7 +64,7 @@ Feature: a trivial change takes the same few beats at either risk tier
       """
     And step "implement.applying" runs its script
     When the process is driven
-    Then the process rests at "idle"
+    Then the process rests at "build.review.reviewing"
     And "src/greeting.ts" contains "Hello, world"
     And the commit subjects end with:
       """
@@ -80,7 +80,7 @@ Feature: a trivial change takes the same few beats at either risk tier
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → idle
+      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
       """
     And the output of gtd "summary" <summary> "needs a human reviewer"