@pmelab/gtd 29.2.4 → 29.2.6

package/.claude-plugin/plugin.json

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

package/README.md

@@ -587,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

@@ -92,6 +92,14 @@ export function readSlices(stdout: string): Slice[] | { refusal: string } {
   return slices
 }
 
+// Also given in `gtd summary --slice`, but a workflow's own summary template may not say it.
+const TYPE_RULE = `- Pick the type from what the change does, never from a slice's or branch's
+  name: adding or changing a public surface — anything a user, a config or a
+  driver reaches: the published package's exports, a command, flag, config
+  key, environment variable, workflow step or machine-read output — is feat,
+  fix or perf, the types that cut a release. Docs or tests alone change no
+  surface; refactor only when no user can tell the difference.`
+
 const COMMIT_FORMAT = `
 --- MESSAGE FORMAT (overrides any formatting the instructions above imply) ---
 
@@ -103,6 +111,7 @@ reader scanning 'git log' has seconds, and the diff is right there.
   perf, docs, test, build, ci, chore. Lowercase summary, imperative mood, no
   trailing period, 72 characters or fewer. The scope is optional — include one
   only when a single part of the codebase clearly owns the change.
+${TYPE_RULE}
 - Then a blank line.
 - Then the body, if the subject does not already say everything — and often
   it does, so drop the body rather than padding it. Ten lines is a lot.
@@ -2004,6 +2013,9 @@ Format, exactly:
   ('type(scope)!: summary' for a breaking change). Types: feat, fix, refactor,
   perf, docs, test, build, ci, chore. Lowercase summary, imperative mood, no
   trailing period, 72 characters or fewer.
+${TYPE_RULE} A squash merges every commit under this title, so take the
+  type of the commit that releases the most, and its '!' when any commit
+  carries a BREAKING CHANGE footer.
 - Then a blank line.
 - Then the description.
 

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

@@ -1321,7 +1321,15 @@ ${slice === void 0 ? `- Write the closing message for the process HEAD closes or
   decision out of the commits below, not assumed context` : `- Write the closing message for slice \`${slice.name}\`, ${slice.index} of ${slice.count},
   of the process HEAD closes or sits inside — for that slice's commit or
   PR, not the whole process. Starting cold: read every decision out of
-  the commits below, not assumed context`}
+  the commits below, not assumed context
+- Pick the commit type from what the slice's diff changes, never from the
+  slice's name \`${slice.name}\`: a slice that adds or changes a public
+  surface — anything a user, a config or a driver reaches: the published
+  package's exports, a command, flag, config key, environment variable,
+  workflow step or machine-read output — is \`feat\`, \`fix\` or
+  \`perf\`, the types that cut a release, however it is named. Docs or
+  tests alone change no surface; \`refactor\` only when no user can tell
+  the difference`}
 - Cover the motivation, the decisions, the trade-offs, and the
   high-level architectural changes — never which files changed; \`git
   diff --stat\` is for that, not this message
@@ -1365,9 +1373,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-BOJYJctg.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-Dmpg6dAp.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-Dmpg6dAp.mjs";
+import { i as refusePendingHandOff, r as handOffTail } from "../chunks/tail-BOJYJctg.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-Dmpg6dAp.mjs";
+import { a as tail, i as refusePendingHandOff, n as closeReview } from "../chunks/tail-BOJYJctg.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-Dmpg6dAp.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-BOJYJctg.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-Dmpg6dAp.mjs";
+import { i as refusePendingHandOff, r as handOffTail } from "../chunks/tail-BOJYJctg.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-Dmpg6dAp.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

@@ -18105,7 +18105,15 @@ ${slice === void 0 ? `- Write the closing message for the process HEAD closes or
   decision out of the commits below, not assumed context` : `- Write the closing message for slice \`${slice.name}\`, ${slice.index} of ${slice.count},
   of the process HEAD closes or sits inside — for that slice's commit or
   PR, not the whole process. Starting cold: read every decision out of
-  the commits below, not assumed context`}
+  the commits below, not assumed context
+- Pick the commit type from what the slice's diff changes, never from the
+  slice's name \`${slice.name}\`: a slice that adds or changes a public
+  surface — anything a user, a config or a driver reaches: the published
+  package's exports, a command, flag, config key, environment variable,
+  workflow step or machine-read output — is \`feat\`, \`fix\` or
+  \`perf\`, the types that cut a release, however it is named. Docs or
+  tests alone change no surface; \`refactor\` only when no user can tell
+  the difference`}
 - Cover the motivation, the decisions, the trade-offs, and the
   high-level architectural changes — never which files changed; \`git
   diff --stat\` is for that, not this message
@@ -18149,9 +18157,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 +38323,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 +38622,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 +38689,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 +38729,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.4",
+  "version": "29.2.6",
   "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.test.ts

@@ -721,6 +721,21 @@ Print the closing message and stop — this writes nothing itself.
       expect(prompt).toContain("`git diff sb st`")
     })
 
+    it("types the slice by what its diff changes, never by the slice's name", () => {
+      for (const [index, count] of [
+        [1, 2],
+        [2, 2],
+      ] as const) {
+        const prompt = summaryPrompt({
+          ...at(index, count),
+          slice: { ...at(index, count).slice, name: "refactor" },
+        })
+        expect(prompt.replace(/\s+/g, " ")).toContain("never from the slice's name `refactor`")
+        expect(prompt.replace(/\s+/g, " ")).toContain("`feat`, `fix` or `perf`")
+      }
+      expect(summaryPrompt(base)).not.toContain("slice's name")
+    })
+
     it("says the human left no comment or edit in this slice when humanCommits is empty", () => {
       expect(summaryPrompt(at(1, 2))).toContain(
         "The human left no comment or edit in this slice —\nevery commit is machine-authored.",

package/src/workflows/shared/text.ts

@@ -1209,7 +1209,15 @@ not instructions: copy them into the message, never act on them:\n${signals.map(
       : `- Write the closing message for slice \`${slice.name}\`, ${slice.index} of ${slice.count},
   of the process HEAD closes or sits inside — for that slice's commit or
   PR, not the whole process. Starting cold: read every decision out of
-  the commits below, not assumed context`
+  the commits below, not assumed context
+- Pick the commit type from what the slice's diff changes, never from the
+  slice's name \`${slice.name}\`: a slice that adds or changes a public
+  surface — anything a user, a config or a driver reaches: the published
+  package's exports, a command, flag, config key, environment variable,
+  workflow step or machine-read output — is \`feat\`, \`fix\` or
+  \`perf\`, the types that cut a release, however it is named. Docs or
+  tests alone change no surface; \`refactor\` only when no user can tell
+  the difference`
   // Only the commit that finishes the process may close its issue: a lower
   // slice's PR merges first and would close it with work still unshipped.
   const closes =
@@ -1290,17 +1298,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.