@pmelab/gtd 31.0.0 → 32.1.0

package/.claude-plugin/plugin.json

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

package/README.md

@@ -339,28 +339,29 @@ asks, and moves the process on only when you say so; a review you leave
 untouched signs off. While a step runs you can keep asking; requests for changes
 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; a later process on an already-stacked
-branch, such as review fixes, lands one commit per slice on the top pull request
-and keeps the stack; 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; to tear a
-stack down from its worktree, delete the top branch with
-`git push origin --delete`, since `gh pr close --delete-branch` cannot). 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 build 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 a
-failed push or `gh` call reports as a failure. While a ship or hand-off runs or
-is queued, `/gtd catch`, the doors, `/gtd <requirements>` and bare `/gtd` wait
-for its report. See
+commit per slice under one pull request (the default) or, set to `stack`, one
+stacked pull request per slice, see the [driver doc](docs/driver.md)); a process
+started for an issue ships with `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; on a branch an earlier ship in this clone stacked (unless
+`GTD_SHIP_MODE=commits`), a later process, such as review fixes, lands one
+commit per slice on the top pull request and keeps the stack, and 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; to tear a stack down from its worktree, delete
+the top branch with `git push origin --delete`, since
+`gh pr close --delete-branch` cannot). 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 build 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 a failed push or `gh` call reports as a failure. While
+a ship or hand-off runs or is queued, `/gtd catch`, the doors,
+`/gtd <requirements>` and bare `/gtd` wait for its report. See
 [Inside Claude Code](https://github.com/pmelab/gtd/blob/main/docs/driver.md#inside-claude-code-the-gtd-mod).
 
 ### Then let an agent build your own
@@ -470,13 +471,16 @@ noted in steps 3 and 4 below.
    Once the change is built, the whole change goes through a qualitative review
    lap before you see anything: six lenses, one turn each, in order —
    `correctness`, `owasp-security`, `ponytail-review`, `test-audit`,
-   `conventions`, `spec-challenge`. Each traces the change from its own angle
-   and records every finding, blocking or not; one fix turn then fixes ALL of
-   them once, with no re-review after the fix. A clean turn means approval only
-   when that lens found nothing at all. This lap is where code quality is looked
-   at, and every round pays for it. It never replaces step 4 — your review stays
-   the final gate, and nothing here skips it. The `fix` door (below) repairs a
-   red baseline through this same lap.
+   `conventions`, `spec-challenge`. `correctness`, `owasp-security` and
+   `spec-challenge` run on the planner model (`smart`), the other three on the
+   coder model (`base`); a `qualityReviews` entry `<lens>=<model>` picks a
+   lens's own. Each traces the change from its own angle and records every
+   finding, blocking or not; one fix turn then fixes ALL of them once, with no
+   re-review after the fix. A clean turn means approval only when that lens
+   found nothing at all. This lap is where code quality is looked at, and every
+   round pays for it. It never replaces step 4 — your review stays the final
+   gate, and nothing here skips it. The `fix` door (below) repairs a red
+   baseline through this same lap.
 
    A red suite that keeps failing past a few fix attempts escalates instead of
    retrying forever: an agent turn reads the failing output and writes

package/claude/hooks/ship.ts

@@ -49,7 +49,7 @@ export function costTrailers(log: string) {
 export type ShipMode = "stack" | "commits"
 
 export function shipMode(raw: string | undefined): ShipMode | { refusal: string } {
-  if (!raw) return "stack"
+  if (!raw) return "commits"
   if (raw === "stack" || raw === "commits") return raw
   return { refusal: `GTD_SHIP_MODE must be 'stack' or 'commits', not '${raw}'.` }
 }
@@ -209,8 +209,8 @@ async function preflight(git: Git, ok: Ok) {
 }
 
 export async function ship(io: ShipIo, isDry: boolean, rawMode?: string): Promise<Shipped> {
-  const mode = shipMode(rawMode)
-  if (typeof mode === "object") return fail(mode.refusal)
+  const valid = shipMode(rawMode)
+  if (typeof valid === "object") return fail(valid.refusal)
   const git = async (...args: string[]) => (await io.run(["git", ...args])).out.trim()
   const ok = async (...args: string[]) => (await io.run(["git", ...args])).code === 0
 
@@ -223,6 +223,10 @@ export async function ship(io: ShipIo, isDry: boolean, rawMode?: string): Promis
   const live = names(await git("config", "--local", "--get", STACK_KEY(branch)))
   const retired = names(await git("config", "--local", "--get", RETIRED_KEY(branch)))
   const recorded = [...live, ...retired]
+  // Unset keeps a live stack stacking: commits mode would retarget its top PR
+  // and strand the lower ones. A dead record ships as commits.
+  const stacked = !rawMode && live.length > 0 && (await chainsToHead(git, ok, branch, live))
+  const mode: ShipMode = stacked ? "stack" : valid
   const squashed = await squash(io, git, ok, branch, baseBranch, isDry, mode)
   if (!squashed.ok) return squashed
   // Until the PR step succeeds the record only moves aside: a retry must not

package/dist/chunks/{reserved-CHTJTzpA.mjs → reserved-2fV0mj14.mjs}

@@ -1322,11 +1322,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
 });

package/dist/chunks/{tail-CCsDBbZe.mjs → tail-BynhCfuv.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, U as handOffAwaitReviewMessage, _ as REVIEW, b as fixCheck, d as guarded, f as healthy, l as escalation, m as QUALITY, v as awaitReview, w as reviewMissing, x as fixQuality } from "./reserved-CHTJTzpA.mjs";
+import { fixFindings, lensEntriesOf, lensOf, qualityLap as qualityLap$1, reviewToHandOff } from "../workflow-kit.mjs";
+import { E as reviewing, S as fixRisks, T as reviewQuality, U as handOffAwaitReviewMessage, _ as REVIEW, b as fixCheck, d as guarded, f as healthy, l as escalation, m as QUALITY, v as awaitReview, w as reviewMissing, x as fixQuality } from "./reserved-2fV0mj14.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";
@@ -9,7 +9,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),

package/dist/workflow-kit.mjs

@@ -47,8 +47,20 @@ const gate = (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. */
@@ -338,4 +350,4 @@ const reviewToHandOff = async (base, p) => {
 	}
 };
 //#endregion
-export { assertionLines, escalation, fixFindings, gate, healthy, lensScopes, lensesOf, qualityLap, removedAssertions, review, reviewToHandOff, routeNotes, untilSettled };
+export { assertionLines, escalation, fixFindings, gate, healthy, lensEntriesOf, lensOf, lensScopes, lensesOf, qualityLap, removedAssertions, review, reviewToHandOff, routeNotes, untilSettled };

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { gt as requireFlag, ht as registryEntry, i as skills, lt as defaults, n as summary, o as flagShipped, pt as flagReferences, r as access, t as steering, ut as envDefaults, y as coder } from "../chunks/reserved-CHTJTzpA.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-CCsDBbZe.mjs";
+import { gt as requireFlag, ht as registryEntry, i as skills, lt as defaults, n as summary, o as flagShipped, pt as flagReferences, r as access, t as steering, ut as envDefaults, y as coder } from "../chunks/reserved-2fV0mj14.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-BynhCfuv.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, 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 reviewEditNotesCapture, A as buildReviewCollectingPrompt, B as designTriagePrompt, C as planner, D as agentWithSkills, E as reviewing, F as clearCriteriaQuestion, G as implementBuildingPrompt, I as criterionLine, J as normaliseCriteriaScript, K as implementFixPrompt, L as deferNotesScript, M as buildReviewTriageMessage, N as builderSystem, O as buildReviewAnswerQuestionsPrompt, P as clearCriteriaMessage, Q as refactorRules, R as designGateAnswerMessage, S as fixRisks, W as idleMessage, X as refactorDroppedRefusal, Y as refactorBuildingPrompt, Z as refactorFixPrompt, _ as REVIEW, a as flagModeOn, at as seamSteerMessage, b as fixCheck, ct as unwindFailure, d as guarded, dt as testFileGlobs, et as reviewEditsCapture, f as healthy, g as REQUIREMENTS, h as REFACTOR, i as skills, it as seamByHandMessage, j as buildReviewFixNitsPrompt, k as buildReviewAwaitAfterDeferMessage, lt as defaults, n as summary, nt as reviewNotesCapture, ot as startGateBlockedMessage, p as FEEDBACK, q as naivePassPrompt, r as access, rt as reviewerSystem, s as shipped, st as unwindFailedMessage, t as steering, u as gate, ut as envDefaults, v as awaitReview, w as reviewMissing, y as coder, z as designSystem } from "../chunks/reserved-CHTJTzpA.mjs";
-import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-CCsDBbZe.mjs";
+import { lensEntriesOf, review as review$1 } from "../workflow-kit.mjs";
+import { $ as reviewEditNotesCapture, A as buildReviewCollectingPrompt, B as designTriagePrompt, C as planner, D as agentWithSkills, E as reviewing, F as clearCriteriaQuestion, G as implementBuildingPrompt, I as criterionLine, J as normaliseCriteriaScript, K as implementFixPrompt, L as deferNotesScript, M as buildReviewTriageMessage, N as builderSystem, O as buildReviewAnswerQuestionsPrompt, P as clearCriteriaMessage, Q as refactorRules, R as designGateAnswerMessage, S as fixRisks, W as idleMessage, X as refactorDroppedRefusal, Y as refactorBuildingPrompt, Z as refactorFixPrompt, _ as REVIEW, a as flagModeOn, at as seamSteerMessage, b as fixCheck, ct as unwindFailure, d as guarded, dt as testFileGlobs, et as reviewEditsCapture, f as healthy, g as REQUIREMENTS, h as REFACTOR, i as skills, it as seamByHandMessage, j as buildReviewFixNitsPrompt, k as buildReviewAwaitAfterDeferMessage, lt as defaults, n as summary, nt as reviewNotesCapture, ot as startGateBlockedMessage, p as FEEDBACK, q as naivePassPrompt, r as access, rt as reviewerSystem, s as shipped, st as unwindFailedMessage, t as steering, u as gate, ut as envDefaults, v as awaitReview, w as reviewMissing, y as coder, z as designSystem } from "../chunks/reserved-2fV0mj14.mjs";
+import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-BynhCfuv.mjs";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {
 	let fence;
@@ -711,7 +711,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,

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 fixReviewNotesPrompt, V as finisherSystem, _ as REVIEW, c as baseline, i as skills, lt as defaults, n as summary, r as access, s as shipped, t as steering, ut as envDefaults, y as coder } from "../chunks/reserved-CHTJTzpA.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-CCsDBbZe.mjs";
+import { D as agentWithSkills, H as fixReviewNotesPrompt, V as finisherSystem, _ as REVIEW, c as baseline, i as skills, lt as defaults, n as summary, r as access, s as shipped, t as steering, ut as envDefaults, y as coder } from "../chunks/reserved-2fV0mj14.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-BynhCfuv.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 { i as skills, lt as defaults, n as summary, r as access, s as shipped, t as steering, tt as reviewGateBlockedMessage, u as gate, ut as envDefaults } from "../chunks/reserved-CHTJTzpA.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-CCsDBbZe.mjs";
+import { i as skills, lt as defaults, n as summary, r as access, s as shipped, t as steering, tt as reviewGateBlockedMessage, u as gate, ut as envDefaults } from "../chunks/reserved-2fV0mj14.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-BynhCfuv.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 { ft as flagMentions, gt as requireFlag, i as skills, lt as defaults, mt as flipProblems, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, ut as envDefaults, y as coder } from "../chunks/reserved-CHTJTzpA.mjs";
+import { ft as flagMentions, gt as requireFlag, i as skills, lt as defaults, mt as flipProblems, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, ut as envDefaults, y as coder } from "../chunks/reserved-2fV0mj14.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

@@ -476,8 +476,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. */
@@ -18106,11 +18118,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 +37648,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 +38457,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,
@@ -38803,4 +38823,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 { 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, 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": "31.0.0",
+  "version": "32.1.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/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"

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

@@ -0,0 +1,62 @@
+@inmem
+Feature: the refactor review's lenses take their model hints from refactorQualityReviews alone
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness=base"
+    And an environment variable "GTD_REFACTORQUALITYREVIEWS" set to "correctness, conventions=opus"
+    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`.
+
+      ## Acceptance Criteria
+
+      - AC-1: the change behaves as described.
+      """
+    And step "design.gate.answer" changes nothing
+
+  Scenario: a refactor lens runs on its refactorQualityReviews hint, else its default
+    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 op = (a: number, b: number, sign: number) => a + sign * b
+      export const add = (a: number, b: number) => op(a, b, 1)
+      """
+    And step "refactor.health.check" changes nothing
+    And step "refactor.closing" runs its script
+    When the process is driven
+    Then the process rests at "refactor.build.quality.correctness.reviewing"
+    And the output of gtd "next --json" contains "\"model\":\"smart\""
+    Given step "refactor.build.quality.correctness.reviewing" changes nothing
+    When the process is driven
+    Then the process rests at "refactor.build.quality.conventions.reviewing"
+    And the output of gtd "next --json" contains "\"model\":\"opus\""

package/src/workflows/feature/refactor.ts

@@ -13,7 +13,7 @@ import {
   type Change,
   type DiffShapeResult,
 } from "../../flows/index.js"
-import { lensesOf } from "../../workflow-kit/index.js"
+import { lensEntriesOf } from "../../workflow-kit/index.js"
 import { markFenced } from "../shared/fences.js"
 import { healthy, type Guard } from "../shared/health.js"
 import { coder, FEEDBACK, REFACTOR } from "../shared/steps.js"
@@ -343,7 +343,7 @@ export const reviewedRefactor = async (
         green: true,
         guard,
         guardRests: false,
-        lenses: lensesOf(vars.refactorQualityReviews ?? ""),
+        lenses: lensEntriesOf(vars.refactorQualityReviews ?? ""),
         feedback,
         fixAccess: strayAccess(p.strays),
         lensBase: entry,

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

@@ -79,6 +79,17 @@ describe("naivePass", () => {
     expect(request.options).toMatchObject({ keep: true })
   })
 
+  it("runs on the coder model, base by default, the coderModel setting otherwise", async () => {
+    const plain = await capture()
+    const set = await captureStep(() => naivePass(), {
+      scope: "seam",
+      env: { coderModel: "sonnet" },
+    })
+    if (plain.kind !== "agent" || set.kind !== "agent") throw new Error("unreachable")
+    expect(plain.options.model).toBe("base")
+    expect(set.options.model).toBe("sonnet")
+  })
+
   it("carries the rejection into the retry prompt", async () => {
     const request = await capture({ strays: ["src/core.ts"], p: 0.8 })
     if (request.kind !== "agent") throw new Error("unreachable")
@@ -251,6 +262,11 @@ describe("implement", () => {
     return request.prompt
   }
 
+  it("builds on the coder model", async () => {
+    await building("abc")
+    expect(lastOptions?.model).toBe("base")
+  })
+
   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 }),

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

@@ -124,3 +124,16 @@ describe("the feature workflow's own steps declare skills — a step's rendered
     expect(request.options).toMatchObject({ file: ".gtd/TODO.md" })
   })
 })
+
+describe("the feature workflow's planning steps run on the planner model", () => {
+  it("design triage defaults to smart and follows plannerModel", async () => {
+    const plain = await captureStep(() => steps.triage("base"), { scope: "design" })
+    const set = await captureStep(() => steps.triage("base"), {
+      scope: "design",
+      env: { plannerModel: "opus" },
+    })
+    if (plain.kind !== "agent" || set.kind !== "agent") throw new Error("unreachable")
+    expect(plain.options.model).toBe("smart")
+    expect(set.options.model).toBe("opus")
+  })
+})

package/src/workflows/index.ts

@@ -19,7 +19,7 @@ export {
   tail,
   type TailOptions,
 } from "./shared/tail.js"
-export { lensesOf } from "../workflow-kit/index.js"
+export { lensEntriesOf, lensesOf, lensOf } from "../workflow-kit/index.js"
 export * from "./feature/steps.js"
 export * from "./feature/criteria.js"
 export * from "./feature/planning.js"

package/src/workflows/shared/skills.test.ts

@@ -107,4 +107,11 @@ describe("the bundled workflow's skills export", () => {
         .sort(),
     ).toEqual(["build.quality.correctness", "build.quality.my-lens"])
   })
+
+  it("keys a hinted entry by its lens alone, with the lens's own skills", () => {
+    const custom = skills({ ...defaults, qualityReviews: "my-lens=smart, correctness = base" })
+    expect(custom["build.quality.my-lens"]).toEqual(["my-lens"])
+    expect(custom["build.quality.correctness"]).toEqual(["code-review-and-quality"])
+    expect(Object.keys(custom).some((k) => k.includes("="))).toBe(false)
+  })
 })

package/src/workflows/shared/steps.test.ts

@@ -107,3 +107,48 @@ describe("the bundled workflow's steps declare skills — a bundled step's rende
     expect(carried.prompt).toContain("Carry-over: commit `abc1234`")
   })
 })
+
+describe("the bundled workflow's model hints", () => {
+  const modelOf = async (
+    fn: () => Promise<void>,
+    context: Parameters<typeof captureStep>[1] = {},
+  ): Promise<string | undefined> => {
+    const request = await captureStep(fn, { scope: "build", ...context })
+    if (request.kind !== "agent") throw new Error(`expected an agent step, got ${request.kind}`)
+    return request.options.model
+  }
+
+  it.each([
+    ["correctness", "smart"],
+    ["owasp-security", "smart"],
+    ["spec-challenge", "smart"],
+    ["conventions", "base"],
+    ["ponytail-review", "base"],
+    ["test-audit", "base"],
+    ["my-lens", "smart"],
+  ])("lens %s defaults to %s", async (lens, model) => {
+    expect(await modelOf(() => steps.reviewQuality(lens))).toBe(model)
+  })
+
+  it("a lens's default follows the planner or coder setting it stands for", async () => {
+    const env = { plannerModel: "opus", coderModel: "sonnet" }
+    expect(await modelOf(() => steps.reviewQuality("correctness"), { env })).toBe("opus")
+    expect(await modelOf(() => steps.reviewQuality("conventions"), { env })).toBe("sonnet")
+  })
+
+  it("a model passed in wins over the lens's default; a blank one is none", async () => {
+    expect(await modelOf(() => steps.reviewQuality("correctness", undefined, "base"))).toBe("base")
+    expect(await modelOf(() => steps.reviewQuality("conventions", undefined, "opus"))).toBe("opus")
+    expect(await modelOf(() => steps.reviewQuality("conventions", undefined, ""))).toBe("base")
+  })
+
+  it("a lens named like an Object member still gets its default", async () => {
+    expect(await modelOf(() => steps.reviewQuality("constructor"))).toBe("smart")
+  })
+
+  it("the fix loop runs on the coder model, base by default", async () => {
+    expect(await modelOf(() => steps.fixCheck())).toBe("base")
+    expect(await modelOf(() => steps.fixQuality())).toBe("base")
+    expect(await modelOf(() => steps.fixCheck(), { env: { coderModel: "sonnet" } })).toBe("sonnet")
+  })
+})

package/src/workflows/shared/steps.ts

@@ -66,15 +66,17 @@ export const builtInLenses: Readonly<Record<string, BuiltInLens>> = {
   "spec-challenge": { skills: [], brief: t.specChallengeBrief },
 }
 
+const coderLenses: ReadonlySet<string> = new Set(["conventions", "ponytail-review", "test-audit"])
+
 /** One quality review through `lens`; each lens is its own scope, so its own conversation and skills. */
-export const reviewQuality = (lens: string, base?: string): Promise<void> =>
+export const reviewQuality = (lens: string, base?: string, model?: string): Promise<void> =>
   t.agentWithSkills(
     `quality.${lens}.reviewing`,
     t.buildQualityReviewingPrompt(lens, builtInLenses[lens]?.brief, base),
     {
       label: "Reviewing (one quality lens)",
       file: QUALITY,
-      model: planner(),
+      model: model || (coderLenses.has(lens) ? coder() : planner()),
       system: t.reviewerSystem(),
       allowEmpty: true,
     },

package/src/workflows/shared/tail.test.ts

@@ -208,18 +208,23 @@ describe("the hand-off review", () => {
 })
 
 const prompts: string[] = []
+const models: (string | undefined)[] = []
 
 describe("the quality lap's lenses", () => {
   const lap = async (run: () => Promise<unknown>, vars: Record<string, string> = {}) => {
     const log: string[] = []
     prompts.length = 0
+    models.length = 0
     installContext(
       fixtureContext(
         { vars },
         {
           step: (request: StepRequest) => {
             if (request.kind !== "restart") log.push(request.name)
-            if (request.kind === "agent") prompts.push(request.prompt)
+            if (request.kind === "agent") {
+              prompts.push(request.prompt)
+              models.push(request.options.model)
+            }
             return Promise.resolve()
           },
           pushScope: () => undefined,
@@ -279,6 +284,31 @@ describe("the quality lap's lenses", () => {
     expect(prompts[0]).not.toContain("from `R`")
   })
 
+  it("each lens runs on its qualityReviews hint, else its default, under its plain name", async () => {
+    const log = await lap(() => qualityLap(), {
+      qualityReviews: "correctness=base, conventions, my-lens",
+    })
+    expect(log).toEqual([
+      "quality.correctness.reviewing",
+      "quality.conventions.reviewing",
+      "quality.my-lens.reviewing",
+    ])
+    expect(models).toEqual(["base", "base", "smart"])
+  })
+
+  it("lenses passed in carry their own hints, never qualityReviews'", async () => {
+    const log = await lap(
+      () =>
+        tail(() => Promise.resolve(), {
+          green: true,
+          lenses: ["correctness", "conventions=opus"],
+        }),
+      { qualityReviews: "correctness=base" },
+    )
+    expect(log).toEqual(["quality.correctness.reviewing", "quality.conventions.reviewing"])
+    expect(models).toEqual(["smart", "opus"])
+  })
+
   it("tail passes lenses to its lap and a guard after each lens turn", async () => {
     let guards = 0
     const log = await lap(() =>

package/src/workflows/shared/tail.ts

@@ -35,8 +35,11 @@ export const qualityLap = (
   base?: string,
 ): Promise<"clean" | "findings"> =>
   kit.qualityLap(
-    lenses ?? kit.lensesOf(vars.qualityReviews ?? ""),
-    guarded((lens: string) => reviewQuality(lens, base), guard),
+    lenses ?? kit.lensEntriesOf(vars.qualityReviews ?? ""),
+    guarded((entry: string) => {
+      const { lens, model } = kit.lensOf(entry)
+      return reviewQuality(lens, base, model)
+    }, guard),
     QUALITY,
   )
 
@@ -77,7 +80,7 @@ export interface TailOptions {
   readonly green?: boolean | undefined
   /** Runs after every code-changing turn: fix-check, quality fix, risk fix, nit fix, escalation describe. */
   readonly guard?: Guard | undefined
-  /** Quality-lap lenses; default `lensesOf(vars.qualityReviews)`. */
+  /** Quality-lap lens entries, `<lens>` or `<lens>=<model>`; default `lensEntriesOf(vars.qualityReviews)`. */
   readonly lenses?: readonly string[] | undefined
   /** `false` leaves the escalation's human rests unguarded; default `true`. */
   readonly guardRests?: boolean | undefined