@pmelab/gtd 39.0.0 → 40.0.0

package/dist/workflows.mjs

@@ -17233,14 +17233,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 +17278,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
@@ -38095,6 +38097,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 +38265,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 +39084,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 +39343,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 +39383,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 +39415,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 +39669,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": "40.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/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"
 

package/src/workflows/feature/feature.ts

@@ -9,13 +9,16 @@ import {
   slice,
   start,
 } from "../../flows/index.js"
-import { gate, healthy } from "../shared/health.js"
+import { gate, healthy, type EscalationCount } from "../shared/health.js"
 import { flagModeOn, shipped } from "../shared/options.js"
 import { FEEDBACK, fixCheck, QUALITY, REQUIREMENTS } from "../shared/steps.js"
 import { refusePendingHandOff, tail } from "../shared/tail.js"
 import * as t from "../shared/text.js"
 import {
+  criterionIds,
   requireCriteriaFrozen,
+  requireStableIds,
+  type StableIds,
   skipDesign,
   sliceIds,
   statedCriteria,
@@ -23,8 +26,8 @@ import {
   type StatedCriteria,
 } from "./criteria.js"
 import { design } from "./planning.js"
-import { buildTail, isCode, reUnwind, type ReviewOutcome } from "./review.js"
-import { closeOut, implement, seamBuild } from "./seam.js"
+import { buildTail, isCode, reUnwind, review, type ReviewOutcome } from "./review.js"
+import { implement, implementing, seamBuild } from "./seam.js"
 import { sliceCap, sliceCriteria, slicing } from "./slicing.js"
 import { recordRisk, riskTierOn, type RiskTier } from "./tier.js"
 
@@ -33,7 +36,9 @@ import { recordRisk, riskTierOn, type RiskTier } from "./tier.js"
 // green-baseline gate → design → per slice of the criteria, a naive pass,
 // judged with `flagMode` on: it lands as the implementation, or (refactoring
 // first when the judge asks) is built fresh from → the health loop → the
-// quality lap, and the episode ends back at `idle`. Human review is the `review` door's.
+// quality lap → after the last slice, human review of the whole change, which
+// signs off (the episode ends back at `idle`) or sends a design → implement
+// lap.
 
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
 export const unwind = (): Promise<void> => {
@@ -52,40 +57,54 @@ export { reUnwind }
 export const buildFeature = async (firstBase: string): Promise<void> => {
   const tier = riskTierOn() ? recordRisk() : undefined
   const slices = await slicing()
+  // Every ID handed out, gathered before a later narrowing can drop one: none is ever reused.
+  const handedOut = new Set(listedIds())
   // A single slice keeps the unnumbered names and builds against every criterion.
   const one = slices.length === 1
+  // A steer may delete every criterion of a later slice: there is nothing to build there.
+  const built = (i: number): boolean => sliceIds(sliceCriteria(slices, i))?.length !== 0
   for (const i of slices.keys()) {
-    const more = i < slices.length - 1
-    const criteria = sliceCriteria(slices, i)
-    // A steer may have deleted every criterion of a later slice: nothing to build.
-    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,
+      // A steer or a narrowing may empty every later slice.
+      more: () => slices.some((_, j) => j > i && built(j)),
+      // Every slice but the one is built unreviewed, so the review covers them all.
+      reviewBase: one ? undefined : firstBase,
+      handedOut,
     })
   }
 }
 
+const listedIds = (): readonly string[] => criterionIds(read(REQUIREMENTS) ?? "")
+
+const gather = (handedOut: Set<string>): readonly string[] => {
+  for (const id of listedIds()) handedOut.add(id)
+  return [...handedOut]
+}
+
 interface SliceBuild {
   readonly tier: RiskTier | undefined
   readonly criteria: CriteriaSlice | undefined
   readonly refactor: string
   readonly feature: string
-  readonly more: boolean
+  readonly more: () => boolean
+  /** Absent: the slice's own base. */
+  readonly reviewBase?: string | undefined
+  /** Every criterion ID handed out so far; the slice adds those a steer adds. */
+  readonly handedOut: Set<string>
 }
 
-/** A naive pass (judged only with `flagMode` on), then implement and the quality lap. */
+/** A naive pass (judged only with `flagMode` on), then implement and the quality lap; after the last slice, the review. */
 const buildSlice = async (sliceBase: string, build: SliceBuild): Promise<void> => {
   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,
@@ -95,6 +114,8 @@ const buildSlice = async (sliceBase: string, build: SliceBuild): Promise<void> =
       base: build.criteria === undefined ? undefined : sliceBase,
       more: build.more,
     })
+    // Closing kept the criteria exactly when there is more to build, so this reads as it did.
+    const more = build.more()
     // A feature slice with no code beyond the carried-over tests: the refactor carried the
     // feature, so the lap covers the whole slice.
     const carried = seam.rebuild?.acceptance?.tests ?? []
@@ -103,14 +124,19 @@ const buildSlice = async (sliceBase: string, build: SliceBuild): Promise<void> =
       !changesSince(seam.base).some((c) => isCode(c.path) && !carried.includes(c.path))
         ? sliceBase
         : seam.base
-    // The criteria stay in the tree for the next slice; no quality fix may move them.
-    const guard = build.more ? () => requireCriteriaFrozen(REQUIREMENTS) : undefined
-    await tail(settleQuality, { green: true, lensBase: base, guard, guardRests: false })
+    if (more) {
+      // The criteria stay in the tree for the next slice; no quality fix may move them.
+      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 })
   })
 }
 
-// The lap is feature's last look: findings the fix cap left must not end the process, nor reach
-// the next one's lap, which appends to the file. Empty counts as resolved, as the lap reads it.
+// The lap's findings the fix cap left must not reach the review, nor the next process's lap,
+// which appends to the file. Empty counts as resolved, as the lap reads it.
 const settleQuality = async (): Promise<void> => {
   let rested = false
   while ((read(QUALITY) ?? "").length > 0) {
@@ -121,10 +147,44 @@ const settleQuality = async (): Promise<void> => {
       file: QUALITY,
     })
   }
-  // The person may have fixed code by hand there; nothing else checks it before idle.
+  // The person may have fixed code by hand there; nothing else checks it before the review.
   if (rested) await healthy(() => fixCheck())
 }
 
+/** The quality lap, then the human review since `base`. */
+const reviewedTail = (base: string, lensBase: string, lap?: "feedback"): Promise<ReviewOutcome> =>
+  tail(
+    async (escalations: EscalationCount) => {
+      await settleQuality()
+      return review(base, escalations, { lap })
+    },
+    { green: true, lensBase },
+  )
+
+// seam.naive / seam.judge never run on a feedback lap: its design → implement is built unjudged
+// and unrefactored, held to every criterion's coverage since the process start.
+const featureFeedback = async (
+  first: ReviewOutcome,
+  lensBase: string,
+  ids: StableIds,
+): Promise<void> => {
+  let outcome = first
+  let closed = ids.closed
+  const handedOut = new Set([...ids.used, ...ids.closed])
+  while (outcome.verdict === "feedback") {
+    await reUnwind(outcome)
+    const lap = { closed, used: [...handedOut] }
+    // Gathered every round, so an ID one round adds and the next drops is never reused.
+    await design(outcome.base, () => {
+      requireStableIds(REQUIREMENTS, lap)
+      gather(handedOut)
+    })
+    const tier = riskTierOn() ? recordRisk() : undefined
+    closed = await implementing({ tier, amend: true })
+    outcome = await reviewedTail(outcome.base, lensBase, "feedback")
+  }
+}
+
 /** Design — skipped when the sketch's own criteria are judged clear — then `buildFeature`. */
 export const planAndBuild = async (firstBase: string, stated?: StatedCriteria): Promise<void> => {
   // GTD_FLAG_RISK_TIER: the tier is proposed at triage and set at the design gate, so no skip.

package/src/workflows/feature/flag-mode.feature

@@ -67,7 +67,7 @@ Feature: flag mode off lands the naive pass with no release flag, seam judge or
       """
     And step "build.quality.correctness.reviewing" changes nothing
     When the process is driven
-    Then the process rests at "idle"
+    Then the process rests at "build.review.reviewing"
     And "src/calc.ts" contains "subtract"
     And "src/calc.test.ts" contains "[AC-1] subtracts"
     And the commit subjects end with:
@@ -85,5 +85,5 @@ Feature: flag mode off lands the naive pass with no release flag, seam judge or
       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
       """

package/src/workflows/feature/one-step-land.feature

@@ -5,7 +5,7 @@ Feature: a naive pass the judge rules land is itself the implementation
   With GTD_FLAG_RISK_TIER off, a naive pass that
   edits an existing source file is judged land: the process skips the approval
   gate and any refactor, applies the kept pass as it is — no build turn — and
-  runs the health loop and quality back to idle, with no review. The flag is pinned here so the per-flag test runs never
+  runs the health loop and quality lap to the feature review. The flag is pinned here so the per-flag test runs never
   move it off this path.
 
   Background:
@@ -62,9 +62,9 @@ Feature: a naive pass the judge rules land is itself the implementation
       """
     And step "build.quality.correctness.reviewing" changes nothing
 
-  Scenario: a land judgment applies the naive pass and runs idle to idle with no rebuild
+  Scenario: a land judgment applies the naive pass and runs from idle to the review gate with no rebuild
     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 "src/acceptance.test.ts" contains "[AC-1] holds"
     And the commit subjects end with:
@@ -81,7 +81,7 @@ Feature: a naive pass the judge rules land is itself the implementation
       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 commit "gtd(human): idle → unwind" has a body containing "Gtd-Var: flag_risk_tier=0"
     And the commit "gtd(agent): seam.naive → seam.check" has a body containing "Gtd-Kept:"

package/src/workflows/feature/planning.ts

@@ -25,13 +25,14 @@ const noteGate = async (file: string, answer: () => Promise<void>): Promise<bool
   return true
 }
 
-/** Triage the sketch since `base` into requirements, until no product question is open. */
-export const design = (base: string): Promise<void> =>
+/** Triage the sketch since `base` into requirements, until no product question is open; `guard` holds every round's criteria. */
+export const design = (base: string, guard?: () => void): Promise<void> =>
   scope("design", async () => {
     do {
       await triage(base)
       requireProgress(REQUIREMENTS)
       requireReplies(REQUIREMENTS)
       requireCriteria(REQUIREMENTS)
+      guard?.()
     } while (await noteGate(REQUIREMENTS, answerProductQuestions))
   })