@pmelab/gtd 29.2.3 → 29.2.5

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "29.2.3",
+  "version": "29.2.5",
   "description": "Drive the gtd loop inside Claude Code: agent turns run as subagents, gtd decides every beat",
   "author": {
     "name": "Philipp Melab"

package/README.md

@@ -341,15 +341,16 @@ wait for the next rest. When the process finishes, Claude offers to squash it
 and open its pull request(s) (or run `/gtd ship`; `GTD_SHIP_MODE` picks one
 stacked pull request per slice or one commit per slice, see the
 [driver doc](docs/driver.md)); a process started for an issue ships with
-`Closes #N` on its top pull request; re-running `/gtd ship` after a lower
-stacked pull request merged restacks the rest (it refuses, with nothing changed,
-when that pull request merged anywhere but the default branch (unless into a
-lower slice branch before that one merged into it), a slice branch is checked
-out in another worktree, an unrelated local branch sits inside the rebased
-commits, or a slice's change is already upstream; a failed rebase is rolled
-back). A process can change hands at any gate: ask Claude to hand it off (or run
-`/gtd throw @dev`) and it opens a draft pull request assigned to them, and
-`/gtd catch <pr>` picks it up exactly where it waits, so whoever wrote the
+`Closes #N` on its top pull request; a closed pull request whose branch was
+deleted from origin is left behind and a new one opens; re-running `/gtd ship`
+after a lower stacked pull request merged restacks the rest (it refuses, with
+nothing changed, when that pull request merged anywhere but the default branch
+(unless into a lower slice branch before that one merged into it), a slice
+branch is checked out in another worktree, an unrelated local branch sits inside
+the rebased commits, or a slice's change is already upstream; a failed rebase is
+rolled back). A process can change hands at any gate: ask Claude to hand it off
+(or run `/gtd throw @dev`) and it opens a draft pull request assigned to them,
+and `/gtd catch <pr>` picks it up exactly where it waits, so whoever wrote the
 requirements can hand the architecture to someone else. Ship, hand-off and throw
 answer at once and run in the background, with progress on the status line; they
 report by waking Claude, a toast, a transcript line and a push notification, and
@@ -586,9 +587,11 @@ directly. A judge checks whether it changed anything outside the expected set
 change is refactored first, in its own slice with its own quality lap
 (`refactorQualityReviews`) and review, before the feature is implemented and
 reviewed; a wrong approach is retried twice, then rests for you to steer or
-overrule it. `gtd slices` lists the `refactor` and `feature` slices. 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
+overrule it. `gtd slices` lists the `refactor` and `feature` slices. A refactor
+that already carried the whole feature leaves the implementation nothing to do:
+its empty turn passes, and the feature review covers the whole change. 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

package/claude/hooks/ship.ts

@@ -633,7 +633,13 @@ export const NO_PR_FOUND = "no pull requests found"
 
 // `gh pr view <branch>`: only NO_PR_FOUND reads as none; any
 // other failure (auth, network) must refuse, or ship would open a duplicate PR.
-async function viewPr(io: ShipIo, branch: string): Promise<View | undefined | string> {
+// A closed PR whose branch origin lost is an abandoned earlier ship and reads as
+// none; `abandoned` is recorded before the push so a retry, with origin holding
+// the branch again, still reads it as none. `gone`: a tracking ref is stale.
+async function readPr(
+  io: ShipIo,
+  branch: string,
+): Promise<{ view?: View; gone?: boolean; abandoned?: number } | string> {
   const v = await io.run([
     "gh",
     "pr",
@@ -643,14 +649,41 @@ async function viewPr(io: ShipIo, branch: string): Promise<View | undefined | st
     "number,title,body,url,state,baseRefName,mergedAt",
   ])
   if (v.code !== 0) {
-    if (v.err.includes(NO_PR_FOUND)) return undefined
+    if (v.err.includes(NO_PR_FOUND)) return {}
     return `gh pr view ${branch} failed: ${v.err.trim()}`
   }
+  let view: View
   try {
-    return JSON.parse(v.out) as View
+    view = JSON.parse(v.out) as View
   } catch {
     return `gh pr view ${branch} returned something unreadable.`
   }
+  if (view.state !== "CLOSED") return { view }
+  const key = await io.run(["git", "config", "--local", "--get", ABANDONED_KEY(branch)])
+  const recorded = key.out.trim() === String(view.number)
+  const ls = await io.run(["git", "ls-remote", "origin", `refs/heads/${branch}`])
+  const gone = ls.code === 0 && !ls.out.trim()
+  if (recorded) return { gone }
+  return gone ? { gone, abandoned: view.number } : { view }
+}
+
+const ABANDONED_KEY = (branch: string) => `branch.${branch}.gtdAbandonedPr`
+
+// Once the new PR opens, gh pr view finds it: the record has served its purpose.
+async function settled<T extends Shipped>(io: ShipIo, branch: string, done: T) {
+  if (done.ok) await io.run(["git", "config", "--local", "--unset", ABANDONED_KEY(branch)])
+  return done
+}
+
+async function abandon(io: ShipIo, branch: string, pr: number | undefined) {
+  if (pr === undefined) return undefined
+  const set = await io.run(["git", "config", "--local", ABANDONED_KEY(branch), String(pr)])
+  return set.code === 0 ? undefined : `git config failed.\n${set.err}`.trimEnd()
+}
+
+async function viewPr(io: ShipIo, branch: string): Promise<View | undefined | string> {
+  const read = await readPr(io, branch)
+  return typeof read === "string" ? read : read.view
 }
 
 // `dead` names belong to a retired record gtd built itself: not a collision.
@@ -1512,10 +1545,13 @@ async function shipLink(
   const l = links[i]!
   const lower = i ? links[i - 1]! : undefined
   const base = baseOf(links, i, baseBranch)
-  const view = await viewPr(io, l.branch)
-  if (typeof view === "string")
-    return { step: "pull request", why: `${view} ${l.branch} was not pushed; /gtd ship retries.` }
-  const pushed = await pushLink(io, git, l, i < links.length - 1)
+  const read = await readPr(io, l.branch)
+  if (typeof read === "string")
+    return { step: "pull request", why: `${read} ${l.branch} was not pushed; /gtd ship retries.` }
+  const { view, gone } = read
+  const marked = await abandon(io, l.branch, read.abandoned)
+  if (marked) return { step: "push", why: marked }
+  const pushed = await pushLink(io, git, { ...l, fresh: l.fresh || gone }, i < links.length - 1)
   if (pushed) return { step: "push", why: pushed }
   const lowerRef = lower?.branch ?? baseRef
   const ctx: Ctx = {
@@ -1528,6 +1564,7 @@ async function shipLink(
   }
   const done = await sliceStep(io, git, ok, l, view, base, lowerRef, ctx)
   if ("step" in done) return done
+  if (!view) await settled(io, l.branch, done)
   if (done.number === undefined && i < links.length - 1)
     return { step: "pull request", why: "its number could not be read from gh's reply." }
   return done
@@ -1764,17 +1801,24 @@ async function pullRequest(
   if (mergeBase === (await git("rev-parse", "HEAD")))
     return fail(`HEAD is an ancestor of ${baseRef}: nothing to describe.`)
 
-  const existing = await viewPr(io, branch)
-  if (typeof existing === "string")
+  const read = await readPr(io, branch)
+  if (typeof read === "string")
     return fail(
-      `${existing} ${branch} was not pushed; the squash and history ref stay, /gtd ship retries.`,
+      `${read} ${branch} was not pushed; the squash and history ref stay, /gtd ship retries.`,
     )
+  const { view: existing, gone } = read
   if (existing && existing.state !== "OPEN")
     return fail(`The pull request for ${branch} is ${existing.state}, not open.`)
-  const pushed = await pushBranch(io, branch)
+  const marked = await abandon(io, branch, read.abandoned)
+  if (marked) return fail(`${marked} ${branch} was not pushed; /gtd ship retries.`)
+  const pushed = await pushBranch(io, branch, "HEAD", undefined, gone)
   if (pushed) return fail(pushed)
   if (!existing)
-    return createPr(io, git, branch, baseBranch, baseRef, { from: mergeBase, to: "HEAD" })
+    return settled(
+      io,
+      branch,
+      await createPr(io, git, branch, baseBranch, baseRef, { from: mergeBase, to: "HEAD" }),
+    )
   // A branch once shipped as a stack keeps the PR aimed at a slice branch; any
   // other base is the author's own and stays.
   const onSlice = recorded.some((n) => existing.baseRefName === `${branch}-${n}`)

package/dist/chunks/{reserved-BduvUQxQ.mjs → reserved-C7JrDBnQ.mjs}

@@ -1365,9 +1365,12 @@ re-implement. It changed these files outside the expected set:
 ${listed(rejection.strays)}
 Start over and choose a different approach; do not rebuild the same diff.
 `}`;
-const implementBuildingPrompt = (reference, tier, amend) => `${stateFileRules}
+const implementBuildingPrompt = (reference, tier, amend, afterRefactor) => `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
-${amend === true ? `- The change already exists in the tree from an earlier lap; amend it to meet
+${afterRefactor === true ? `- A reviewed refactor has just landed and may already carry part of the change,
+  though never a release flag. Build only what is still missing, held to every
+  rule below; if nothing is, change nothing and finish your turn
+` : ""}${amend === true ? `- The change already exists in the tree from an earlier lap; amend it to meet
   the re-derived requirements instead of rewriting it
 ` : `- Implement them properly, fitting the codebase's seams and conventions
 `}${reference === void 0 || amend === true ? "" : `- Reference only: \`git show ${reference}\` shows an earlier naive attempt.

package/dist/chunks/{tail-pgq1Fbbv.mjs → tail-JAC-v_TW.mjs}

@@ -1,6 +1,6 @@
 import { read, refuse, removeScript, run, scope, showScript, vars } from "../flows.mjs";
 import { fixFindings, lensesOf, qualityLap as qualityLap$1, reviewToHandOff } from "../workflow-kit.mjs";
-import { E as reviewing, S as fixRisks, T as reviewQuality, W as handOffAwaitReviewMessage, _ as REVIEW, b as fixCheck, c as escalation, d as healthy, m as QUALITY, u as guarded, v as awaitReview, w as reviewMissing, x as fixQuality } from "./reserved-BduvUQxQ.mjs";
+import { E as reviewing, S as fixRisks, T as reviewQuality, W as handOffAwaitReviewMessage, _ as REVIEW, b as fixCheck, c as escalation, d as healthy, m as QUALITY, u as guarded, v as awaitReview, w as reviewMissing, x as fixQuality } from "./reserved-C7JrDBnQ.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/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { _t as registryEntry, a as flagShipped, dt as defaults, ft as envDefaults, ht as flagReferences, i as skills, n as summary, r as access, t as steering, vt as requireFlag, y as coder } from "../chunks/reserved-BduvUQxQ.mjs";
-import { i as refusePendingHandOff, r as handOffTail } from "../chunks/tail-pgq1Fbbv.mjs";
+import { _t as registryEntry, a as flagShipped, dt as defaults, ft as envDefaults, ht as flagReferences, i as skills, n as summary, r as access, t as steering, vt as requireFlag, y as coder } from "../chunks/reserved-C7JrDBnQ.mjs";
+import { i as refusePendingHandOff, r as handOffTail } from "../chunks/tail-JAC-v_TW.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 { answered, changes, changesSince, glob, 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 } from "../flows.mjs";
 import { lensesOf, review as review$1 } from "../workflow-kit.mjs";
-import { $ as refactorFixPrompt, A as architectureDecomposePrompt, B as designSystem, C as planner, D as agentWithSkills, E as reviewing, F as buildReviewFixNitsPrompt, G as idleMessage, I as buildReviewTriageMessage, J as naivePassPrompt, K as implementBuildingPrompt, L as builderSystem, M as buildReviewAnswerQuestionsPrompt, N as buildReviewAwaitAfterDeferMessage, O as architectSystem, P as buildReviewCollectingPrompt, Q as refactorDroppedRefusal, R as deferNotesScript, S as fixRisks, V as designTriagePrompt, X as packagesItemFixSuitePrompt, Y as packagesItemBuildingPrompt, Z as refactorBuildingPrompt, _ as REVIEW, at as reviewerSystem, b as fixCheck, ct as startGateBlockedMessage, d as healthy, dt as defaults, et as refactorRules, f as ARCHITECTURE, ft as envDefaults, g as REQUIREMENTS, h as REFACTOR, i as skills, it as reviewNotesCapture, j as architectureGateAnswerMessage, k as architectureAuthorPrompt, l as gate, lt as unwindFailedMessage, n as summary, nt as reviewEditsCapture, o as shipped, ot as seamByHandMessage, p as FEEDBACK, pt as testFileGlobs, q as implementFixPrompt, r as access, st as seamSteerMessage, t as steering, tt as reviewEditNotesCapture, u as guarded, ut as unwindFailure, v as awaitReview, w as reviewMissing, y as coder, z as designGateAnswerMessage } from "../chunks/reserved-BduvUQxQ.mjs";
-import { a as tail, i as refusePendingHandOff, n as closeReview } from "../chunks/tail-pgq1Fbbv.mjs";
+import { $ as refactorFixPrompt, A as architectureDecomposePrompt, B as designSystem, C as planner, D as agentWithSkills, E as reviewing, F as buildReviewFixNitsPrompt, G as idleMessage, I as buildReviewTriageMessage, J as naivePassPrompt, K as implementBuildingPrompt, L as builderSystem, M as buildReviewAnswerQuestionsPrompt, N as buildReviewAwaitAfterDeferMessage, O as architectSystem, P as buildReviewCollectingPrompt, Q as refactorDroppedRefusal, R as deferNotesScript, S as fixRisks, V as designTriagePrompt, X as packagesItemFixSuitePrompt, Y as packagesItemBuildingPrompt, Z as refactorBuildingPrompt, _ as REVIEW, at as reviewerSystem, b as fixCheck, ct as startGateBlockedMessage, d as healthy, dt as defaults, et as refactorRules, f as ARCHITECTURE, ft as envDefaults, g as REQUIREMENTS, h as REFACTOR, i as skills, it as reviewNotesCapture, j as architectureGateAnswerMessage, k as architectureAuthorPrompt, l as gate, lt as unwindFailedMessage, n as summary, nt as reviewEditsCapture, o as shipped, ot as seamByHandMessage, p as FEEDBACK, pt as testFileGlobs, q as implementFixPrompt, r as access, st as seamSteerMessage, t as steering, tt as reviewEditNotesCapture, u as guarded, ut as unwindFailure, v as awaitReview, w as reviewMissing, y as coder, z as designGateAnswerMessage } from "../chunks/reserved-C7JrDBnQ.mjs";
+import { a as tail, i as refusePendingHandOff, n as closeReview } from "../chunks/tail-JAC-v_TW.mjs";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {
 	let fence;
@@ -475,16 +475,26 @@ const review = (base, escalations = { rounds: 0 }, options = {}) => {
 		}
 	});
 };
-function buildTail(first, second, third = false, fourth = {}) {
-	if (typeof first !== "string" && typeof first !== "boolean" && typeof second !== "string") return Promise.reject(/* @__PURE__ */ new Error("buildTail takes buildTail(base, options?) or the deprecated buildTail(fixFirst, base, green?, options?); this call fits neither"));
-	const [base, options] = typeof first === "string" ? [first, second ?? {}] : [second, {
-		...fourth,
-		fixFirst: first,
-		green: third
-	}];
-	const { fixFirst, green, ...reviewOptions } = options;
-	return tail(fixFirst ?? false, (escalations) => review(base, escalations, reviewOptions), green ?? false, options.guard, options.lenses, options.guardRests, options.lensBase, options.rules);
+function buildTail(first, second, ...rest) {
+	const options = callForm(first, second, rest);
+	if (options === void 0) return Promise.reject(/* @__PURE__ */ new Error("buildTail takes buildTail(base, options?) or the deprecated buildTail(fixFirst, base, green?, options?); this call fits neither"));
+	const [base, form] = options;
+	const { fixFirst, green, ...reviewOptions } = form;
+	return tail(fixFirst ?? false, (escalations) => review(base, escalations, reviewOptions), green ?? false, form.guard, form.lenses, form.guardRests, form.lensBase, form.rules);
 }
+const isOptionalObject = (value) => value == null || typeof value === "object" && !Array.isArray(value) && typeof value.then !== "function";
+const isOptionalBoolean = (value) => value == null || typeof value === "boolean";
+const legacyForm = (fixFirst, base, green, options) => isOptionalBoolean(fixFirst) && isOptionalBoolean(green) && isOptionalObject(options) ? [base, {
+	...options,
+	fixFirst: fixFirst ?? void 0,
+	green: green ?? void 0
+}] : void 0;
+const currentForm = (base, options, third, fourth) => isOptionalObject(options) && third == null && fourth == null ? [base, options ?? {}] : void 0;
+const callForm = (first, second, [third, fourth, ...extra]) => {
+	if (extra.some((value) => value != null)) return void 0;
+	if (typeof second === "string") return legacyForm(first, second, third, fourth);
+	if (typeof first === "string") return currentForm(first, second, third, fourth);
+};
 /**
 * Undo the human's review-round code edits. A path changed since the human
 * left it is not overwritten; requireRevert names it instead.
@@ -764,10 +774,11 @@ function implement(first, tier, amend) {
 		amend
 	};
 	return scope("implement", async () => {
-		await agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend), {
+		await agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend, options.afterRefactor), {
 			label: "Implementing",
 			model: coder(),
-			system: builderSystem()
+			system: builderSystem(),
+			...options.afterRefactor === true ? { allowEmpty: true } : {}
 		});
 		await healthy(() => agentWithSkills("fix.suite.fixing", implementFixPrompt(), {
 			label: "Fixing the check",
@@ -830,10 +841,11 @@ const seamBuild = async (base) => {
 		reference,
 		base
 	};
-	await slice("refactor", () => reviewedRefactor(shape, { reference }));
+	const refactored = await slice("refactor", () => reviewedRefactor(shape, { reference }));
 	return {
 		reference,
-		base: head()
+		base: head(),
+		refactored
 	};
 };
 //#endregion
@@ -869,12 +881,14 @@ const naivePlanAndBuild = async (firstBase) => {
 	await slice("feature", async () => {
 		await implement({
 			reference: seam.reference,
-			tier
+			tier,
+			afterRefactor: seam.refactored
 		});
-		await featureFeedback(await buildTail(seam.base, {
+		const base = seam.refactored === true && !changesSince(seam.base).some((c) => isCode$1(c.path)) ? firstBase : seam.base;
+		await featureFeedback(await buildTail(base, {
 			green: true,
-			lensBase: seam.base
-		}), seam.base);
+			lensBase: base
+		}), base);
 	});
 };
 const featureFeedback = async (first, lensBase) => {

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 { D as agentWithSkills, H as finisherSystem, U as fixReviewNotesPrompt, _ as REVIEW, dt as defaults, ft as envDefaults, i as skills, n as summary, o as shipped, r as access, s as baseline, t as steering, y as coder } from "../chunks/reserved-BduvUQxQ.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-pgq1Fbbv.mjs";
+import { D as agentWithSkills, H as finisherSystem, U as fixReviewNotesPrompt, _ as REVIEW, dt as defaults, ft as envDefaults, i as skills, n as summary, o as shipped, r as access, s as baseline, t as steering, y as coder } from "../chunks/reserved-C7JrDBnQ.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-JAC-v_TW.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 { dt as defaults, ft as envDefaults, i as skills, l as gate, n as summary, o as shipped, r as access, rt as reviewGateBlockedMessage, t as steering } from "../chunks/reserved-BduvUQxQ.mjs";
-import { i as refusePendingHandOff, r as handOffTail } from "../chunks/tail-pgq1Fbbv.mjs";
+import { dt as defaults, ft as envDefaults, i as skills, l as gate, n as summary, o as shipped, r as access, rt as reviewGateBlockedMessage, t as steering } from "../chunks/reserved-C7JrDBnQ.mjs";
+import { i as refusePendingHandOff, r as handOffTail } from "../chunks/tail-JAC-v_TW.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 { a as flagShipped, dt as defaults, ft as envDefaults, gt as flipProblems, i as skills, l as gate, mt as flagMentions, n as summary, p as FEEDBACK, r as access, t as steering, vt as requireFlag, y as coder } from "../chunks/reserved-BduvUQxQ.mjs";
+import { a as flagShipped, dt as defaults, ft as envDefaults, gt as flipProblems, i as skills, l as gate, mt as flagMentions, n as summary, p as FEEDBACK, r as access, t as steering, vt as requireFlag, y as coder } from "../chunks/reserved-C7JrDBnQ.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.";

package/dist/workflows.mjs

@@ -18149,9 +18149,12 @@ re-implement. It changed these files outside the expected set:
 ${listed(rejection.strays)}
 Start over and choose a different approach; do not rebuild the same diff.
 `}`;
-const implementBuildingPrompt = (reference, tier, amend) => `${stateFileRules}
+const implementBuildingPrompt = (reference, tier, amend, afterRefactor) => `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
-${amend === true ? `- The change already exists in the tree from an earlier lap; amend it to meet
+${afterRefactor === true ? `- A reviewed refactor has just landed and may already carry part of the change,
+  though never a release flag. Build only what is still missing, held to every
+  rule below; if nothing is, change nothing and finish your turn
+` : ""}${amend === true ? `- The change already exists in the tree from an earlier lap; amend it to meet
   the re-derived requirements instead of rewriting it
 ` : `- Implement them properly, fitting the codebase's seams and conventions
 `}${reference === void 0 || amend === true ? "" : `- Reference only: \`git show ${reference}\` shows an earlier naive attempt.
@@ -38312,16 +38315,26 @@ const review$1 = (base, escalations = { rounds: 0 }, options = {}) => {
 		}
 	});
 };
-function buildTail(first, second, third = false, fourth = {}) {
-	if (typeof first !== "string" && typeof first !== "boolean" && typeof second !== "string") return Promise.reject(/* @__PURE__ */ new Error("buildTail takes buildTail(base, options?) or the deprecated buildTail(fixFirst, base, green?, options?); this call fits neither"));
-	const [base, options] = typeof first === "string" ? [first, second ?? {}] : [second, {
-		...fourth,
-		fixFirst: first,
-		green: third
-	}];
-	const { fixFirst, green, ...reviewOptions } = options;
-	return tail(fixFirst ?? false, (escalations) => review$1(base, escalations, reviewOptions), green ?? false, options.guard, options.lenses, options.guardRests, options.lensBase, options.rules);
+function buildTail(first, second, ...rest) {
+	const options = callForm(first, second, rest);
+	if (options === void 0) return Promise.reject(/* @__PURE__ */ new Error("buildTail takes buildTail(base, options?) or the deprecated buildTail(fixFirst, base, green?, options?); this call fits neither"));
+	const [base, form] = options;
+	const { fixFirst, green, ...reviewOptions } = form;
+	return tail(fixFirst ?? false, (escalations) => review$1(base, escalations, reviewOptions), green ?? false, form.guard, form.lenses, form.guardRests, form.lensBase, form.rules);
 }
+const isOptionalObject = (value) => value == null || typeof value === "object" && !Array.isArray(value) && typeof value.then !== "function";
+const isOptionalBoolean = (value) => value == null || typeof value === "boolean";
+const legacyForm = (fixFirst, base, green, options) => isOptionalBoolean(fixFirst) && isOptionalBoolean(green) && isOptionalObject(options) ? [base, {
+	...options,
+	fixFirst: fixFirst ?? void 0,
+	green: green ?? void 0
+}] : void 0;
+const currentForm = (base, options, third, fourth) => isOptionalObject(options) && third == null && fourth == null ? [base, options ?? {}] : void 0;
+const callForm = (first, second, [third, fourth, ...extra]) => {
+	if (extra.some((value) => value != null)) return void 0;
+	if (typeof second === "string") return legacyForm(first, second, third, fourth);
+	if (typeof first === "string") return currentForm(first, second, third, fourth);
+};
 /**
 * Undo the human's review-round code edits. A path changed since the human
 * left it is not overwritten; requireRevert names it instead.
@@ -38601,10 +38614,11 @@ function implement(first, tier, amend) {
 		amend
 	};
 	return scope("implement", async () => {
-		await agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend), {
+		await agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend, options.afterRefactor), {
 			label: "Implementing",
 			model: coder(),
-			system: builderSystem()
+			system: builderSystem(),
+			...options.afterRefactor === true ? { allowEmpty: true } : {}
 		});
 		await healthy(() => agentWithSkills("fix.suite.fixing", implementFixPrompt(), {
 			label: "Fixing the check",
@@ -38667,10 +38681,11 @@ const seamBuild = async (base) => {
 		reference,
 		base
 	};
-	await slice("refactor", () => reviewedRefactor(shape, { reference }));
+	const refactored = await slice("refactor", () => reviewedRefactor(shape, { reference }));
 	return {
 		reference,
-		base: head$1()
+		base: head$1(),
+		refactored
 	};
 };
 //#endregion
@@ -38706,12 +38721,14 @@ const naivePlanAndBuild = async (firstBase) => {
 	await slice("feature", async () => {
 		await implement({
 			reference: seam.reference,
-			tier
+			tier,
+			afterRefactor: seam.refactored
 		});
-		await featureFeedback(await buildTail(seam.base, {
+		const base = seam.refactored === true && !changesSince(seam.base).some((c) => isCode$1(c.path)) ? firstBase : seam.base;
+		await featureFeedback(await buildTail(base, {
 			green: true,
-			lensBase: seam.base
-		}), seam.base);
+			lensBase: base
+		}), base);
 	});
 };
 const featureFeedback = async (first, lensBase) => {

package/package.json

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

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

@@ -50,7 +50,12 @@ const CALC = "export const add = (a: number, b: number) => a + b\n"
 const naivePlanned = (flag: "0" | "1") => {
   const repo = testRepo({
     workflow: CONFIG_SCAFFOLD,
-    env: { GTD_QUALITYREVIEWS: "", GTD_FLAG_NAIVE_PASS: flag, GTD_FLAG_RISK_TIER: "0" },
+    env: {
+      GTD_QUALITYREVIEWS: "",
+      GTD_REFACTORQUALITYREVIEWS: "",
+      GTD_FLAG_NAIVE_PASS: flag,
+      GTD_FLAG_RISK_TIER: "0",
+    },
   })
   repo.write("src/calc.ts", CALC)
   repo.commit("feat: add calculator")
@@ -59,6 +64,40 @@ const naivePlanned = (flag: "0" | "1") => {
 }
 
 describe("planAndBuild on the naive pass", () => {
+  it("a refactor that carried the whole feature: the empty implement turn passes and the review covers the whole change", async () => {
+    const repo = naivePlanned("1")
+    const SUBTRACT = `${CALC}export const subtract = (a: number, b: number) => a - b\n`
+    expect(
+      (
+        await repo.drive({
+          unwind: () => undefined,
+          "start-gate.check": () => undefined,
+          "design.triage": (_, r) =>
+            r.write(".gtd/REQUIREMENTS.md", "# Requirements\n\n## Concerns\n\n### S\n\n- `s`\n"),
+          "design.gate.answer": () => undefined,
+          "seam.naive": (_, r) => r.write("src/calc.ts", SUBTRACT),
+          "seam.judge": () => '[{"id":"shape","answer":"refactor-first","p":0.9}]',
+          "refactor.deriving": runsItsScript,
+          "refactor.building": (_, r) => r.write("src/calc.ts", SUBTRACT),
+          "refactor.health.check": () => undefined,
+          "refactor.closing": runsItsScript,
+          "refactor.build.review.reviewing": (_, r) => r.write(".gtd/REVIEW.md", review()),
+        })
+      ).state,
+    ).toBe("refactor.build.review.await-review")
+    await repo.land()
+    const rest = await repo.drive({
+      "refactor.build.review.closing": runsItsScript,
+      "implement.building": () => undefined,
+      "implement.health.check": () => undefined,
+      "implement.closing": runsItsScript,
+      "build.review.reviewing": (_, r) => r.write(".gtd/REVIEW.md", review()),
+    })
+    expect(rest.state).toBe("build.review.await-review")
+    const base = (await repo.gtd("base")).stdout.trim()
+    expect(repo.show(base, "src/calc.ts")).toBe(CALC)
+  })
+
   it("after land, feedback rests next at design.triage, then implement.building, never seam.naive", async () => {
     const repo = naivePlanned("1")
     const requirements = (_: unknown, r: typeof repo) =>
@@ -141,7 +180,12 @@ describe("afterTail feedback lap", () => {
     prompts.length = 0
     const repo = testRepo({
       workflow: TAIL,
-      env: { GTD_QUALITYREVIEWS: "", GTD_FLAG_NAIVE_PASS: flag, GTD_FLAG_RISK_TIER: "0" },
+      env: {
+        GTD_QUALITYREVIEWS: "",
+        GTD_REFACTORQUALITYREVIEWS: "",
+        GTD_FLAG_NAIVE_PASS: flag,
+        GTD_FLAG_RISK_TIER: "0",
+      },
     })
     repo.write("src/calc.ts", CALC)
     repo.commit("feat: add calculator")

package/src/workflows/feature/feature.ts

@@ -1,4 +1,14 @@
-import { changes, head, human, revertScript, run, slice, start, vars } from "../../flows/index.js"
+import {
+  changes,
+  changesSince,
+  head,
+  human,
+  revertScript,
+  run,
+  slice,
+  start,
+  vars,
+} from "../../flows/index.js"
 import { gate } from "../shared/health.js"
 import { shipped } from "../shared/options.js"
 import { FEEDBACK } from "../shared/steps.js"
@@ -6,7 +16,7 @@ import { refusePendingHandOff } from "../shared/tail.js"
 import * as t from "../shared/text.js"
 import { packages } from "./packages.js"
 import { architecture, design } from "./planning.js"
-import { buildTail, reUnwind, type ReviewOutcome } from "./review.js"
+import { buildTail, isCode, reUnwind, type ReviewOutcome } from "./review.js"
 import { implement, seamBuild } from "./seam.js"
 import { recordRisk, riskTierOn } from "./tier.js"
 
@@ -54,11 +64,13 @@ const naivePlanAndBuild = async (firstBase: string): Promise<void> => {
   const tier = riskTierOn() ? recordRisk() : undefined
   const seam = await seamBuild(firstBase)
   await slice("feature", async () => {
-    await implement({ reference: seam.reference, tier })
-    await featureFeedback(
-      await buildTail(seam.base, { green: true, lensBase: seam.base }),
-      seam.base,
-    )
+    await implement({ reference: seam.reference, tier, afterRefactor: seam.refactored })
+    // An empty feature slice: the refactor carried the feature, so review the whole change.
+    const base =
+      seam.refactored === true && !changesSince(seam.base).some((c) => isCode(c.path))
+        ? firstBase
+        : seam.base
+    await featureFeedback(await buildTail(base, { green: true, lensBase: base }), base)
   })
 }
 

package/src/workflows/feature/refactor-absorbs.feature

@@ -0,0 +1,125 @@
+# One SDLC path per file, so a changed path reds exactly one fixture — do not merge.
+@inmem
+Feature: a refactor that carried the whole feature still gets a feature review
+
+  With GTD_FLAG_NAIVE_PASS on and GTD_FLAG_RISK_TIER off, a refactor-first
+  refactor can land everything the requirements ask for. The feature slice's
+  implement turn then has nothing to author: its empty turn completes the
+  step, and with no code changed since the refactor the feature review covers
+  the whole change, refactor included.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to ""
+    And an environment variable "GTD_REFACTORQUALITYREVIEWS" set to ""
+    And an environment variable "GTD_FLAG_NAIVE_PASS" set to "1"
+    And an environment variable "GTD_FLAG_RISK_TIER" set to "0"
+    And a file "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      """
+    And the working tree is committed as "feat: add calculator"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      subtract(a, b) returns the difference.
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Concerns
+
+      ### Subtract
+
+      - `subtract(a, b)` returns `a - b`.
+      """
+    And step "design.gate.answer" changes nothing
+
+  Scenario: an empty implement turn after a refactor that did it all reaches review and idle
+    Given step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"refactor-first","p":0.9}]
+      """
+    And step "refactor.deriving" runs its script
+    And step "refactor.building" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And step "refactor.health.check" changes nothing
+    And step "refactor.closing" runs its script
+    And step "refactor.build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-2
+        subtract next to add
+      """
+    And step "refactor.build.review.closing" runs its script
+    When the process is driven
+    Then the process rests at "refactor.build.review.await-review"
+
+    Given a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [x] ./src/calc.ts#1-2
+        subtract next to add
+      """
+    And step "implement.building" changes nothing
+    And step "implement.health.check" changes nothing
+    And step "implement.closing" runs its script
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-2
+        subtract next to add
+      """
+    When gtd lands
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REQUIREMENTS.md" does not exist
+
+    Given step "build.review.closing" runs its script
+    When gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And "src/calc.ts" contains "subtract"
+    And the commit subjects end with:
+      """
+      gtd(human): refactor.build.review.await-review → refactor.build.review.closing
+      gtd(check): refactor.build.review.closing → implement.building
+      gtd(agent): implement.building → implement.health.check
+      gtd(check): implement.health.check → implement.closing
+      gtd(check): implement.closing → build.review.reviewing
+      gtd(agent): build.review.reviewing → build.review.await-review
+      gtd(human): build.review.await-review → build.review.closing
+      gtd(check): build.review.closing → idle
+      """
+    And the output lines of gtd "slices" start with:
+      """
+      refactor 
+      feature 
+      """

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

@@ -916,6 +916,83 @@ describe("BuildTailOptions.lensBase", () => {
       expect(names).toEqual([])
     })
 
+    const fitsNeither: [string, () => Promise<unknown>][] = [
+      ["a boolean with no base", () => buildTail(true as never)],
+      ["false followed by an options object", () => buildTail(false as never, {} as never)],
+      ["a base followed by a boolean", () => buildTail("base", true as never)],
+      ["a base followed by a string array", () => buildTail("base", ["x"] as never)],
+      [
+        "a base with a third argument",
+        () => (buildTail as (...args: unknown[]) => Promise<unknown>)("base", {}, true),
+      ],
+      ["a number followed by a base", () => buildTail(1 as never, "base")],
+      ["a string fixFirst followed by a base", () => buildTail("x" as never, "base")],
+      ["a legacy call with a non-boolean green", () => buildTail(false, "base", 1 as never)],
+      ["a legacy call with non-object options", () => buildTail(false, "base", true, 1 as never)],
+      ["a base followed by a Promise", () => buildTail("base", Promise.resolve({}) as never)],
+      [
+        "a base with a fifth argument",
+        () =>
+          (buildTail as (...args: unknown[]) => Promise<unknown>)(
+            "base",
+            {},
+            undefined,
+            undefined,
+            {},
+          ),
+      ],
+      [
+        "a legacy call with a fifth argument",
+        () => (buildTail as (...args: unknown[]) => Promise<unknown>)(false, "base", true, {}, {}),
+      ],
+    ]
+    for (const [label, call] of fitsNeither) {
+      it(`rejects ${label} before any step runs`, async () => {
+        const names: string[] = []
+        const rejected = expect(requestNames(call, names)).rejects
+        await rejected.toThrow("buildTail(base, options?)")
+        await rejected.toThrow("buildTail(fixFirst, base, green?, options?)")
+        expect(names).toEqual([])
+      })
+    }
+
+    it("reads null and trailing undefined arguments as absent", async () => {
+      const omitted = await requestNames(() => buildTail("base"))
+      expect(await requestNames(() => buildTail(null as never, "base", null as never))).toEqual(
+        omitted,
+      )
+      expect(
+        await requestNames(() =>
+          (buildTail as (...args: unknown[]) => Promise<unknown>)(
+            "base",
+            {},
+            null,
+            undefined,
+            null,
+          ),
+        ),
+      ).toEqual(omitted)
+      expect(await requestNames(() => buildTail("base", null as never))).toEqual(omitted)
+      expect(await requestNames(() => buildTail(false, "base", false, null as never))).toEqual(
+        omitted,
+      )
+    })
+
+    it("accepts a class instance as options", async () => {
+      class Options {
+        green = true
+      }
+      expect(await requestNames(() => buildTail("base", new Options()))).toEqual(
+        await requestNames(() => buildTail("base", { green: true })),
+      )
+    })
+
+    it("accepts a null-prototype options object", async () => {
+      expect(await requestNames(() => buildTail("base", Object.create(null) as never))).toEqual(
+        await requestNames(() => buildTail("base")),
+      )
+    })
+
     it("still runs buildTail(undefined, base) as a legacy call", async () => {
       const names: string[] = []
       await requestNames(() => buildTail(undefined as never, "base"), names)

package/src/workflows/feature/review.ts

@@ -158,7 +158,7 @@ const triage =
     )
   }
 
-const isCode = (path: string): boolean => path !== ".gtd" && !path.startsWith(".gtd/")
+export const isCode = (path: string): boolean => path !== ".gtd" && !path.startsWith(".gtd/")
 
 /**
  * A reviewer writes `.gtd/REVIEW.md` over everything since `base`, a human
@@ -289,34 +289,71 @@ export function buildTail(
 export function buildTail(
   first: boolean | string,
   second?: string | BuildTailOptions,
-  third = false,
-  fourth: Omit<BuildTailOptions, "fixFirst" | "green"> = {},
+  ...rest: unknown[]
 ): Promise<kit.ReviewOutcome> {
+  const options = callForm(first, second, rest)
   // Before any step runs, so a bad call never leaves a half-walked flow.
-  if (typeof first !== "string" && typeof first !== "boolean" && typeof second !== "string") {
+  if (options === undefined) {
     return Promise.reject(
       new Error(
         "buildTail takes buildTail(base, options?) or the deprecated buildTail(fixFirst, base, green?, options?); this call fits neither",
       ),
     )
   }
-  const [base, options]: [string, BuildTailOptions] =
-    typeof first === "string"
-      ? [first, (second as BuildTailOptions | undefined) ?? {}]
-      : [second as string, { ...fourth, fixFirst: first, green: third }]
-  const { fixFirst, green, ...reviewOptions } = options
+  const [base, form] = options
+  const { fixFirst, green, ...reviewOptions } = form
   return tail(
     fixFirst ?? false,
     (escalations) => review(base, escalations, reviewOptions),
     green ?? false,
-    options.guard,
-    options.lenses,
-    options.guardRests,
-    options.lensBase,
-    options.rules,
+    form.guard,
+    form.lenses,
+    form.guardRests,
+    form.lensBase,
+    form.rules,
   )
 }
 
+// null reads as absent; an un-awaited Promise is a mistake, not options.
+const isOptionalObject = (value: unknown): value is BuildTailOptions | null | undefined =>
+  value == null ||
+  (typeof value === "object" &&
+    !Array.isArray(value) &&
+    typeof (value as { then?: unknown }).then !== "function")
+
+const isOptionalBoolean = (value: unknown): value is boolean | null | undefined =>
+  value == null || typeof value === "boolean"
+
+const legacyForm = (
+  fixFirst: unknown,
+  base: string,
+  green: unknown,
+  options: unknown,
+): [string, BuildTailOptions] | undefined =>
+  isOptionalBoolean(fixFirst) && isOptionalBoolean(green) && isOptionalObject(options)
+    ? [base, { ...options, fixFirst: fixFirst ?? undefined, green: green ?? undefined }]
+    : undefined
+
+const currentForm = (
+  base: string,
+  options: unknown,
+  third: unknown,
+  fourth: unknown,
+): [string, BuildTailOptions] | undefined =>
+  isOptionalObject(options) && third == null && fourth == null ? [base, options ?? {}] : undefined
+
+// gtd.config.ts is untyped at runtime, so every argument is checked against the form chosen.
+const callForm = (
+  first: unknown,
+  second: unknown,
+  [third, fourth, ...extra]: readonly unknown[],
+): [string, BuildTailOptions] | undefined => {
+  if (extra.some((value) => value != null)) return undefined
+  if (typeof second === "string") return legacyForm(first, second, third, fourth)
+  if (typeof first === "string") return currentForm(first, second, third, fourth)
+  return undefined
+}
+
 /**
  * Undo the human's review-round code edits. A path changed since the human
  * left it is not overwritten; requireRevert names it instead.

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

@@ -179,7 +179,7 @@ describe("seamBuild", () => {
 
   it("refactor-first runs the reviewed refactor in slice refactor and resolves HEAD after it", async () => {
     const h = await driveSeam("refactor-first")
-    expect(h.outcome).toEqual({ reference: "abc", base: "after-refactor" })
+    expect(h.outcome).toEqual({ reference: "abc", base: "after-refactor", refactored: true })
     expect(h.slices).toEqual(["refactor"])
     expect(h.inside.refactor![0]).toBe("refactor.deriving")
     expect(h.inside.refactor).toContain("refactor.build.review.closing")
@@ -221,6 +221,7 @@ describe("seamBuild", () => {
 })
 
 describe("implement", () => {
+  let lastOptions: Extract<StepRequest, { kind: "agent" }>["options"] | undefined
   const building = async (
     reference: string | undefined,
     tier?: "low" | "high",
@@ -228,6 +229,7 @@ describe("implement", () => {
     call: () => Promise<void> = () => implement({ reference, tier, amend }),
   ) => {
     const requests: StepRequest[] = []
+    lastOptions = undefined
     installContext(
       fixtureContext(
         {},
@@ -245,9 +247,24 @@ describe("implement", () => {
     await call()
     const request = requests.find((r) => r.kind === "agent" && r.name === "building")
     if (request?.kind !== "agent") throw new Error("no building turn")
+    lastOptions = request.options
     return request.prompt
   }
 
+  it("after a refactor, lets an empty turn complete the step and says so", async () => {
+    const prompt = await building("abc", undefined, undefined, () =>
+      implement({ reference: "abc", afterRefactor: true }),
+    )
+    expect(lastOptions?.allowEmpty).toBe(true)
+    expect(prompt).toMatch(/change\s+nothing and finish your turn/)
+  })
+
+  it("without a refactor, an empty turn stays an attempt", async () => {
+    const prompt = await building("abc")
+    expect(lastOptions?.allowEmpty).toBeUndefined()
+    expect(prompt).not.toMatch(/change\s+nothing/)
+  })
+
   it("the deprecated positional form renders the same prompt as the options form", async () => {
     const modern = await building("abc", "low")
     const legacy = await building("abc", "low", undefined, () => implement("abc", "low"))

package/src/workflows/feature/seam.ts

@@ -45,6 +45,8 @@ export interface ImplementOptions {
   readonly reference?: string | undefined
   readonly tier?: RiskTier | undefined
   readonly amend?: boolean | undefined
+  /** After a refactor slice, which may already carry the feature: an empty turn completes the step. */
+  readonly afterRefactor?: boolean | undefined
 }
 
 export function implement(options?: ImplementOptions): Promise<void>
@@ -64,11 +66,17 @@ export function implement(
   return scope("implement", async () => {
     await t.agentWithSkills(
       "building",
-      t.implementBuildingPrompt(options.reference, options.tier, options.amend),
+      t.implementBuildingPrompt(
+        options.reference,
+        options.tier,
+        options.amend,
+        options.afterRefactor,
+      ),
       {
         label: "Implementing",
         model: coder(),
         system: t.builderSystem(),
+        ...(options.afterRefactor === true ? { allowEmpty: true } : {}),
       },
     )
     await healthy(() =>
@@ -124,6 +132,7 @@ export interface SeamOutcome {
   readonly reference: string
   /** The feature review's base: HEAD after the refactor on refactor-first, else the caller's base. */
   readonly base: string
+  readonly refactored?: boolean
 }
 
 export const seamBuild = async (base: string): Promise<SeamOutcome> => {
@@ -140,6 +149,6 @@ export const seamBuild = async (base: string): Promise<SeamOutcome> => {
     return { reference, base }
   }
   if (refactorStrays(shape).length === 0) return { reference, base }
-  await slice("refactor", () => reviewedRefactor(shape, { reference }))
-  return { reference, base: head() }
+  const refactored = await slice("refactor", () => reviewedRefactor(shape, { reference }))
+  return { reference, base: head(), refactored }
 }

package/src/workflows/shared/text.ts

@@ -1290,17 +1290,25 @@ export const implementBuildingPrompt = (
   reference: string | undefined,
   tier?: "low" | "high",
   amend?: boolean,
+  afterRefactor?: boolean,
 ): string =>
   `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
 ${
-  amend === true
-    ? `- The change already exists in the tree from an earlier lap; amend it to meet
+  afterRefactor === true
+    ? `- A reviewed refactor has just landed and may already carry part of the change,
+  though never a release flag. Build only what is still missing, held to every
+  rule below; if nothing is, change nothing and finish your turn
+`
+    : ""
+}${
+    amend === true
+      ? `- The change already exists in the tree from an earlier lap; amend it to meet
   the re-derived requirements instead of rewriting it
 `
-    : `- Implement them properly, fitting the codebase's seams and conventions
+      : `- Implement them properly, fitting the codebase's seams and conventions
 `
-}${
+  }${
     reference === undefined || amend === true
       ? ""
       : `- Reference only: \`git show ${reference}\` shows an earlier naive attempt.