@pmelab/gtd 50.0.0 → 51.0.1

package/.claude-plugin/plugin.json

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

package/README.md

@@ -545,30 +545,31 @@ noted in steps 3 and 4 below.
    each led by its tier and reason (`_critical: security, one-way door_`) — the
    phone shows it on the chunk's card. A chunk the judge is unsure of, or whose
    evidence the budget cut, is `critical`. On `refactor-first` the refactor
-   slice gets a review of its own first, composed by gtd from its lap's notes,
-   before the feature is built; see [the naive pass](#the-naive-pass). **Every
-   note needs exactly one tick before `gtd land` accepts the review**
-   (`answer-completeness`; an open `- H:` thread waiting on the agent is the one
-   exception). Fix as suggested joins the nit batch below, unjudged; won't fix
-   drops the note and records it as `Gtd-Mark: wontfix=<title>` on the gate's
-   commit; your own answer is judged like a note. A note you answered is left
-   out of the fresh review after a nit fix. Land with every note answered and
-   nothing else changed to approve, or write what is wrong — disagreeing with a
-   fix or a drop means writing a note of your own. Approving ends the process
-   (at the refactor review, it moves on to the feature); feedback is judged note
-   by note, each as `edit`, `question`, `nit` or `praise`. An `edit` sends the
-   process back to step 2 for re-derived requirements — the built criteria keep
-   their IDs (reworded in place when their behaviour changes) and new behaviour
-   gets new ones — then the implementation is amended to meet them, with no new
-   naive pass or seam judge, every criterion's coverage is judged again, the
-   quality lap runs, and you review again. At the refactor review an `edit`
-   re-derives the refactor instead. A `question` is answered inline under your
-   note and the process stops at the review again — no new plan. A `nit` is
-   fixed in one batch, the suite must go green (a red one gets fix turns first),
-   then a fresh review of the change stops at the review again. `praise` is
-   dropped; a round of only praise signs off. When a round mixes them, questions
-   are answered and nits fixed first, then the edits are planned — risk: the
-   planning lap may redo nit fixes it touches.
+   slice gets a walkthrough of its own first, covering the whole refactor on
+   every round, before the feature is built; see
+   [the naive pass](#the-naive-pass). **Every note needs exactly one tick before
+   `gtd land` accepts the review** (`answer-completeness`; an open `- H:` thread
+   waiting on the agent is the one exception). Fix as suggested joins the nit
+   batch below, unjudged; won't fix drops the note and records it as
+   `Gtd-Mark: wontfix=<title>` on the gate's commit; your own answer is judged
+   like a note. A note you answered is left out of the fresh review after a nit
+   fix. Land with every note answered and nothing else changed to approve, or
+   write what is wrong — disagreeing with a fix or a drop means writing a note
+   of your own. Approving ends the process (at the refactor review, it moves on
+   to the feature); feedback is judged note by note, each as `edit`, `question`,
+   `nit` or `praise`. An `edit` sends the process back to step 2 for re-derived
+   requirements — the built criteria keep their IDs (reworded in place when
+   their behaviour changes) and new behaviour gets new ones — then the
+   implementation is amended to meet them, with no new naive pass or seam judge,
+   every criterion's coverage is judged again, the quality lap runs, and you
+   review again. At the refactor review an `edit` re-derives the refactor
+   instead. A `question` is answered inline under your note and the process
+   stops at the review again — no new plan. A `nit` is fixed in one batch, the
+   suite must go green (a red one gets fix turns first), then a fresh review of
+   the change stops at the review again. `praise` is dropped; a round of only
+   praise signs off. When a round mixes them, questions are answered and nits
+   fixed first, then the edits are planned — risk: the planning lap may redo nit
+   fixes it touches.
 
    Each `edit` note also gets a severity tier from four judge questions
    (security, reversibility, blast radius, new concept). Every tier is
@@ -692,6 +693,13 @@ an uncovered one goes back to the agent (twice, then to you) instead of ending
 the feature, and each covered ID is recorded as a `Gtd-Mark: covers=<id>`
 trailer. See
 [Acceptance-criteria coverage](docs/configuration.md#acceptance-criteria-coverage).
+Then an agent uses the slice by hand — the real program in a scratch directory,
+the real page, guided by a project skill or a manual testing section in
+`AGENTS.md`, `CLAUDE.md` or `README.md` — and writes `.gtd/PROTOTYPE.md`: per
+criterion pass, fail or blocked, with the steps run and what it saw. Failures
+are fixed and re-tested before the quality lap, up to `prototypeRounds` (3) fix
+rounds; past them, with only blocked items, or with no way to test found, it
+rests for you. See [The hands-on test](docs/configuration.md#the-hands-on-test).
 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

package/dist/chunks/{reserved-CdOzKFVX.mjs → reserved-CUkk9XgL.mjs}

@@ -243,6 +243,7 @@ const defaults = {
 	qualityReviews: "correctness, owasp-security, ponytail-review, test-audit, conventions, spec-challenge",
 	refactorQualityReviews: "correctness, ponytail-review, conventions",
 	continuations: "3",
+	prototypeRounds: "3",
 	continuationStall: "2"
 };
 /** Environment settings. */
@@ -320,6 +321,11 @@ task in front of you end to end, tests first, and come back to fix
 things when redirected — a failing check, or reviewer feedback. Stay
 strictly inside that task; never touch code outside it. Treat feedback as the
 diagnosis to act on; discard it, with reason, only when simply wrong.`;
+const testerPersona = `You are the hands-on tester in gtd's build pipeline: use what was just
+built the way a person would — run the real program, open the real
+page, call the real endpoint — and report exactly what you did and
+what you saw. Never fix anything yourself, and never pass a criterion
+you did not watch hold.`;
 const finisherPersona = `You are the closing identity in gtd's build pipeline — the last coder
 before it closes. Fix a late-breaking failing check after sign-off,
 focused and minimal. Every turn lands its own commit — nothing here
@@ -745,8 +751,11 @@ const acceptanceCriteriaBlock = `
 Whichever lap this is, \`.gtd/REQUIREMENTS.md\` carries a
 \`## Acceptance Criteria\` section: one \`- AC-<n>: <criterion>\` line
 per criterion, numbered from \`AC-1\`. They bind every later step —
-the build is done when each one holds — so each must be checkable: a
-test or a command shows it holds or not. A later lap keeps every ID:
+the build is done when each one holds — so each must be behaviour a
+test can pin: one that fails when it does not hold. A green suite, a
+passing typecheck or lint, a generator or build that runs — the health
+check enforces those on every lap, so none is a criterion; fold what it
+must produce into a behaviour a test can observe. A later lap keeps every ID:
 reword a criterion in place, append a new one with the next unused
 number, delete a dropped one — never renumber, never reuse an ID. When
 the file holds no list (a review loop-back rewrites it), recover the
@@ -854,7 +863,7 @@ const clearCriteriaQuestion = {
 	id: "clear",
 	primitive: "noul",
 	instructions: "state.criteria lists the acceptance criteria the human's sketch (state.sketch) stated, as gtd numbered them. Decide whether they can stand as the binding definition of done, with no design conversation.",
-	criteria: "yes: every criterion is clear and checkable — a test or a command can show it holds or not — and together they say what to build. no: any one criterion is vague, subjective or untestable, or the sketch leaves an open product question. Unsure means no."
+	criteria: "yes: every criterion is clear behaviour a test can pin — a test would fail if it did not hold — and together they say what to build. no: any one criterion is vague, subjective or untestable, only a command can check it (a suite, typecheck, lint, build or generator run that passes), or the sketch leaves an open product question. Unsure means no."
 };
 const clearCriteriaMessage = () => `The sketch stated its own acceptance criteria. Run \`gtd judge answer\` and
 pipe \`yes\` when every one is clear and checkable, so design is skipped and
@@ -1773,6 +1782,80 @@ Two ways forward (then run \`gtd land\`):
 - **Overrule** — land a clean tree to finish without them. The slice records
   the IDs it covers and, as \`uncovered\`, the ones it does not
 `;
+const testerSystem = () => `${testerPersona}
+
+${agentConduct}`;
+const PROTOTYPE_FORMAT = `- Write \`.gtd/PROTOTYPE.md\`, replacing any earlier report: one \`## \` chunk
+  per criterion, headed \`## AC-<n>: pass\`, \`## AC-<n>: fail\` or
+  \`## AC-<n>: blocked\`, then one chunk per problem you found outside any
+  criterion, headed \`## Problem <short title>: fail\` (\`: pass\` once a
+  re-test shows it fixed). Under each: the exact steps you ran, what you
+  observed (output, a screenshot path, the error), and for a failure what
+  you expected instead
+- \`blocked\` is for a criterion you could not exercise, or one whose
+  expected behaviour itself looks wrong — say which and why: a person
+  decides it, never a fixer`;
+const prototypeTestingPrompt = (slice, retest) => `${stateFileRules}
+- Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
+${sliceLine(slice)}- The change is built and its suite is green. Now test it by hand: use
+  every acceptance criterion the way a person would and watch what
+  happens. Running the test suite is not this — it already ran
+- Find how this project is exercised for real, in this order: a project
+  skill that launches or drives it (e.g. \`.claude/skills/*\`); a manual
+  testing or running section in \`AGENTS.md\`, \`CLAUDE.md\` or \`README.md\`;
+  failing those, the project's shape — a browser or Playwright for a web
+  project, the built CLI in a scratch directory for a CLI, a request client
+  for an API
+- Found none and recognised no shape: write only a chunk headed
+  \`## No testing instructions\` saying what you looked for, and finish —
+  a person is asked; never guess
+- Test in a disposable place only — a scratch directory outside this
+  repository, a throwaway repository, a dev server on a free port — never
+  against the user's real data or this working tree. Point every tool's
+  output (screenshots, traces, test results) outside the repository too
+${retest ? `- This is a re-test: \`.gtd/PROTOTYPE.md\` holds the last round's report and
+  a fix turn or a person has changed the code since. Re-test every failed or blocked criterion and
+  every problem it lists in full, then re-run the passed ones quickly
+` : ""}${PROTOTYPE_FORMAT}
+- Change nothing but \`.gtd/PROTOTYPE.md\` — a turn that does is refused
+- Leave everything uncommitted and finish your turn — do not commit
+`;
+const prototypeFixingPrompt = (slice) => `${stateFileRules}
+- Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
+${sliceLine(slice)}${criteriaBinding(true)}
+- Read \`.gtd/PROTOTYPE.md\`: a hands-on test of the change. Fix every
+  \`fail\` chunk of this change's criteria${slice === void 0 ? "" : " (this slice's only)"} or a problem found
+  beside them, at its cause, with a test that shows it; leave \`blocked\`
+  ones to the person
+- A \`fail\` the code does not explain (the tester misread what it saw) has
+  nothing to fix: leave it and change nothing for it — the next round re-tests
+- Leave \`.gtd/PROTOTYPE.md\` as it is: the next round re-tests from it
+- Run \`${env.testCommand}\` and finish only once it is green
+- Leave everything uncommitted and finish your turn — do not commit
+`;
+const openItems = (items) => items.map((item) => `- ${item.subject}: ${item.verdict}`).join("\n");
+const prototypeOpenMessage = (items, rounds) => `The hands-on test of this slice still has open items${rounds > 0 ? ` after ${rounds} fix round${rounds === 1 ? "" : "s"}` : ", and none a fixer can take"}:
+${openItems(items)}
+
+\`.gtd/PROTOTYPE.md\` holds the last report: the steps run and what was seen.
+
+Two ways forward (then run \`gtd land\`):
+- **Fix** — change the code, or the testing instructions, yourself (the
+  criteria are settled: an edit to them is refused); the suite runs and the
+  slice is tested again, with a fresh round budget
+- **Overrule** — land a clean tree to go on to the quality lap with these
+  items open
+`;
+const prototypeUnguidedMessage = () => `The hands-on test found no way to exercise this project for real — no
+project skill, no manual testing section in \`AGENTS.md\`, \`CLAUDE.md\` or
+\`README.md\`, and no project shape it recognised. \`.gtd/PROTOTYPE.md\` says
+what it looked for.
+
+Two ways forward (then run \`gtd land\`):
+- **Instruct** — add testing instructions (a project skill, or a manual
+  testing section); the slice is tested again
+- **Skip** — land a clean tree to go on to the quality lap untested
+`;
 //#endregion
 //#region src/workflows/shared/steps.ts
 const FEEDBACK = ".gtd/FEEDBACK.md";
@@ -1784,6 +1867,7 @@ const REFACTOR_NOTE = ".gtd/REFACTOR-NOTE.md";
 const QUALITY = ".gtd/QUALITY.md";
 const SLICES = ".gtd/SLICES.md";
 const HANDOFF = ".gtd/HANDOFF.md";
+const PROTOTYPE = ".gtd/PROTOTYPE.md";
 const planner = () => env.plannerModel ?? "";
 const coder = () => env.coderModel ?? "";
 const fixCheck = (rules) => agentWithSkills("fix", buildFixPrompt(rules), {
@@ -2028,6 +2112,7 @@ const ShippedOptions = Struct({
 	qualityReviews: setting,
 	refactorQualityReviews: setting,
 	continuations: setting,
+	prototypeRounds: setting,
 	continuationStall: setting,
 	testCommand: setting,
 	plannerModel: setting,
@@ -2107,6 +2192,10 @@ const skills = (vars) => {
 		seam: ["incremental-implementation"],
 		implement: ["test-driven-development", "incremental-implementation"],
 		"implement.fix.suite": ["debugging-and-error-recovery"],
+		"implement.prototype": [],
+		"implement.prototype.fix": ["test-driven-development", "incremental-implementation"],
+		"implement.prototype.fix.suite": ["debugging-and-error-recovery"],
+		"implement.prototype.health": ["debugging-and-error-recovery"],
 		"implement.health": ["debugging-and-error-recovery"],
 		...lensScopes("build.quality", lensesOf(vars.qualityReviews ?? ""), (lens) => builtInLenses[lens]?.skills ?? [lens]),
 		...lensScopes("refactor.build.quality", lensesOf(vars.refactorQualityReviews ?? ""), (lens) => builtInLenses[lens]?.skills ?? [lens])
@@ -2131,4 +2220,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { naiveApplyFailure as $, reviewQuality as A, defaults as At, coverageMessage as B, renderStandards as Bt, collecting as C, uncoveredMessage as Ct, fixRisks as D, walkthroughBlock as Dt, fixQuality as E, unwindFailure as Et, builderSystem as F, conflictFor as Ft, designSystem as G, registryEntry as Gt, coveringPrompt as H, flagMentions as Ht, chunkTexts as I, conflictTitle as It, fixReviewNotesPrompt as J, designTriagePrompt as K, requireFlag as Kt, clearCriteriaMessage as L, isConflictTitle as Lt, agentWithSkills as M, testFileGlobs as Mt, buildReviewCollectingPrompt as N, STANDARDS as Nt, planner as O, withLapFindings as Ot, buildReviewTriageMessage as P, conflictBody as Pt, implementFixPrompt as Q, clearCriteriaQuestion as R, oneLine as Rt, coder as S, titledNotes as St, fixNits as T, unwindFailedMessage as Tt, criterionLine as U, flagReferences as Ut, coverageQuestion as V, standardKey as Vt, designGateAnswerMessage as W, flipProblems as Wt, idleMessage as X, handOffAwaitReviewMessage as Y, implementBuildingPrompt as Z, REQUIREMENTS as _, reviewerSystem as _t, flagModeOn as a, rankedReview as at, answerReviewQuestions as b, slicingPrompt as bt, baseline as c, refactorFixPrompt as ct, healthy as d, reviewEditNotesCapture as dt, naivePassPrompt as et, FEEDBACK as f, reviewEditsCapture as ft, REFACTOR_NOTE as g, reviewRankingMessage as gt, REFACTOR as h, reviewNotesCapture as ht, skills as i, qualityTriageMessage as it, reviewing as j, envDefaults as jt, reviewMissing as k, withWalkthrough as kt, gate as l, refactorNotePrompt as lt, QUALITY as m, reviewGateBlockedMessage as mt, summary as n, oversizedMessage as nt, flagShipped as o, refactorBuildingPrompt as ot, HANDOFF as p, reviewFeedbackFixPrompt as pt, finisherSystem as q, access as r, qualityFindingsFile as rt, shipped as s, refactorDroppedRefusal as st, steering as t, normaliseCriteriaScript as tt, guarded as u, refactorRules as ut, REVIEW as v, seamByHandMessage as vt, fixCheck as w, unranked as wt, awaitReview as x, startGateBlockedMessage as xt, SLICES as y, seamSteerMessage as yt, composedReview as z, parseStandards as zt };
+export { implementFixPrompt as $, reviewMissing as A, unranked as At, composedReview as B, conflictBody as Bt, coder as C, seamByHandMessage as Ct, fixQuality as D, testerSystem as Dt, fixNits as E, startGateBlockedMessage as Et, buildReviewTriageMessage as F, withWalkthrough as Ft, designGateAnswerMessage as G, parseStandards as Gt, coverageQuestion as H, conflictTitle as Ht, builderSystem as I, defaults as It, finisherSystem as J, flagMentions as Jt, designSystem as K, renderStandards as Kt, chunkTexts as L, envDefaults as Lt, reviewing as M, unwindFailure as Mt, agentWithSkills as N, walkthroughBlock as Nt, fixRisks as O, titledNotes as Ot, buildReviewCollectingPrompt as P, withLapFindings as Pt, implementBuildingPrompt as Q, requireFlag as Qt, clearCriteriaMessage as R, testFileGlobs as Rt, awaitReview as S, reviewerSystem as St, fixCheck as T, slicingPrompt as Tt, coveringPrompt as U, isConflictTitle as Ut, coverageMessage as V, conflictFor as Vt, criterionLine as W, oneLine as Wt, handOffAwaitReviewMessage as X, flipProblems as Xt, fixReviewNotesPrompt as Y, flagReferences as Yt, idleMessage as Z, registryEntry as Zt, REFACTOR_NOTE as _, reviewEditsCapture as _t, flagModeOn as a, prototypeOpenMessage as at, SLICES as b, reviewNotesCapture as bt, baseline as c, qualityFindingsFile as ct, healthy as d, refactorBuildingPrompt as dt, naiveApplyFailure as et, FEEDBACK as f, refactorDroppedRefusal as ft, REFACTOR as g, reviewEditNotesCapture as gt, QUALITY as h, refactorRules as ht, skills as i, prototypeFixingPrompt as it, reviewQuality as j, unwindFailedMessage as jt, planner as k, uncoveredMessage as kt, gate as l, qualityTriageMessage as lt, PROTOTYPE as m, refactorNotePrompt as mt, summary as n, normaliseCriteriaScript as nt, flagShipped as o, prototypeTestingPrompt as ot, HANDOFF as p, refactorFixPrompt as pt, designTriagePrompt as q, standardKey as qt, access as r, oversizedMessage as rt, shipped as s, prototypeUnguidedMessage as st, steering as t, naivePassPrompt as tt, guarded as u, rankedReview as ut, REQUIREMENTS as v, reviewFeedbackFixPrompt as vt, collecting as w, seamSteerMessage as wt, answerReviewQuestions as x, reviewRankingMessage as xt, REVIEW as y, reviewGateBlockedMessage as yt, clearCriteriaQuestion as z, STANDARDS as zt };

package/dist/chunks/{review-BChXEl2Y.mjs → review-BaCXlIT2.mjs}

@@ -1,8 +1,8 @@
 import { answered, changesSince, head, judge, numeric, read, refuse, requireRevert, restoreScript, run, showScript, vars, writeScript } from "../flows.mjs";
 import { _ as reviewRisks, m as reviewChunks } from "./steering-DtUVUz9l.mjs";
 import { removedAssertions, review } from "../workflow-kit.mjs";
-import { Bt as renderStandards, C as collecting, D as fixRisks, Dt as walkthroughBlock, Ft as conflictFor, I as chunkTexts, It as conflictTitle, Lt as isConflictTitle, Nt as STANDARDS, P as buildReviewTriageMessage, Pt as conflictBody, Rt as oneLine, St as titledNotes, T as fixNits, Vt as standardKey, at as rankedReview, b as answerReviewQuestions, d as healthy, dt as reviewEditNotesCapture, ft as reviewEditsCapture, gt as reviewRankingMessage, ht as reviewNotesCapture, j as reviewing, k as reviewMissing, kt as withWalkthrough, u as guarded, v as REVIEW, w as fixCheck, wt as unranked, x as awaitReview, z as composedReview, zt as parseStandards } from "./reserved-CdOzKFVX.mjs";
-import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-DRM2eC1z.mjs";
+import { A as reviewMissing, At as unranked, B as composedReview, Bt as conflictBody, E as fixNits, F as buildReviewTriageMessage, Ft as withWalkthrough, Gt as parseStandards, Ht as conflictTitle, Kt as renderStandards, L as chunkTexts, M as reviewing, Nt as walkthroughBlock, O as fixRisks, Ot as titledNotes, S as awaitReview, T as fixCheck, Ut as isConflictTitle, Vt as conflictFor, Wt as oneLine, _t as reviewEditsCapture, bt as reviewNotesCapture, d as healthy, gt as reviewEditNotesCapture, qt as standardKey, u as guarded, ut as rankedReview, w as collecting, x as answerReviewQuestions, xt as reviewRankingMessage, y as REVIEW, zt as STANDARDS } from "./reserved-CUkk9XgL.mjs";
+import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-CX6Pdsql.mjs";
 //#region src/workflows/shared/learn.ts
 const SUMMARY_MAX = 200;
 const BANNER = /^_(?:The fixer left this unresolved\.|A fix turn removed this while renaming another finding — check whether it was fixed\.|No detail given\.)_\s*/;

package/dist/chunks/{tail-DRM2eC1z.mjs → tail-CX6Pdsql.mjs}

@@ -1,6 +1,6 @@
 import { answered, head, judge, mark, numeric, read, refuse, removeScript, run, scope, sectionBodies, showScript, vars, writeScript } from "../flows.mjs";
 import { lensEntriesOf, lensOf, qualityLap, reviewToHandOff } from "../workflow-kit.mjs";
-import { A as reviewQuality, D as fixRisks, E as fixQuality, Ot as withLapFindings, Y as handOffAwaitReviewMessage, d as healthy, it as qualityTriageMessage, j as reviewing, k as reviewMissing, m as QUALITY, rt as qualityFindingsFile, u as guarded, v as REVIEW, w as fixCheck, x as awaitReview } from "./reserved-CdOzKFVX.mjs";
+import { A as reviewMissing, D as fixQuality, M as reviewing, O as fixRisks, Pt as withLapFindings, S as awaitReview, T as fixCheck, X as handOffAwaitReviewMessage, ct as qualityFindingsFile, d as healthy, h as QUALITY, j as reviewQuality, lt as qualityTriageMessage, u as guarded, y as REVIEW } from "./reserved-CUkk9XgL.mjs";
 //#region src/workflows/shared/lenses.ts
 const NO_FINDINGS = {
 	notes: [],

package/dist/gtd.bundle.mjs

@@ -38078,6 +38078,28 @@ const memoryScopeOf = (name) => {
 	const dot = name.lastIndexOf(".");
 	return dot === -1 ? "" : name.slice(0, dot);
 };
+/** Is `name` inside `scope`'s subtree? The root scope `""` holds everything. */
+const inScope = (name, scope) => scope === "" || name === scope || name.startsWith(`${scope}.`);
+/**
+* Where the current unbroken run of rests inside `scope`'s subtree began —
+* a dip into a descendant scope does not break it, a sibling or ancestor
+* does, and so does a fresh `scope()` call of the same scope.
+*/
+const scopeRunStart = (trace, scope) => {
+	let start = -1;
+	for (let k = 0; k < trace.length; k++) {
+		if (!inScope(trace[k].memoryScope, scope)) continue;
+		const previous = trace[k - 1];
+		if (!(previous !== void 0 && inScope(previous.memoryScope, scope) && scopeCallOf(previous, scope) === scopeCallOf(trace[k], scope))) start = k;
+	}
+	return start;
+};
+/** The innermost `scope()` call enclosing `scope` at `step` — a new call is a new conversation. */
+const scopeCallOf = (step, scope) => {
+	let call;
+	for (const entry of step.scopeCalls) if (inScope(scope, entry.prefix)) call = entry.call;
+	return call;
+};
 var Stop = class extends Error {};
 const short = (hash) => hash.slice(0, 7);
 /** One step's changes; content is read only when a flow asks for it. */
@@ -38337,12 +38359,13 @@ const replay = async (input) => {
 			skills: step.skills,
 			access: unfoldedAccess.get(step)
 		};
-		const seen = personas.get(step.memoryScope);
+		const conversation = `${step.memoryScope}#${scopeRunStart(trace, step.memoryScope)}`;
+		const seen = personas.get(conversation);
 		if (seen === void 0) {
-			personas.set(step.memoryScope, identity);
+			personas.set(conversation, identity);
 			return;
 		}
-		return samePersona(seen, identity) ? void 0 : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in memory scope "${step.memoryScope || "root"}" — one scope is one conversation, and a conversation has one identity`;
+		return samePersona(seen, identity) ? void 0 : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in its conversation in memory scope "${step.memoryScope || "root"}" — a conversation has one identity`;
 	};
 	const DIVERGED = "the workflow changed under this process; run `gtd abandon` to start over";
 	const blockerAt = (step) => {
@@ -40110,28 +40133,6 @@ const stepDefOf = (step) => {
 		case "human": return messageDef(common, request, step);
 	}
 };
-/** Is `name` inside `scope`'s subtree? The root scope `""` holds everything. */
-const inScope = (name, scope) => scope === "" || name === scope || name.startsWith(`${scope}.`);
-/**
-* Where the current unbroken run of rests inside `scope`'s subtree began —
-* a dip into a descendant scope does not break it, a sibling or ancestor
-* does, and so does a fresh `scope()` call of the same scope.
-*/
-const scopeRunStart = (trace, scope) => {
-	let start = -1;
-	for (let k = 0; k < trace.length; k++) {
-		if (!inScope(trace[k].memoryScope, scope)) continue;
-		const previous = trace[k - 1];
-		if (!(previous !== void 0 && inScope(previous.memoryScope, scope) && scopeCallOf(previous, scope) === scopeCallOf(trace[k], scope))) start = k;
-	}
-	return start;
-};
-/** The innermost `scope()` call enclosing `scope` at `step` — a new call is a new conversation. */
-const scopeCallOf = (step, scope) => {
-	let call;
-	for (const entry of step.scopeCalls) if (inScope(scope, entry.prefix)) call = entry.call;
-	return call;
-};
 const ROOT_MEMORY_SCOPE_NAME = "root";
 /**
 * An agent rest's memory key, `<scope>#<hash7>`: the hash is the commit the

package/dist/testkit.mjs

@@ -7124,6 +7124,28 @@ const memoryScopeOf = (name) => {
 	const dot = name.lastIndexOf(".");
 	return dot === -1 ? "" : name.slice(0, dot);
 };
+/** Is `name` inside `scope`'s subtree? The root scope `""` holds everything. */
+const inScope = (name, scope) => scope === "" || name === scope || name.startsWith(`${scope}.`);
+/**
+* Where the current unbroken run of rests inside `scope`'s subtree began —
+* a dip into a descendant scope does not break it, a sibling or ancestor
+* does, and so does a fresh `scope()` call of the same scope.
+*/
+const scopeRunStart = (trace, scope) => {
+	let start = -1;
+	for (let k = 0; k < trace.length; k++) {
+		if (!inScope(trace[k].memoryScope, scope)) continue;
+		const previous = trace[k - 1];
+		if (!(previous !== void 0 && inScope(previous.memoryScope, scope) && scopeCallOf(previous, scope) === scopeCallOf(trace[k], scope))) start = k;
+	}
+	return start;
+};
+/** The innermost `scope()` call enclosing `scope` at `step` — a new call is a new conversation. */
+const scopeCallOf = (step, scope) => {
+	let call;
+	for (const entry of step.scopeCalls) if (inScope(scope, entry.prefix)) call = entry.call;
+	return call;
+};
 var Stop = class extends Error {};
 const short = (hash) => hash.slice(0, 7);
 /** One step's changes; content is read only when a flow asks for it. */
@@ -7383,12 +7405,13 @@ const replay = async (input) => {
 			skills: step.skills,
 			access: unfoldedAccess.get(step)
 		};
-		const seen = personas.get(step.memoryScope);
+		const conversation = `${step.memoryScope}#${scopeRunStart(trace, step.memoryScope)}`;
+		const seen = personas.get(conversation);
 		if (seen === void 0) {
-			personas.set(step.memoryScope, identity);
+			personas.set(conversation, identity);
 			return;
 		}
-		return samePersona(seen, identity) ? void 0 : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in memory scope "${step.memoryScope || "root"}" — one scope is one conversation, and a conversation has one identity`;
+		return samePersona(seen, identity) ? void 0 : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in its conversation in memory scope "${step.memoryScope || "root"}" — a conversation has one identity`;
 	};
 	const DIVERGED = "the workflow changed under this process; run `gtd abandon` to start over";
 	const blockerAt = (step) => {
@@ -9145,28 +9168,6 @@ const stepDefOf = (step) => {
 		case "human": return messageDef(common, request, step);
 	}
 };
-/** Is `name` inside `scope`'s subtree? The root scope `""` holds everything. */
-const inScope = (name, scope) => scope === "" || name === scope || name.startsWith(`${scope}.`);
-/**
-* Where the current unbroken run of rests inside `scope`'s subtree began —
-* a dip into a descendant scope does not break it, a sibling or ancestor
-* does, and so does a fresh `scope()` call of the same scope.
-*/
-const scopeRunStart = (trace, scope) => {
-	let start = -1;
-	for (let k = 0; k < trace.length; k++) {
-		if (!inScope(trace[k].memoryScope, scope)) continue;
-		const previous = trace[k - 1];
-		if (!(previous !== void 0 && inScope(previous.memoryScope, scope) && scopeCallOf(previous, scope) === scopeCallOf(trace[k], scope))) start = k;
-	}
-	return start;
-};
-/** The innermost `scope()` call enclosing `scope` at `step` — a new call is a new conversation. */
-const scopeCallOf = (step, scope) => {
-	let call;
-	for (const entry of step.scopeCalls) if (inScope(scope, entry.prefix)) call = entry.call;
-	return call;
-};
 const ROOT_MEMORY_SCOPE_NAME = "root";
 /**
 * An agent rest's memory key, `<scope>#<hash7>`: the hash is the commit the

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { At as defaults, Gt as registryEntry, Kt as requireFlag, S as coder, Ut as flagReferences, i as skills, jt as envDefaults, n as summary, o as flagShipped, r as access, t as steering } from "../chunks/reserved-CdOzKFVX.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-DRM2eC1z.mjs";
+import { C as coder, It as defaults, Lt as envDefaults, Qt as requireFlag, Yt as flagReferences, Zt as registryEntry, i as skills, n as summary, o as flagShipped, r as access, t as steering } from "../chunks/reserved-CUkk9XgL.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-CX6Pdsql.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 () => {