@pmelab/gtd 32.0.0 → 33.0.0

package/dist/workflows.mjs

@@ -1,3 +1,4 @@
+import { posix } from "node:path";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -476,8 +477,20 @@ const gate$1 = (name, passes, blocked) => scope(name, async () => {
 });
 //#endregion
 //#region src/workflow-kit/quality.ts
-/** Split a comma-separated lens list: trimmed, blanks dropped. */
-const lensesOf = (value) => value.split(",").map((lens) => lens.trim()).filter((lens) => lens.length > 0);
+const lensOf = (entry) => {
+	const at = entry.indexOf("=");
+	return at < 0 ? {
+		lens: entry.trim(),
+		model: ""
+	} : {
+		lens: entry.slice(0, at).trim(),
+		model: entry.slice(at + 1).trim()
+	};
+};
+/** Split a comma-separated lens list into whole entries, `<lens>` or `<lens>=<model>`: trimmed, blanks dropped. */
+const lensEntriesOf = (value) => value.split(",").map((entry) => entry.trim()).filter((entry) => lensOf(entry).lens.length > 0);
+/** The same list's lens names, model hints cut off. */
+const lensesOf = (value) => lensEntriesOf(value).map((entry) => lensOf(entry).lens);
 /** One `<scope>.<lens>` entry per lens — the per-lens part of a skills or access export. */
 const lensScopes = (scope, lenses, entry) => Object.fromEntries(lenses.map((lens) => [`${scope}.${lens}`, entry(lens)]));
 /** One `review` turn per lens, each appending its findings to `findings`; resolves `"findings"` when that file has any. */
@@ -17987,24 +18000,47 @@ Print the closing message and stop — this writes nothing itself.
 `;
 };
 const listed = (paths, unreadable = []) => paths.map((path) => `  - \`${displayPath(path)}\`${unreadable.includes(path) ? " (unreadable)" : ""}`).join("\n");
+const isRed = (retry) => "red" in retry;
+const isFault = (retry) => "fault" in retry;
+const pickUp = (hash) => `Pick it up — \`git diff --binary ${hash}^ ${hash} | git apply\``;
 const criteriaBinding = (refused) => `- Its \`## Acceptance Criteria\` (\`AC-<n>\`) bind this turn: re-read them from
   the file, never from memory, and stop only when each one holds. They are
   settled — ${refused ? "a turn that changes them is refused" : "leave them as they are"}`;
-const naivePassPrompt = (rejection) => `${stateFileRules}
+const naiveRetry = (retry) => isFault(retry) ? `
+Your previous attempt's (\`${retry.hash}\`) tests fall short:
+${retry.fault}
+${pickUp(retry.hash)} — and fix its tests; do not start over.
+` : isRed(retry) ? `
+Your previous attempt (\`${retry.red}\`) left the suite red; \`.gtd/FEEDBACK.md\`
+holds the output. ${pickUp(retry.red)}
+— and fix it until the suite is green; do not start over.
+` : `
+Your previous attempt was rejected: the judge answered \`reject\` (p=${retry.p}),
+meaning the naive pass solved the task the wrong way — discard it and
+re-implement. It changed these files outside the expected set:
+${listed(retry.strays)}
+Start over and choose a different approach; do not rebuild the same diff.
+`;
+const naivePassPrompt = (retry) => `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
 ${criteriaBinding(false)}
 - Implement them the quickest way that works — the naive version. Do not
   restructure, abstract or refactor around the change; a later step judges
   the shape of your diff and a reviewer makes it fit
-- Add tests as you go, and leave \`.gtd/\` untouched
+- Work breadth-first: rough out every part of the change before finishing any
+  one, so a run cut off midway still shows the whole shape
+- Write behaviour-level acceptance tests, at least one per criterion, each
+  naming its ID in the test or scenario name (\`[AC-3] …\`). Test through code
+  that existed before this pass — a public entry point, the CLI, an existing
+  module's exports — never a file this pass adds: that is naive structure a
+  later reset and refactor replaces. A pass that leaves a criterion's ID out
+  of its tests, or whose test imports a file it added, is sent back
+- Run \`${env.testCommand}\` and finish only once it is green with every
+  criterion's test passing: the next step runs it on your diff and sends a red
+  pass back
+- Leave \`.gtd/\` untouched
 - Leave everything uncommitted and finish your turn — do not commit
-${rejection === void 0 ? "" : `
-Your previous attempt was rejected: the judge answered \`reject\` (p=${rejection.p}),
-meaning the naive pass solved the task the wrong way — discard it and
-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.
-`}`;
+${retry === void 0 ? "" : naiveRetry(retry)}`;
 const implementBuildingPrompt = (reference, tier, amend, afterRefactor, flagMode = true) => `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
 ${criteriaBinding(true)}
@@ -18029,8 +18065,41 @@ const implementFixPrompt = () => `${stateFileRules}
 ${fixFeedbackPrompt}
 - Leave everything uncommitted and finish your turn — do not commit
 `;
-const seamSteerMessage = (rejection) => `The naive pass was rejected three times and the retries are spent.
-The last attempt changed these files outside the expected set:
+const steerChoices = (overrule) => `Two ways forward (then run \`gtd land\`):
+- **Steer** — edit \`.gtd/REQUIREMENTS.md\` to redirect the change; the naive
+  pass runs again with a fresh retry budget
+- **Overrule** — ${overrule}
+
+An edit together with an approval counts as steer. Only
+\`.gtd/REQUIREMENTS.md\` is meant to change here: any other edit lands on the
+branch unjudged.
+`;
+const seamSteerMessage = (retry) => isFault(retry) ? `The naive pass failed three times and the retries are spent. The last
+attempt's tests (\`git show ${retry.hash}\`) fall short:
+${retry.fault}
+
+${steerChoices(`land a clean tree to go on with the last attempt as it is:
+  \`seam.check\` runs its suite and the seam judge rules on its shape. Use it
+  when the rule cannot fit this change (tests the globs do not see, or no
+  entry point that existed before). Risk: a criterion may have no test that
+  survives a later refactor — the choice is recorded in history.`)}` : isRed(retry) ? `The naive pass failed three times and the retries are spent. The last
+attempt left the suite red: \`.gtd/FEEDBACK.md\` holds the last run's output; \`git show ${retry.red}\` shows
+the last attempt.
+
+Two ways forward (then run \`gtd land\`):
+- **Steer** — edit \`.gtd/REQUIREMENTS.md\` to redirect the change; the naive
+  pass runs again with a fresh retry budget
+- **Overrule** — land a clean tree to go on with the last attempt as it is:
+  the seam judge rules on its shape, and the implementation's health loop
+  must turn the suite green. Risk: the criteria's tests never passed on the
+  naive pass — the choice is recorded in history.
+
+An edit together with an approval counts as steer. Only
+\`.gtd/REQUIREMENTS.md\` is meant to change here: any other edit lands on the
+branch unjudged.
+` : seamRejectedMessage(retry);
+const seamRejectedMessage = (rejection) => `The naive pass failed three times and the retries are spent. The judge
+rejected the last attempt: it changed these files outside the expected set:
 ${listed(rejection.strays)}
 
 Two ways forward (then run \`gtd land\`):
@@ -18106,11 +18175,16 @@ const builtInLenses = {
 		brief: specChallengeBrief
 	}
 };
+const coderLenses = /* @__PURE__ */ new Set([
+	"conventions",
+	"ponytail-review",
+	"test-audit"
+]);
 /** One quality review through `lens`; each lens is its own scope, so its own conversation and skills. */
-const reviewQuality = (lens, base) => agentWithSkills(`quality.${lens}.reviewing`, buildQualityReviewingPrompt(lens, builtInLenses[lens]?.brief, base), {
+const reviewQuality = (lens, base, model) => agentWithSkills(`quality.${lens}.reviewing`, buildQualityReviewingPrompt(lens, builtInLenses[lens]?.brief, base), {
 	label: "Reviewing (one quality lens)",
 	file: QUALITY,
-	model: planner(),
+	model: model || (coderLenses.has(lens) ? coder() : planner()),
 	system: reviewerSystem(),
 	allowEmpty: true
 });
@@ -37631,7 +37705,10 @@ const REVIEW_ORIG = ".gtd/REVIEW.orig.md";
 * finding to `.gtd/QUALITY.md`. Resolves `"findings"` when that file
 * has any.
 */
-const qualityLap = (guard, lenses, base) => qualityLap$1(lenses ?? lensesOf(vars.qualityReviews ?? ""), guarded((lens) => reviewQuality(lens, base), guard), QUALITY);
+const qualityLap = (guard, lenses, base) => qualityLap$1(lenses ?? lensEntriesOf(vars.qualityReviews ?? ""), guarded((entry) => {
+	const { lens, model } = lensOf(entry);
+	return reviewQuality(lens, base, model);
+}, guard), QUALITY);
 /** Resolves `true` once `.gtd/QUALITY.md` is resolved, `false` when the fix cap escalated instead. */
 const fixQualityFindings = (escalations, guard, guardRests = true, rules) => fixFindings({
 	fix: guarded(() => fixQuality(rules), guard),
@@ -38437,7 +38514,7 @@ const reviewedRefactor = async (shape, options = {}) => {
 				green: true,
 				guard,
 				guardRests: false,
-				lenses: lensesOf(vars.refactorQualityReviews ?? ""),
+				lenses: lensEntriesOf(vars.refactorQualityReviews ?? ""),
 				feedback,
 				fixAccess: strayAccess(p.strays),
 				lensBase: entry,
@@ -38453,7 +38530,7 @@ const reviewedRefactor = async (shape, options = {}) => {
 };
 //#endregion
 //#region src/workflows/feature/seam.ts
-/** Naive-pass retries after a `reject`; the next `reject` rests at `seam.steer`. */
+/** Naive-pass retries after a `reject` or a red suite; the next one rests at `seam.steer`. */
 const NAIVE_RETRIES = 2;
 /** A change to an existing file outside the allowlist is a stray even when the task needs it: the judge decides. */
 const judgeSeam = (tip) => judgeDiffShape("judge", {
@@ -38461,12 +38538,95 @@ const judgeSeam = (tip) => judgeDiffShape("judge", {
 	allow: (vars.seamAllow ?? defaults.seamAllow).split(",").map((glob) => glob.trim()).filter((glob) => glob !== ""),
 	exempt: tip.changes.filter((c) => c.status === "added").map((c) => c.path)
 });
-const naivePass = (rejection) => agentWithSkills("naive", naivePassPrompt(rejection), {
-	label: rejection === void 0 ? "Writing the naive pass" : "Rewriting the naive pass",
+const naivePass = (retry) => agentWithSkills("naive", naivePassPrompt(retry), {
+	label: retry === void 0 ? "Writing the naive pass" : "Rewriting the naive pass",
 	keep: true,
 	model: coder(),
 	system: builderSystem()
 });
+const IMPORTED = /(?:\bfrom|\bimport|\brequire\s*\(|\bmock\s*\()\s*\(?\s*(["'`])([^"'`\n]+)\1/g;
+const EXTENSION = /\.[\w-]+$/;
+const ALIAS = /^(?:[@~]\/|#)/;
+/** The specifiers an added `path` answers to: itself, without its extension, and its directory for an `index`. */
+const namesOf = (path) => {
+	const bare = path.replace(EXTENSION, "");
+	return posix.basename(bare) === "index" ? [
+		path,
+		bare,
+		posix.dirname(bare)
+	] : [path, bare];
+};
+/**
+* The repository paths `test` imports, each with and without an extension: a
+* relative specifier resolved from its directory, an aliased one (`@/`, `~/`,
+* `#`) as a path tail, anything else as written. Comments are skipped; a
+* computed import goes unseen.
+*/
+const importsOf = (test) => [...(test.after ?? "").replace(COMMENT, "").matchAll(IMPORTED)].flatMap(([, , spec]) => {
+	const relative = /^\.\.?(\/|$)/.test(spec);
+	const tail = ALIAS.test(spec);
+	const path = relative ? posix.join(posix.dirname(test.path), spec) : spec.replace(ALIAS, "");
+	return [path, path.replace(EXTENSION, "")].map((p) => ({
+		path: p,
+		tail
+	}));
+});
+const reaches = (imports, added) => namesOf(added).some((name) => imports.some(({ path, tail }) => name === path || tail && name.endsWith(`/${path}`)));
+const named = (id, text) => new RegExp(`(?<![\\w-])${id}(?!\\d)`).test(text);
+/** The lines `change` added: an ID an earlier change left in the file does not count. */
+const addedLines = (change) => {
+	const before = new Set((change.before ?? "").split("\n"));
+	return change.after.split("\n").filter((line) => !before.has(line)).join("\n");
+};
+/**
+* Why `tip`'s tests fall short, or `undefined`: a criterion ID of `file` no
+* test line of the pass names, or a test importing a file the pass added —
+* naive structure a reset and refactor replaces, which the tests must survive.
+*/
+const acceptanceFault = (file, tip) => {
+	const ids = (criteriaOf(read(file) ?? "") ?? []).map((c) => c.id).filter((id) => id !== "");
+	const tests = tip.changes.filter((c) => c.after !== void 0 && isCode$1(c.path) && isTestFile(c.path));
+	const lines = tests.map(addedLines);
+	const untested = ids.filter((id) => !lines.some((text) => named(id, text)));
+	if (untested.length > 0) return `acceptance-tests: no test of the naive pass names ${untested.join(", ")} — write a behaviour-level test for each criterion with its ID in the test or scenario name, e.g. "[${untested[0]}] …"`;
+	const added = tip.changes.filter((c) => c.status === "added" && isCode$1(c.path) && !isTestFile(c.path)).map((c) => c.path);
+	const reaching = tests.filter((test) => holdsCallSites(test.path)).flatMap((test) => {
+		const imports = importsOf(test);
+		return added.filter((path) => reaches(imports, path)).map((path) => `  - ${test.path} → ${path}`);
+	});
+	if (reaching.length > 0) return `acceptance-internals: these tests import files the naive pass added — test through code that existed before it (a public entry point, an existing module's exports):\n${reaching.join("\n")}`;
+};
+const restore = (path) => `if git cat-file -e ${quote(`HEAD:${path}`)} 2>/dev/null; then git checkout -q HEAD -- ${quote(path)}; else rm -f -- ${quote(path)}; fi`;
+/**
+* Run the suite with `tip`'s diff applied, then take it out again; resolves
+* `true` when green. The pass's paths go back to HEAD before (an interrupted
+* run left them applied) and after; afterwards so does anything else the run
+* changed, judged against what was already dirty, which is left alone.
+*/
+const naiveGreen = (tip) => {
+	const paths = tip.changes.map((c) => restore(c.path));
+	return check("check", [
+		...paths,
+		"dirty=$(git -c core.quotePath=false ls-files -m -d -o --exclude-standard)",
+		`if ! git diff --binary ${quote(`${tip.hash}^`)} ${quote(tip.hash)} -- | git apply; then`,
+		"  echo 'gtd: the kept naive pass no longer applies to HEAD; no test ran'",
+		"  exit 1",
+		"fi",
+		"(",
+		env.testCommand ?? "",
+		")",
+		"code=$?",
+		...paths,
+		"git -c core.quotePath=false ls-files -m -d -o --exclude-standard | while IFS= read -r path; do",
+		"  printf '%s\\n' \"$dirty\" | grep -qxF -- \"$path\" && continue",
+		"  if git cat-file -e \"HEAD:$path\" 2>/dev/null; then git checkout -q HEAD -- \"$path\"; else rm -f -- \"$path\"; fi",
+		"done",
+		"exit \"$code\""
+	].join("\n"), {
+		report: FEEDBACK,
+		label: "Running the naive pass's tests"
+	});
+};
 function implement(first, tier, amend) {
 	const options = typeof first === "object" && first !== null ? first : {
 		reference: first,
@@ -38493,36 +38653,76 @@ function implement(first, tier, amend) {
 		await run("closing", removeScript([REQUIREMENTS]), { label: "Closing out the implementation" });
 	});
 }
-const decide = () => scope("seam", async () => {
-	let rejection;
+/** Resolves `true` when the human steered (edited), `false` on a clean overrule. */
+const steer = async (retry) => {
+	await human("steer", {
+		message: seamSteerMessage(retry),
+		label: "Steer or overrule the naive pass",
+		file: REQUIREMENTS,
+		acceptClean: true
+	});
+	if (changes().length === 0) return false;
+	requireCriteria(REQUIREMENTS);
+	return true;
+};
+/** Rejects, test faults and red checks share one budget; a steer or an overrule refills it. */
+const budget = () => {
 	let retries = 0;
-	for (;;) {
-		await naivePass(rejection);
-		const tip = kept("naive");
-		const shape = await judgeSeam(tip);
-		if (shape.choice === "land") return { reference: tip.hash };
-		if (shape.choice === "refactor-first") return {
-			reference: tip.hash,
-			shape
-		};
-		rejection = {
-			strays: shape.strays,
-			p: shape.judgment?.answers.shape?.p ?? 0
-		};
+	return async (next) => {
 		if (retries < NAIVE_RETRIES) {
 			retries++;
-			continue;
+			return {
+				kind: "retry",
+				retry: next
+			};
 		}
-		await human("steer", {
-			message: seamSteerMessage(rejection),
-			label: "Steer or overrule the rejected naive pass",
-			file: REQUIREMENTS,
-			acceptClean: true
-		});
-		if (changes().length === 0) return { reference: tip.hash };
-		requireCriteria(REQUIREMENTS);
-		rejection = void 0;
+		const steered = await steer(next);
 		retries = 0;
+		if (read(".gtd/FEEDBACK.md") !== void 0) await run("clear", removeScript([FEEDBACK]), { label: "Clearing the red check" });
+		return { kind: steered ? "steered" : "overruled" };
+	};
+};
+/** Sends a pass whose tests fall short or run red back (`undefined`: it goes on, an overruled one as it is). */
+const vetted = async (tip, vetting) => {
+	const fault = vetting.waived ? void 0 : acceptanceFault(REQUIREMENTS, tip);
+	if (fault !== void 0) {
+		const verdict = await vetting.again({
+			fault,
+			hash: tip.hash
+		});
+		if (verdict.kind !== "overruled") return verdict;
+		vetting.waived = true;
+	}
+	if (await naiveGreen(tip)) return void 0;
+	const verdict = await vetting.again({ red: tip.hash });
+	return verdict.kind === "overruled" ? void 0 : verdict;
+};
+/** The judge's ruling on a vetted pass: the decision, or the next attempt's verdict. */
+const ruled = async (tip, again) => {
+	const shape = await judgeSeam(tip);
+	if (shape.choice === "land") return { reference: tip.hash };
+	if (shape.choice === "refactor-first") return {
+		reference: tip.hash,
+		shape
+	};
+	const next = await again({
+		strays: shape.strays,
+		p: shape.judgment?.answers.shape?.p ?? 0
+	});
+	return next.kind === "overruled" ? { reference: tip.hash } : next;
+};
+const decide = () => scope("seam", async () => {
+	const vetting = {
+		again: budget(),
+		waived: false
+	};
+	let retry;
+	for (;;) {
+		await naivePass(retry);
+		const tip = kept("naive");
+		const outcome = await vetted(tip, vetting) ?? await ruled(tip, vetting.again);
+		if (!("kind" in outcome)) return outcome;
+		retry = outcome.kind === "retry" ? outcome.retry : void 0;
 	}
 });
 const seamBuild = async (base) => {
@@ -38803,4 +39003,4 @@ var workflows_default = feature;
 */
 const doors = {};
 //#endregion
-export { ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, QUALITY, REFACTOR, REFACTOR_PACKAGE, REQUIREMENTS, REVIEW, REVIEW_ORIG, ShippedOptions, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, awaitReview, base, baseline, buildFeature, buildTail, builtInLenses, cleanup, cleanupFlow, closeReview, coder, collecting, criteriaOf, workflows_default as default, defaults, deferNotes, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, implement, judgeSeam, lensesOf, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, refactorCollecting, refactorFirst, refactorStrays, requireCriteria, requireCriteriaFrozen, requireNoNewFlags, requireNoTestFiles, requireTestCallSitesOnly, requireWithin, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewedRefactor, reviewing, rollout, rolloutFlow, seamBuild, skills, skipDesign, statedCriteria, steering, summary, tail, threads, triage, unwind };
+export { COMMENT, ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, QUALITY, REFACTOR, REFACTOR_PACKAGE, REQUIREMENTS, REVIEW, REVIEW_ORIG, ShippedOptions, acceptanceFault, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, awaitReview, base, baseline, buildFeature, buildTail, builtInLenses, cleanup, cleanupFlow, closeReview, coder, collecting, criteriaOf, workflows_default as default, defaults, deferNotes, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, holdsCallSites, implement, isTestFile, judgeSeam, lensEntriesOf, lensOf, lensesOf, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, refactorCollecting, refactorFirst, refactorStrays, requireCriteria, requireCriteriaFrozen, requireNoNewFlags, requireNoTestFiles, requireTestCallSitesOnly, requireWithin, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewedRefactor, reviewing, rollout, rolloutFlow, seamBuild, skills, skipDesign, statedCriteria, steering, summary, tail, threads, triage, unwind };

package/package.json

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

package/src/workflow-kit/quality.test.ts

@@ -1,10 +1,34 @@
 import { describe, expect, it } from "vitest"
-import { lensesOf, lensScopes } from "./quality.js"
+import { lensEntriesOf, lensesOf, lensOf, lensScopes } from "./quality.js"
 
 describe("lensesOf", () => {
   it("splits on commas, trims, drops blanks", () => {
     expect(lensesOf(" a ,, b,")).toEqual(["a", "b"])
   })
+
+  it("cuts each entry's model hint off at its first =", () => {
+    expect(lensesOf("a = smart, plugin:b=vendor=x, c=")).toEqual(["a", "plugin:b", "c"])
+  })
+
+  it("drops an entry with a hint but no lens", () => {
+    expect(lensesOf("=smart, a")).toEqual(["a"])
+  })
+})
+
+describe("lensEntriesOf", () => {
+  it("keeps each entry whole, hint included", () => {
+    expect(lensEntriesOf(" a = smart ,, b, =x")).toEqual(["a = smart", "b"])
+  })
+})
+
+describe("lensOf", () => {
+  it("splits an entry at its first =, both sides trimmed", () => {
+    expect(lensOf(" plugin:b = vendor=x ")).toEqual({ lens: "plugin:b", model: "vendor=x" })
+  })
+
+  it("an entry without = has a blank hint", () => {
+    expect(lensOf("a")).toEqual({ lens: "a", model: "" })
+  })
 })
 
 describe("lensScopes", () => {

package/src/workflow-kit/quality.ts

@@ -1,11 +1,29 @@
 import { read } from "../flows/index.js"
 
-/** Split a comma-separated lens list: trimmed, blanks dropped. */
-export const lensesOf = (value: string): readonly string[] =>
+export interface LensEntry {
+  readonly lens: string
+  /** Blank when the entry carries none. */
+  readonly model: string
+}
+
+// Split at the first `=`: skill names may hold `:` (`plugin:skill`), never `=`.
+export const lensOf = (entry: string): LensEntry => {
+  const at = entry.indexOf("=")
+  return at < 0
+    ? { lens: entry.trim(), model: "" }
+    : { lens: entry.slice(0, at).trim(), model: entry.slice(at + 1).trim() }
+}
+
+/** Split a comma-separated lens list into whole entries, `<lens>` or `<lens>=<model>`: trimmed, blanks dropped. */
+export const lensEntriesOf = (value: string): readonly string[] =>
   value
     .split(",")
-    .map((lens) => lens.trim())
-    .filter((lens) => lens.length > 0)
+    .map((entry) => entry.trim())
+    .filter((entry) => lensOf(entry).lens.length > 0)
+
+/** The same list's lens names, model hints cut off. */
+export const lensesOf = (value: string): readonly string[] =>
+  lensEntriesOf(value).map((entry) => lensOf(entry).lens)
 
 /** One `<scope>.<lens>` entry per lens — the per-lens part of a skills or access export. */
 export const lensScopes = <T>(

package/src/workflows/feature/acceptance-criteria.feature

@@ -86,6 +86,14 @@ Feature: acceptance criteria carry stable IDs, and a sketch that states clear on
         - AC-1: `greeting` reads "Hello, world".
         """
       And step "design.gate.answer" changes nothing
+      And step "seam.check" changes nothing
+      And step "seam.naive" writes "src/acceptance.test.ts" with:
+        """
+        it("[AC-1] holds", () => {})
+        it("[AC-2] holds", () => {})
+        it("[AC-3] holds", () => {})
+        it("[AC-7] holds", () => {})
+        """
       And step "seam.naive" writes "src/greeting.ts" with:
         """
         export const greeting = "Hello, world"

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

@@ -57,7 +57,12 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
     Then the process rests at "seam.naive"
     And the last commit subject is "gtd(human): design.gate.answer → seam.naive"
 
-    Given step "seam.naive" writes "src/greeting.ts" with:
+    Given step "seam.check" changes nothing
+    And step "seam.naive" writes "src/acceptance.test.ts" with:
+      """
+      it("[AC-1] holds", () => {})
+      """
+    And step "seam.naive" writes "src/greeting.ts" with:
       """
       export const greeting = "Hello, world"
       """
@@ -99,7 +104,8 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
       gtd(check): start-gate.check → design.triage
       gtd(agent): design.triage → design.gate.answer
       gtd(human): design.gate.answer → seam.naive
-      gtd(agent): seam.naive → seam.judge
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → seam.judge
       gtd(judge): seam.judge → implement.building
       gtd(agent): implement.building → implement.health.check
       gtd(check): implement.health.check → implement.closing

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

@@ -47,6 +47,8 @@ const review = (text?: string): string =>
 
 const CALC = "export const add = (a: number, b: number) => a + b\n"
 
+const ACCEPTANCE = 'it("[AC-1] done", () => {})\n'
+
 const naivePlanned = () => {
   const repo = testRepo({
     workflow: CONFIG_SCAFFOLD,
@@ -77,7 +79,11 @@ describe("planAndBuild", () => {
               "# Requirements\n\n## Concerns\n\n### S\n\n- `s`\n\n## Acceptance Criteria\n\n- AC-1: done\n",
             ),
           "design.gate.answer": () => undefined,
-          "seam.naive": (_, r) => r.write("src/calc.ts", SUBTRACT),
+          "seam.naive": (_, r) => {
+            r.write("src/calc.ts", SUBTRACT)
+            r.write("src/calc.test.ts", ACCEPTANCE)
+          },
+          "seam.check": () => undefined,
           "seam.judge": () => '[{"id":"shape","answer":"refactor-first","p":0.9}]',
           "refactor.deriving": runsItsScript,
           "refactor.building": (_, r) => r.write("src/calc.ts", SUBTRACT),
@@ -112,7 +118,11 @@ describe("planAndBuild", () => {
       "start-gate.check": () => undefined,
       "design.triage": requirements,
       "design.gate.answer": () => undefined,
-      "seam.naive": (_: unknown, r: typeof repo) => r.write("src/calc.ts", `${CALC}// naive\n`),
+      "seam.naive": (_: unknown, r: typeof repo) => {
+        r.write("src/calc.ts", `${CALC}// naive\n`)
+        r.write("src/calc.test.ts", ACCEPTANCE)
+      },
+      "seam.check": () => undefined,
       "seam.judge": () => '[{"id":"shape","answer":"land","p":0.9}]',
       "implement.building": (_: unknown, r: typeof repo) =>
         r.write("src/calc.ts", `${CALC}// built\n`),
@@ -341,7 +351,10 @@ describe("an in-flight 28.0.0 naive-pass process", () => {
           "# Requirements\n\n## Concerns\n\n### S\n\n- `s`\n\n## Acceptance Criteria\n\n- AC-1: done\n",
         ),
       "design.gate.answer": () => undefined,
-      "seam.naive": (_, r) => r.write("src/calc.ts", `${CALC}// naive\n`),
+      "seam.naive": (_, r) => {
+        r.write("src/calc.ts", `${CALC}// naive\n`)
+        r.write("src/calc.test.ts", ACCEPTANCE)
+      },
     })
     const kept = /Gtd-Kept: (\w+)/.exec(repo.messages().at(-1)!)![1]!
     const seen: Record<string, number> = {
@@ -366,16 +379,13 @@ describe("an in-flight 28.0.0 naive-pass process", () => {
     return repo
   }
 
+  // seam.check now follows every naive pass, so no rest past the first naive pass replays.
   for (const [name, trail] of Object.entries(trails)) {
-    const replays = name !== "refactor-first"
-    it(`${name}: ${replays ? "every rest replays to itself" : "every rest from the verdict on fails replay"}`, async () => {
+    it(`${name}: every rest past the naive pass fails replay`, async () => {
       for (let upTo = 1; upTo <= trail.length; upTo++) {
         const rest = trail[upTo - 1]![2]
         const repo = await forged(trail, upTo)
-        if (replays) expect((await repo.next()).state, rest).toBe(rest)
-        else {
-          await expect(repo.next(), rest).rejects.toThrow("the workflow changed under this process")
-        }
+        await expect(repo.next(), rest).rejects.toThrow("the workflow changed under this process")
       }
     })
   }

package/src/workflows/feature/lens-models.feature

@@ -0,0 +1,60 @@
+@inmem
+Feature: each quality lens runs on its own model hint
+
+  A `qualityReviews` entry may carry a model hint, `<lens>=<model>`. A lens
+  without one runs on the planner model (`smart`), except `conventions`,
+  `ponytail-review` and `test-audit`, which run on the coder model (`base`).
+
+  Background:
+    Given a gtd config with:
+      """
+      import { feature } from "@pmelab/gtd/workflows/feature"
+      export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
+      export default feature({
+        flagMode: false,
+        qualityReviews: "correctness, conventions, test-audit=opus",
+      })
+      """
+    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
+
+      ## Acceptance Criteria
+
+      - AC-1: `subtract(a, b)` returns `a - b`.
+      """
+    And step "design.gate.answer" changes nothing
+    And step "implement.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 "implement.health.check" changes nothing
+    And step "implement.closing" runs its script
+
+  Scenario: a hinted lens runs on its hint, every other lens on its default
+    When the process is driven
+    Then the process rests at "build.quality.correctness.reviewing"
+    And the output of gtd "next --json" contains "\"model\":\"smart\""
+    Given step "build.quality.correctness.reviewing" changes nothing
+    When the process is driven
+    Then the process rests at "build.quality.conventions.reviewing"
+    And the output of gtd "next --json" contains "\"model\":\"base\""
+    Given step "build.quality.conventions.reviewing" changes nothing
+    When the process is driven
+    Then the process rests at "build.quality.test-audit.reviewing"
+    And the output of gtd "next --json" contains "\"model\":\"opus\""
+    And the resting step's content contains "test-audit"