@pmelab/gtd 30.0.0 → 31.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "30.0.0",
+  "version": "31.0.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

@@ -418,18 +418,24 @@ noted in steps 3 and 4 below.
    with `- A: <reply>` and the process stops at the same gate again. Close a
    thread by replying with a conclusion or deleting it. While a thread's last
    entry is the agent's, moving on is refused. Leave the file untouched and
-   start the loop to accept the plan as-is, unanswered questions and all.
+   start the loop to accept the plan as-is, unanswered questions and all. The
+   file lists numbered acceptance criteria (`AC-1`, `AC-2`, …) that bind the
+   build. Sketch your own under an `Acceptance criteria` heading and, when a
+   judge finds every one clear and checkable, they are recorded as they are and
+   this moment is skipped; one vague criterion brings it back. See
+   [Acceptance criteria](docs/configuration.md#acceptance-criteria).
 
 3. **You wait.** The agent first implements the requirements the quickest way
    that works — the naive pass — and a judge reads where it changed code (see
-   [the naive pass](#the-naive-pass) below). Then the change is built
-   test-first, checked against the full suite (`testCommand`) and fixed until it
-   passes — so keep that suite fast; gtd has no lighter one. Scenario wording is
-   not frozen: you sign the scenarios off once, in the review's `## Scenarios`
-   chunk, where any assertion an existing scenario lost is marked `Weakened:`.
-   After the build the quality lap runs. Three points along the process are
-   judged rather than always asking you outright — each stops and hands you a
-   verdict to make (`gtd judge answer`, or land with a clean tree to accept the
+   [the naive pass](#the-naive-pass) below; with [flag mode](#the-naive-pass)
+   off, neither runs). Then the change is built test-first, checked against the
+   full suite (`testCommand`) and fixed until it passes — so keep that suite
+   fast; gtd has no lighter one. Scenario wording is not frozen: you sign the
+   scenarios off once, in the review's `## Scenarios` chunk, where any assertion
+   an existing scenario lost is marked `Weakened:`. After the build the quality
+   lap runs. Three points along the process (two with flag mode off) are judged
+   rather than always asking you outright — each stops and hands you a verdict
+   to make (`gtd judge answer`, or land with a clean tree to accept the
    conservative default, which never skips work;
    `gtd judge run --provider fixed --answers <path>` — or the
    `GTD_JUDGE_ANSWERS` env var, inline JSON — answers one from a file, piped
@@ -595,6 +601,14 @@ out is `gtd abandon`. A process from 27.5.0 or later whose judge ruled
 that slice. Details in
 [the naive-pass path](docs/configuration.md#the-naive-pass-path).
 
+**Flag mode (`flagMode`, on by default).** On, the implementation is asked for a
+new release flag (none at a `low` risk tier) and the naive pass and its judge
+run as above. A project that is not publicly released turns it off explicitly —
+`feature({ flagMode: false })` in `gtd.config.ts`, it is never detected: then no
+flag is asked for, no seam judge or refactor runs, and the implementation is the
+naive version, straight through the health loop and the quality lap. See
+[`flagMode`](docs/configuration.md#the-bundled-workflows-settings).
+
 **Risk tier (flag `GTD_FLAG_RISK_TIER=1`, off by default).** Triage proposes a
 risk tier, `low` or `high`, and the production signals to watch after merge.
 Edit the first word under `## Risk Tier` at the design gate to change it; a

package/claude/hooks/register.tsx

@@ -993,6 +993,11 @@ export const register: Register = (on) => {
     return next(e)
   })
 
+  // A worker's tool call hands settings hooks the MAIN session's
+  // `transcript_path`, marked only by `agent_id`/`agent_type`; its own
+  // transcript (`agent_transcript_path`) is named only at SubagentStop, too
+  // late to measure a running worker's context.
+  //
   // The loop lands a turn when it ends; work left running in the background
   // would still be writing the tree gtd is committing.
   on("tool.call", async ($, e, next) => {

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

@@ -1,6 +1,6 @@
 import { accessFor, agent, answered, changesSince, check, codeThreads, defineWorkflow, displayPath, env, head, human, judge, numeric, quote, read, refuse, scope, skillsFor, start, vars } from "../flows.mjs";
 import { escalation as escalation$1, gate as gate$1, healthy as healthy$1, lensScopes, lensesOf, removedAssertions } from "../workflow-kit.mjs";
-import { c as String$, g as standardSchemaV1, h as optionalWith, l as Struct } from "./Schema-DO5ttJaI.mjs";
+import { c as String$, g as standardSchemaV1, h as optionalWith, l as Struct, n as Boolean$ } from "./Schema-DO5ttJaI.mjs";
 //#region src/workflows/shared/registry.ts
 const FILL = "
";
 const commentLength = (rest) => {
@@ -132,6 +132,7 @@ const defaults = {
 	reviewSeverityMinP: "0.7",
 	refactorFlagPattern: "\\bGTD_FLAG_\\w+",
 	seamAllow: [...testFileGlobs, ".gtd/**"].join(", "),
+	flagMode: "true",
 	flag_risk_tier: "0",
 	qualityReviews: "correctness, owasp-security, ponytail-review, test-audit, conventions, spec-challenge",
 	refactorQualityReviews: "correctness, ponytail-review, conventions"
@@ -438,6 +439,21 @@ const codeThreadReplies = () => {
   concluded thread in and delete its lines:
 ${waiting.map((t) => `  - ${t.path}:${t.line}: ${t.first}`).join("\n")}`;
 };
+const acceptanceCriteriaBlock = `
+## Acceptance criteria
+
+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:
+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
+last settled one from history (\`git log -p -- .gtd/REQUIREMENTS.md\`)
+and carry its IDs over. Landing is refused while a criterion has no ID or
+two share one.
+`;
 const riskTierBlock = `
 ## Risk tier and production signals
 
@@ -481,7 +497,7 @@ ${footnoteFoldIn}${codeThreadReplies()}
   or both
 - Whichever lap this is, leave \`.gtd/REQUIREMENTS.md\`
   uncommitted and finish once it reflects this lap's own work
-
+${acceptanceCriteriaBlock}
 ## First lap
 
 \`.gtd/REQUIREMENTS.md\` does not exist yet (or holds whatever the
@@ -536,6 +552,34 @@ ${questionBarReturn}
   made). If red, make that breakage the first concern, ahead of
   everything else — the build assumes the suite started green
 ${riskTier ? riskTierBlock : ""}`;
+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."
+};
+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
+they are recorded as they are — or land without a verdict to run the
+ordinary design conversation.
+`;
+const criterionLine = (c) => `- ${c.id}: ${c.text.replace(/\s+/g, " ")}`;
+/** Writes \`.gtd/REQUIREMENTS.md\` from criteria the sketch stated, wrapped the way oxfmt writes it. */
+const normaliseCriteriaScript = (stated) => {
+	return `mkdir -p .gtd
+printf '%s\\n' ${[
+		"# Requirements",
+		"",
+		`Stated in \`${stated.path}\` by the sketch:`,
+		"",
+		`\`git show ${stated.commit}:${stated.path}\``,
+		"",
+		"## Acceptance Criteria",
+		"",
+		...stated.criteria.flatMap((c) => wrapItem(criterionLine(c)))
+	].map(quote).join(" ")} > ${quote(".gtd/REQUIREMENTS.md")}
+`;
+};
 const designSystem = () => `${designPersona}
 
 ${agentConduct}`;
@@ -860,7 +904,8 @@ What each change does next (then run \`gtd land\`):
 const wrapItem = (item) => {
 	const out = [];
 	let line = "";
-	for (const word of item.split(" ")) if (line !== "" && line.length + 1 + word.length > 80) {
+	const words = item.split(" ").reduce((acc, word) => acc.length > 0 && /^([-+*>#]|\d+[.)])$/.test(word) ? [...acc.slice(0, -1), `${acc.at(-1)} ${word}`] : [...acc, word], []);
+	for (const word of words) if (line !== "" && line.length + 1 + word.length > 80) {
 		out.push(line);
 		line = `  ${word}`;
 	} else line = line === "" ? word : `${line} ${word}`;
@@ -1158,8 +1203,12 @@ 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 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}
 - 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
@@ -1172,18 +1221,21 @@ re-implement. It changed these files outside the expected set:
 ${listed(rejection.strays)}
 Start over and choose a different approach; do not rebuild the same diff.
 `}`;
-const implementBuildingPrompt = (reference, tier, amend, afterRefactor) => `${stateFileRules}
+const implementBuildingPrompt = (reference, tier, amend, afterRefactor, flagMode = true) => `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
+${criteriaBinding(true)}
 ${afterRefactor === true ? `- A reviewed refactor has just landed and may already carry part of the change,
   though never a release flag. Build only what is still missing, held to every
   rule below; if nothing is, change nothing and finish your turn
 ` : ""}${amend === true ? `- The change already exists in the tree from an earlier lap; amend it to meet
   the re-derived requirements instead of rewriting it
-` : `- Implement them properly, fitting the codebase's seams and conventions
+` : flagMode ? `- Implement them properly, fitting the codebase's seams and conventions
+` : `- Implement them the quickest way that works — the naive version. Do not
+  restructure, abstract or refactor around the change
 `}${reference === void 0 || amend === true ? "" : `- Reference only: \`git show ${reference}\` shows an earlier naive attempt.
   Read it for ideas; never apply, cherry-pick or check it out — write
   the change fresh
-`}${tier === "low" ? "- Add no release flag — this change is low risk tier" : amend === true ? "- Keep the release flag the earlier lap added, if it added one; otherwise put\n  the behaviour behind a new release flag" : `- Put the new behaviour behind a new release flag, following the
+`}${!flagMode ? "- Add no release flag — this project ships without release flags" : tier === "low" ? "- Add no release flag — this change is low risk tier" : amend === true ? "- Keep the release flag the earlier lap added, if it added one; otherwise put\n  the behaviour behind a new release flag" : `- Put the new behaviour behind a new release flag, following the
   repository's flag conventions`}
 - Write the tests first, then the code that makes them pass
 - Leave \`.gtd/REQUIREMENTS.md\` in place and everything uncommitted, then
@@ -1420,12 +1472,19 @@ const ShippedOptions = Struct({
 	refactorQualityReviews: setting,
 	testCommand: setting,
 	plannerModel: setting,
-	coderModel: setting
+	coderModel: setting,
+	flagMode: optionalWith(Boolean$, { exact: true })
 });
 const over = (base, options) => ({
 	...base,
-	...Object.fromEntries(Object.entries(options).filter(([name]) => Object.hasOwn(base, name)))
+	...Object.fromEntries(Object.entries(options).filter(([name]) => Object.hasOwn(base, name)).map(([name, value]) => [name, String(value)]))
 });
+/** The `flagMode` setting, pinned at process start. Anything but true/false fails rather than guess a side. */
+const flagModeOn = () => {
+	const value = vars.flagMode ?? defaults.flagMode;
+	if (value !== "true" && value !== "false") refuse(`gtd: flagMode must be "true" or "false", got ${JSON.stringify(value)}`);
+	return value === "true";
+};
 /** A shipped flow as a factory: its options override the settings it declares, each in its own kind. */
 const shipped = (flow, doors, base) => defineWorkflow(standardSchemaV1(ShippedOptions, {
 	onExcessProperty: "error",
@@ -1509,4 +1568,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { seamByHandMessage as $, buildReviewFixNitsPrompt as A, idleMessage as B, reviewMissing as C, buildReviewAnswerQuestionsPrompt as D, agentWithSkills as E, designSystem as F, refactorDroppedRefusal as G, implementFixPrompt as H, designTriagePrompt as I, reviewEditNotesCapture as J, refactorFixPrompt as K, finisherSystem as L, builderSystem as M, deferNotesScript as N, buildReviewAwaitAfterDeferMessage as O, designGateAnswerMessage as P, reviewerSystem as Q, fixReviewNotesPrompt as R, planner as S, reviewing as T, naivePassPrompt as U, implementBuildingPrompt as V, refactorBuildingPrompt as W, reviewGateBlockedMessage as X, reviewEditsCapture as Y, reviewNotesCapture as Z, awaitReview as _, flagShipped as a, envDefaults as at, fixQuality as b, escalation as c, flagReferences as ct, healthy as d, requireFlag as dt, seamSteerMessage as et, FEEDBACK as f, REVIEW as g, REQUIREMENTS as h, skills as i, defaults as it, buildReviewTriageMessage as j, buildReviewCollectingPrompt as k, gate as l, flipProblems as lt, REFACTOR as m, summary as n, unwindFailedMessage as nt, shipped as o, testFileGlobs as ot, QUALITY as p, refactorRules as q, access as r, unwindFailure as rt, baseline as s, flagMentions as st, steering as t, startGateBlockedMessage as tt, guarded as u, registryEntry as ut, coder as v, reviewQuality as w, fixRisks as x, fixCheck as y, handOffAwaitReviewMessage as z };
+export { reviewEditNotesCapture as $, buildReviewCollectingPrompt as A, designTriagePrompt as B, planner as C, agentWithSkills as D, reviewing as E, clearCriteriaQuestion as F, implementBuildingPrompt as G, fixReviewNotesPrompt as H, criterionLine as I, normaliseCriteriaScript as J, implementFixPrompt as K, deferNotesScript as L, buildReviewTriageMessage as M, builderSystem as N, buildReviewAnswerQuestionsPrompt as O, clearCriteriaMessage as P, refactorRules as Q, designGateAnswerMessage as R, fixRisks as S, reviewQuality as T, handOffAwaitReviewMessage as U, finisherSystem as V, idleMessage as W, refactorDroppedRefusal as X, refactorBuildingPrompt as Y, refactorFixPrompt as Z, REVIEW as _, flagModeOn as a, seamSteerMessage as at, fixCheck as b, baseline as c, unwindFailure as ct, guarded as d, testFileGlobs as dt, reviewEditsCapture as et, healthy as f, flagMentions as ft, REQUIREMENTS as g, requireFlag as gt, REFACTOR as h, registryEntry as ht, skills as i, seamByHandMessage as it, buildReviewFixNitsPrompt as j, buildReviewAwaitAfterDeferMessage as k, escalation as l, defaults as lt, QUALITY as m, flipProblems as mt, summary as n, reviewNotesCapture as nt, flagShipped as o, startGateBlockedMessage as ot, FEEDBACK as p, flagReferences as pt, naivePassPrompt as q, access as r, reviewerSystem as rt, shipped as s, unwindFailedMessage as st, steering as t, reviewGateBlockedMessage as tt, gate as u, envDefaults as ut, awaitReview as v, reviewMissing as w, fixQuality as x, coder as y, designSystem as z };

package/dist/chunks/{tail-DA2UuJNP.mjs → tail-CCsDBbZe.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 { C as reviewMissing, T as reviewing, _ as awaitReview, b as fixQuality, c as escalation, d as healthy, g as REVIEW, p as QUALITY, u as guarded, w as reviewQuality, x as fixRisks, y as fixCheck, z as handOffAwaitReviewMessage } from "./reserved-iG86IR3I.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";
 //#region src/workflows/shared/tail.ts
 /** The reviewer's own `.gtd/REVIEW.md`, kept beside the human's notes so `fix` can tell them apart. */
 const REVIEW_ORIG = ".gtd/REVIEW.orig.md";

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { a as flagShipped, at as envDefaults, ct as flagReferences, dt as requireFlag, i as skills, it as defaults, n as summary, r as access, t as steering, ut as registryEntry, v as coder } from "../chunks/reserved-iG86IR3I.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-DA2UuJNP.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";
 //#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 seamByHandMessage, A as buildReviewFixNitsPrompt, B as idleMessage, C as reviewMissing, D as buildReviewAnswerQuestionsPrompt, E as agentWithSkills, F as designSystem, G as refactorDroppedRefusal, H as implementFixPrompt, I as designTriagePrompt, J as reviewEditNotesCapture, K as refactorFixPrompt, M as builderSystem, N as deferNotesScript, O as buildReviewAwaitAfterDeferMessage, P as designGateAnswerMessage, Q as reviewerSystem, S as planner, T as reviewing, U as naivePassPrompt, V as implementBuildingPrompt, W as refactorBuildingPrompt, Y as reviewEditsCapture, Z as reviewNotesCapture, _ as awaitReview, at as envDefaults, d as healthy, et as seamSteerMessage, f as FEEDBACK, g as REVIEW, h as REQUIREMENTS, i as skills, it as defaults, j as buildReviewTriageMessage, k as buildReviewCollectingPrompt, l as gate, m as REFACTOR, n as summary, nt as unwindFailedMessage, o as shipped, ot as testFileGlobs, q as refactorRules, r as access, rt as unwindFailure, t as steering, tt as startGateBlockedMessage, u as guarded, v as coder, x as fixRisks, y as fixCheck } from "../chunks/reserved-iG86IR3I.mjs";
-import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-DA2UuJNP.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";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {
 	let fence;
@@ -17,6 +17,128 @@ const markFenced = (text) => {
 	});
 };
 //#endregion
+//#region src/workflows/feature/criteria.ts
+/** Below this the judge's `yes` is not trusted: a wrong skip builds against criteria nobody can check. */
+const CLEAR_MIN_P = .8;
+const HEADING = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
+const ITEM = /^ ?(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?(.*)$/;
+const ID = /^(AC-\d+):\s*(.*)$/;
+/** The list items under the first heading `title` matches (at `level` when given), up to the next heading; wrapped lines joined, fenced lines ignored. */
+const listUnder = (text, title, level) => {
+	const lines = markFenced(text);
+	const at = lines.findIndex((l) => {
+		const heading = l.fenced ? null : HEADING.exec(l.line);
+		return heading !== null && (level === void 0 || heading[1].length === level) && title.test(heading[2]);
+	});
+	if (at === -1) return void 0;
+	const items = [];
+	let open = false;
+	for (const { line, fenced } of lines.slice(at + 1)) {
+		if (fenced) {
+			open = false;
+			continue;
+		}
+		if (HEADING.test(line)) break;
+		const item = ITEM.exec(line);
+		if (item !== null) {
+			items.push(item[1].trim());
+			open = true;
+		} else if (open && line.trim() !== "") items[items.length - 1] = `${items.at(-1)} ${line.trim()}`.trim();
+		else open = false;
+	}
+	return items;
+};
+/** The `- AC-<n>: …` list of `## Acceptance Criteria`, or `undefined` when the section is missing. */
+const criteriaOf = (text) => listUnder(text, /^acceptance criteria$/i, 2)?.map((item) => {
+	const id = ID.exec(item);
+	return id === null ? {
+		id: "",
+		text: item
+	} : {
+		id: id[1],
+		text: id[2]
+	};
+});
+/** Items numbered `AC-1`…, unless every one already carries its own distinct ID. */
+const numbered = (items) => {
+	const ids = items.map((item) => ID.exec(item));
+	const own = ids.every((id) => id !== null) && new Set(ids.map((id) => id[1])).size === ids.length;
+	return items.map((item, i) => own ? {
+		id: ids[i][1],
+		text: ids[i][2]
+	} : {
+		id: `AC-${i + 1}`,
+		text: item.replace(ID, "$2")
+	});
+};
+const STATED = /^acceptance criteria:?$/i;
+const statedItems = (text) => text === void 0 ? [] : (listUnder(text, STATED) ?? []).filter((item) => item !== "");
+/**
+* The criteria a `TODO.md` in the sketch `sketch` (the idle turn's changes)
+* added or changed under an `Acceptance criteria` heading. More than one such
+* file is ambiguous, and any other change in the sketch is input only triage
+* folds in, so none.
+*/
+const statedCriteria = (sketch, commit) => {
+	const found = sketch.flatMap((change) => {
+		if (!/(^|\/)TODO\.md$/.test(change.path) || change.after === void 0) return [];
+		const items = statedItems(change.after);
+		if (items.length === 0 || items.join("\n") === statedItems(change.before).join("\n")) return [];
+		return [{
+			path: change.path,
+			commit,
+			text: change.after,
+			criteria: numbered(items)
+		}];
+	});
+	return found.length === 1 && sketch.length === 1 ? found[0] : void 0;
+};
+const listing = (criteria) => criteria.map(criterionLine).join("\n");
+/** Refuse a turn that leaves `file` without ID'd acceptance criteria. A deleted file is `requireProgress`'s call. */
+const requireCriteria = (file) => {
+	const text = read(file);
+	if (text === void 0) return;
+	const criteria = criteriaOf(text) ?? [];
+	const unnamed = criteria.filter((c) => c.id === "");
+	const ids = criteria.map((c) => c.id).filter((id) => id !== "");
+	const twice = ids.filter((id, i) => ids.indexOf(id) !== i);
+	if (criteria.length > 0 && unnamed.length === 0 && twice.length === 0) return;
+	refuse(`gtd land: acceptance-criteria: ${file} has ${criteria.length === 0 ? `no "## Acceptance Criteria" list` : unnamed.length > 0 ? `${unnamed.length} criterion without an ID:\n${unnamed.map((c) => `  - ${c.text}`).join("\n")}` : `duplicate IDs: ${[...new Set(twice)].join(", ")}`} — list every criterion under "## Acceptance Criteria" as "- AC-<n>: <checkable criterion>", each ID unique and never reused`);
+};
+/** Refuse a turn that changed the acceptance criteria in `file`: after the design gate only another design lap may. */
+const requireCriteriaFrozen = (file) => {
+	const change = changes().get(file);
+	if (change === void 0) return;
+	if (listing(criteriaOf(change.before ?? "") ?? []) === listing(criteriaOf(change.after ?? "") ?? [])) return;
+	refuse(`gtd land: criteria-frozen: the acceptance criteria in ${file} are settled — restore them; only a design lap changes them`);
+};
+/** Whether the judge trusts `stated` as clear and checkable, every criterion of it. Truncated evidence never is. */
+const clear = async (stated) => {
+	const { answers, truncated } = await judge("clear", {
+		questions: [clearCriteriaQuestion],
+		evidence: {
+			criteria: listing(stated.criteria),
+			sketch: stated.text
+		},
+		message: clearCriteriaMessage(),
+		label: "Judging the stated acceptance criteria"
+	});
+	return truncated.length === 0 && answered(answers.clear, "yes", CLEAR_MIN_P);
+};
+/**
+* The skip path: when the sketch stated clear, checkable criteria, write them
+* to `.gtd/REQUIREMENTS.md` as they are and resolve `true` — no triage, no
+* design gate. `false` when design must run.
+*/
+const skipDesign = (stated) => stated === void 0 ? Promise.resolve(false) : scope("design", async () => {
+	if (!await clear(stated)) return false;
+	await run("normalise", normaliseCriteriaScript(stated), {
+		label: "Recording the stated acceptance criteria",
+		file: REQUIREMENTS
+	});
+	return true;
+});
+//#endregion
 //#region src/workflows/feature/tier.ts
 /** GTD_FLAG_RISK_TIER: pinned at process start, so a mid-process flip never moves a process. */
 const riskTierOn = () => vars.flag_risk_tier === "1";
@@ -137,6 +259,7 @@ const design = (base) => scope("design", async () => {
 		await triage(base);
 		requireProgress(REQUIREMENTS);
 		requireReplies(REQUIREMENTS);
+		requireCriteria(REQUIREMENTS);
 	} while (await noteGate(REQUIREMENTS, answerProductQuestions));
 });
 //#endregion
@@ -625,18 +748,22 @@ function implement(first, tier, amend) {
 		amend
 	};
 	return scope("implement", async () => {
-		await agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend, options.afterRefactor), {
+		await agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend, options.afterRefactor, flagModeOn()), {
 			label: "Implementing",
 			model: coder(),
 			system: builderSystem(),
 			...options.afterRefactor === true ? { allowEmpty: true } : {}
 		});
+		requireCriteriaFrozen(REQUIREMENTS);
 		await healthy(() => agentWithSkills("fix.suite.fixing", implementFixPrompt(), {
 			label: "Fixing the check",
 			file: FEEDBACK,
 			model: coder(),
 			system: builderSystem()
-		}));
+		}), {
+			guard: () => requireCriteriaFrozen(REQUIREMENTS),
+			guardRests: false
+		});
 		await run("closing", removeScript([REQUIREMENTS]), { label: "Closing out the implementation" });
 	});
 }
@@ -667,6 +794,7 @@ const decide = () => scope("seam", async () => {
 			acceptClean: true
 		});
 		if (changes().length === 0) return { reference: tip.hash };
+		requireCriteria(REQUIREMENTS);
 		rejection = void 0;
 		retries = 0;
 	}
@@ -706,10 +834,10 @@ const unwind = () => {
 	const commit = head();
 	return run("unwind", revertScript(commit, FEEDBACK, unwindFailure(commit)), { label: "Unwinding your input" });
 };
-/** A judged naive pass, then implement and review until a review round signs off; design must have run since `firstBase`. */
+/** A judged naive pass (none with `flagMode` off), then implement and review until a review round signs off; design must have run since `firstBase`. */
 const buildFeature = async (firstBase) => {
 	const tier = riskTierOn() ? recordRisk() : void 0;
-	const seam = await seamBuild(firstBase);
+	const seam = flagModeOn() ? await seamBuild(firstBase) : { base: firstBase };
 	await slice("feature", async () => {
 		await implement({
 			reference: seam.reference,
@@ -723,9 +851,9 @@ const buildFeature = async (firstBase) => {
 		}), base);
 	});
 };
-/** Design, then `buildFeature`. */
-const planAndBuild = async (firstBase) => {
-	await design(firstBase);
+/** Design — skipped when the sketch's own criteria are judged clear — then `buildFeature`. */
+const planAndBuild = async (firstBase, stated) => {
+	if (!await skipDesign(riskTierOn() ? void 0 : stated)) await design(firstBase);
 	await buildFeature(firstBase);
 };
 const featureFeedback = async (first, lensBase) => {
@@ -754,6 +882,8 @@ const ordinaryStart = async () => {
 		file: ".gtd/TODO.md"
 	});
 	refusePendingHandOff();
+	flagModeOn();
+	const stated = statedCriteria(changes(), head());
 	await unwind();
 	if (changes(".gtd/FEEDBACK.md").some((c) => c.status !== "deleted")) await human("unwind-failed", {
 		message: unwindFailedMessage(),
@@ -761,11 +891,11 @@ const ordinaryStart = async () => {
 		file: FEEDBACK
 	});
 	await gate("start-gate", startGateBlockedMessage());
-	await planAndBuild(start());
+	await planAndBuild(start(), stated);
 };
 const feature = shipped(ordinaryStart);
 //#endregion
 //#region src/workflows/feature/index.ts
 var feature_default = feature;
 //#endregion
-export { REFACTOR_PACKAGE, access, afterTail, answerProductQuestions, answerReviewQuestions, buildFeature, buildTail, collecting, feature_default as default, defaults, deferNotes, design, envDefaults, feature, fixNits, implement, judgeSeam, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorStrays, requireNoNewFlags, requireNoTestFiles, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, steering, summary, triage, unwind };
+export { REFACTOR_PACKAGE, access, afterTail, answerProductQuestions, answerReviewQuestions, buildFeature, buildTail, collecting, criteriaOf, feature_default as default, defaults, deferNotes, design, envDefaults, feature, fixNits, implement, judgeSeam, naivePass, ordinaryStart, planAndBuild, reUnwind, refactorCollecting, refactorFirst, refactorStrays, requireCriteria, requireCriteriaFrozen, requireNoNewFlags, requireNoTestFiles, requireTestCallSitesOnly, requireWithin, reviewedRefactor, seamBuild, skills, skipDesign, statedCriteria, steering, summary, triage, unwind };

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 { E as agentWithSkills, L as finisherSystem, R as fixReviewNotesPrompt, at as envDefaults, g as REVIEW, i as skills, it as defaults, n as summary, o as shipped, r as access, s as baseline, t as steering, v as coder } from "../chunks/reserved-iG86IR3I.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-DA2UuJNP.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";
 //#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 { X as reviewGateBlockedMessage, at as envDefaults, i as skills, it as defaults, l as gate, n as summary, o as shipped, r as access, t as steering } from "../chunks/reserved-iG86IR3I.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-DA2UuJNP.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";
 //#region src/workflows/review/review.ts
 /**
 * Pure review of everything since `reviewBase`: a green gate, the quality

package/dist/workflows/rollout.mjs

@@ -1,5 +1,5 @@
 import { agent, changesSince, glob, head, mark, read, refuse, removeScript, run, scope, vars } from "../flows.mjs";
-import { a as flagShipped, at as envDefaults, dt as requireFlag, f as FEEDBACK, i as skills, it as defaults, l as gate, lt as flipProblems, n as summary, r as access, st as flagMentions, t as steering, v as coder } from "../chunks/reserved-iG86IR3I.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";
 //#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.";