@pmelab/gtd 30.0.0 → 30.1.0

package/.claude-plugin/plugin.json

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

@@ -422,14 +422,15 @@ noted in steps 3 and 4 below.
 
 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 +596,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-DDiiAZ8U.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"
@@ -1172,18 +1173,20 @@ 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
 ${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 +1423,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 +1519,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 { reviewerSystem as $, buildReviewCollectingPrompt as A, handOffAwaitReviewMessage as B, planner as C, agentWithSkills as D, reviewing as E, designGateAnswerMessage as F, refactorBuildingPrompt as G, implementBuildingPrompt as H, designSystem as I, refactorRules as J, refactorDroppedRefusal as K, designTriagePrompt as L, buildReviewTriageMessage as M, builderSystem as N, buildReviewAnswerQuestionsPrompt as O, deferNotesScript as P, reviewNotesCapture as Q, finisherSystem as R, fixRisks as S, reviewQuality as T, implementFixPrompt as U, idleMessage as V, naivePassPrompt as W, reviewEditsCapture as X, reviewEditNotesCapture as Y, reviewGateBlockedMessage as Z, REVIEW as _, flagModeOn as a, defaults as at, fixCheck as b, baseline as c, flagMentions as ct, guarded as d, registryEntry as dt, seamByHandMessage as et, healthy as f, requireFlag as ft, REQUIREMENTS as g, REFACTOR as h, skills as i, unwindFailure as it, buildReviewFixNitsPrompt as j, buildReviewAwaitAfterDeferMessage as k, escalation as l, flagReferences as lt, QUALITY as m, summary as n, startGateBlockedMessage as nt, flagShipped as o, envDefaults as ot, FEEDBACK as p, refactorFixPrompt as q, access as r, unwindFailedMessage as rt, shipped as s, testFileGlobs as st, steering as t, seamSteerMessage as tt, gate as u, flipProblems as ut, awaitReview as v, reviewMissing as w, fixQuality as x, coder as y, fixReviewNotesPrompt as z };

package/dist/chunks/{tail-DA2UuJNP.mjs → tail-ILPlELuy.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 { B as handOffAwaitReviewMessage, E as reviewing, S as fixRisks, T as reviewQuality, _ 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-DDiiAZ8U.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 { at as defaults, dt as registryEntry, ft as requireFlag, i as skills, lt as flagReferences, n as summary, o as flagShipped, ot as envDefaults, r as access, t as steering, y as coder } from "../chunks/reserved-DDiiAZ8U.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-ILPlELuy.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 reviewerSystem, A as buildReviewCollectingPrompt, C as planner, D as agentWithSkills, E as reviewing, F as designGateAnswerMessage, G as refactorBuildingPrompt, H as implementBuildingPrompt, I as designSystem, J as refactorRules, K as refactorDroppedRefusal, L as designTriagePrompt, M as buildReviewTriageMessage, N as builderSystem, O as buildReviewAnswerQuestionsPrompt, P as deferNotesScript, Q as reviewNotesCapture, S as fixRisks, U as implementFixPrompt, V as idleMessage, W as naivePassPrompt, X as reviewEditsCapture, Y as reviewEditNotesCapture, _ as REVIEW, a as flagModeOn, at as defaults, b as fixCheck, d as guarded, et as seamByHandMessage, f as healthy, g as REQUIREMENTS, h as REFACTOR, i as skills, it as unwindFailure, j as buildReviewFixNitsPrompt, k as buildReviewAwaitAfterDeferMessage, n as summary, nt as startGateBlockedMessage, ot as envDefaults, p as FEEDBACK, q as refactorFixPrompt, r as access, rt as unwindFailedMessage, s as shipped, st as testFileGlobs, t as steering, tt as seamSteerMessage, u as gate, v as awaitReview, w as reviewMissing, y as coder } from "../chunks/reserved-DDiiAZ8U.mjs";
+import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-ILPlELuy.mjs";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {
 	let fence;
@@ -625,7 +625,7 @@ 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(),
@@ -706,10 +706,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,
@@ -754,6 +754,7 @@ const ordinaryStart = async () => {
 		file: ".gtd/TODO.md"
 	});
 	refusePendingHandOff();
+	flagModeOn();
 	await unwind();
 	if (changes(".gtd/FEEDBACK.md").some((c) => c.status !== "deleted")) await human("unwind-failed", {
 		message: unwindFailedMessage(),

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, R as finisherSystem, _ as REVIEW, at as defaults, c as baseline, i as skills, n as summary, ot as envDefaults, r as access, s as shipped, t as steering, y as coder, z as fixReviewNotesPrompt } from "../chunks/reserved-DDiiAZ8U.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-ILPlELuy.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 { Z as reviewGateBlockedMessage, at as defaults, i as skills, n as summary, ot as envDefaults, r as access, s as shipped, t as steering, u as gate } from "../chunks/reserved-DDiiAZ8U.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-ILPlELuy.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 { at as defaults, ct as flagMentions, ft as requireFlag, i as skills, n as summary, o as flagShipped, ot as envDefaults, p as FEEDBACK, r as access, t as steering, u as gate, ut as flipProblems, y as coder } from "../chunks/reserved-DDiiAZ8U.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

@@ -16916,6 +16916,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"
@@ -17956,18 +17957,20 @@ 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
 ${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
@@ -37522,12 +37525,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",
@@ -38292,7 +38302,7 @@ 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(),
@@ -38373,10 +38383,10 @@ const unwind = () => {
 	const commit = head$1();
 	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,
@@ -38421,6 +38431,7 @@ const ordinaryStart = async () => {
 		file: ".gtd/TODO.md"
 	});
 	refusePendingHandOff();
+	flagModeOn();
 	await unwind();
 	if (changes(".gtd/FEEDBACK.md").some((c) => c.status !== "deleted")) await human("unwind-failed", {
 		message: unwindFailedMessage(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "30.0.0",
+  "version": "30.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/workflows/feature/feature.test.ts

@@ -397,3 +397,44 @@ describe("an in-flight process from before the architecture path was removed", (
     await expect(repo.next()).rejects.toThrow("the workflow changed under this process")
   })
 })
+
+describe("flagMode", () => {
+  const config = (workflow: string): string =>
+    [
+      'import { feature } from "@pmelab/gtd/workflows/feature"',
+      'export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"',
+      `export default ${workflow}`,
+      "",
+    ].join("\n")
+
+  const designed = async (workflow: string, env: Record<string, string> = {}) => {
+    const repo = testRepo({ workflow, env: { GTD_QUALITYREVIEWS: "", ...env } })
+    repo.write("src/calc.ts", CALC)
+    repo.commit("feat: add calculator")
+    repo.write("TODO.md", "# Add subtract\n")
+    return repo.drive({
+      unwind: () => undefined,
+      "start-gate.check": () => undefined,
+      "design.triage": (_, r) =>
+        r.write(".gtd/REQUIREMENTS.md", "# Requirements\n\n## Concerns\n\n### S\n\n- `s`\n"),
+      "design.gate.answer": () => undefined,
+    })
+  }
+
+  it("set on explicitly, runs the naive pass like the default", async () => {
+    expect((await designed(config("feature({ flagMode: true })"))).state).toBe("seam.naive")
+  })
+
+  it("off through GTD_FLAGMODE=false, skips the naive pass and the seam judge", async () => {
+    const rest = await designed(CONFIG_SCAFFOLD, { GTD_FLAGMODE: "false" })
+    expect(rest.state).toBe("implement.building")
+    expect(rest.content).toContain("this project ships without release flags")
+  })
+
+  it("refuses a value other than true or false before the process starts", async () => {
+    const repo = testRepo({ workflow: CONFIG_SCAFFOLD, env: { GTD_FLAGMODE: "off" } })
+    repo.write("TODO.md", "# Add subtract\n")
+    await expect(repo.drive({})).rejects.toThrow('flagMode must be "true" or "false", got "off"')
+    expect(repo.subjects()).toEqual(["chore: initial commit"])
+  })
+})

package/src/workflows/feature/feature.ts

@@ -9,20 +9,21 @@ import {
   start,
 } from "../../flows/index.js"
 import { gate } from "../shared/health.js"
-import { shipped } from "../shared/options.js"
+import { flagModeOn, shipped } from "../shared/options.js"
 import { FEEDBACK } from "../shared/steps.js"
 import { refusePendingHandOff } from "../shared/tail.js"
 import * as t from "../shared/text.js"
 import { design } from "./planning.js"
 import { buildTail, isCode, reUnwind, type ReviewOutcome } from "./review.js"
-import { implement, seamBuild } from "./seam.js"
+import { implement, seamBuild, type SeamOutcome } from "./seam.js"
 import { recordRisk, riskTierOn } from "./tier.js"
 
 // The ordinary start. Any change to the tree starts a process: `idle` →
 // `unwind` reverts the sketch (its intent survives in history) → a
 // green-baseline gate → design → a judged naive pass (refactoring first when
-// the judge asks) → implement → the quality lap → human review, which signs
-// off (the episode ends back at `idle`) or sends a design → implement lap.
+// the judge asks; with `flagMode` off, neither) → implement → the quality lap
+// → human review, which signs off (the episode ends back at `idle`) or sends a
+// design → implement lap.
 
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
 export const unwind = (): Promise<void> => {
@@ -36,10 +37,12 @@ export { reUnwind }
 
 // seam.naive / seam.judge run once: a feedback lap is design → implement on every verdict, so a
 // seam a re-plan turns up is built unjudged and unrefactored.
-/** 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`. */
 export const buildFeature = async (firstBase: string): Promise<void> => {
   const tier = riskTierOn() ? recordRisk() : undefined
-  const seam = await seamBuild(firstBase)
+  const seam: Omit<SeamOutcome, "reference"> & { reference?: string } = flagModeOn()
+    ? await seamBuild(firstBase)
+    : { base: firstBase }
   await slice("feature", async () => {
     await implement({ reference: seam.reference, tier, afterRefactor: seam.refactored })
     // An empty feature slice: the refactor carried the feature, so review the whole change.
@@ -75,6 +78,8 @@ export const afterTail = (outcome: ReviewOutcome): Promise<void> => featureFeedb
 export const ordinaryStart = async (): Promise<void> => {
   await human("idle", { message: t.idleMessage(), label: "Idle", file: ".gtd/TODO.md" })
   refusePendingHandOff()
+  // Read right after idle, so a bad value refuses the landing that would pin it.
+  flagModeOn()
   await unwind()
   if (changes(FEEDBACK).some((c) => c.status !== "deleted")) {
     await human("unwind-failed", {

package/src/workflows/feature/flag-mode.feature

@@ -0,0 +1,157 @@
+@inmem
+Feature: flag mode off builds a feature with no release flag, seam judge or refactor
+
+  `flagMode` is a factory option of the shipped workflows, on by default. Off,
+  the project ships without feature flags: no seam judge and no refactor run,
+  and the naive implementation goes straight through the health loop and the
+  quality lap.
+
+  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 })
+      """
+    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
+    And a file "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      """
+    And the working tree is committed as "feat: add calculator"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      subtract(a, b) returns the difference.
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Concerns
+
+      ### Subtract
+
+      - `subtract(a, b)` returns `a - b`.
+      """
+    And step "design.gate.answer" changes nothing
+
+  Scenario: flag mode off skips the seam judge and the refactor, and asks for no flag
+    When the process is driven
+    Then the process rests at "implement.building"
+    And the resting step's content contains "the quickest way that works"
+    And the resting step's content contains "Add no release flag — this project ships without release flags"
+    And the resting step's content does not contain "new release flag"
+    Given 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
+    And step "build.quality.correctness.reviewing" changes nothing
+    When the process is driven
+    Then the process rests at "build.review.reviewing"
+    And "src/calc.ts" contains "subtract"
+    And the commit subjects end with:
+      """
+      chore: initial commit
+      feat: add calculator
+      gtd(human): idle → unwind
+      gtd(check): unwind → start-gate.check
+      gtd(check): start-gate.check → design.triage
+      gtd(agent): design.triage → design.gate.answer
+      gtd(human): design.gate.answer → implement.building
+      gtd(agent): implement.building → implement.health.check
+      gtd(check): implement.health.check → implement.closing
+      gtd(check): implement.closing → build.quality.correctness.reviewing
+      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
+      """
+
+  Scenario: flag mode off asks for no flag on a feedback lap either
+    Given 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
+    And step "build.quality.correctness.reviewing" changes nothing
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#2-2
+        new subtract function
+      """
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    Given a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#2-2
+        new subtract function[^why]
+
+      [^why]:
+          - H: also export multiply
+      """
+    And step "build.review.collecting" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Concerns
+
+      ### Multiply
+
+      - Export `multiply()`.
+      """
+    And step "build.review.collecting" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#2-2
+        new subtract function[^why]
+
+      [^why]:
+          - H: also export multiply
+          - A: noted in the requirements.
+      """
+    When gtd lands
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    Given a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#2-2
+        new subtract function
+      """
+    And step "build.review.closing" runs its script
+    And step "re-unwind" runs its script
+    And step "implement.building" is no longer scripted
+    When gtd lands
+    And the process is driven
+    Then the process rests at "implement.building"
+    And the resting step's content contains "Add no release flag — this project ships without release flags"
+    And the resting step's content does not contain "release flag the earlier lap added"
+    And no commit body contains "Gtd-Kept:"

package/src/workflows/feature/seam.ts

@@ -17,6 +17,7 @@ import { coder, FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 import { defaults } from "../shared/vars.js"
 import { refactorStrays, reviewedRefactor } from "./refactor.js"
+import { flagModeOn } from "../shared/options.js"
 import type { RiskTier } from "./tier.js"
 
 /** Naive-pass retries after a `reject`; the next `reject` rests at `seam.steer`. */
@@ -71,6 +72,7 @@ export function implement(
         options.tier,
         options.amend,
         options.afterRefactor,
+        flagModeOn(),
       ),
       {
         label: "Implementing",

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

@@ -30,6 +30,18 @@ describe("the shipped workflow factories", () => {
     })
   })
 
+  it("default flagMode on and lay a boolean factory option over it as a string", () => {
+    expect(defaults.flagMode).toBe("true")
+    expect(configure(feature({ flagMode: false }))).toMatchObject({
+      ok: true,
+      build: { defaults: { flagMode: "false" } },
+    })
+    expect(configure(review({ flagMode: true }))).toMatchObject({
+      ok: true,
+      build: { defaults: { flagMode: "true" } },
+    })
+  })
+
   it("declare flag_risk_tier off by default; it is no factory option", () => {
     expect(Object.keys(ShippedOptions.fields)).not.toContain("flag_risk_tier")
   })

package/src/workflows/shared/options.ts

@@ -5,6 +5,8 @@ import {
   type WorkflowBase,
   type WorkflowDoors,
   type WorkflowFactory,
+  refuse,
+  vars,
 } from "../../flows/index.js"
 import { defaultFlagRegistry, defaults, envDefaults } from "./vars.js"
 
@@ -23,18 +25,31 @@ export const ShippedOptions = Schema.Struct({
   testCommand: setting,
   plannerModel: setting,
   coderModel: setting,
+  flagMode: Schema.optionalWith(Schema.Boolean, { exact: true }),
 })
 
 export type ShippedOptions = Schema.Schema.Encoded<typeof ShippedOptions>
 
 const over = (
   base: Readonly<Record<string, string>>,
-  options: Readonly<Record<string, string>>,
+  options: Readonly<Record<string, string | boolean>>,
 ): Record<string, string> => ({
   ...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. */
+export const flagModeOn = (): boolean => {
+  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. */
 export const shipped = (
   flow: Flow,

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

@@ -990,6 +990,22 @@ describe("the seam phase's texts", () => {
     expect(prompt).toContain("Implement them properly")
   })
 
+  it("flag mode off asks for the naive version and no release flag, whatever the tier or lap", () => {
+    for (const [tier, amend] of [
+      ["high", false],
+      ["low", false],
+      ["high", true],
+    ] as const) {
+      const prompt = renderText(() => implementBuildingPrompt(undefined, tier, amend, false, false))
+      expect(prompt).toContain("Add no release flag — this project ships without release flags")
+      expect(prompt).not.toContain("new release flag")
+      expect(prompt).not.toContain("low risk tier")
+    }
+    expect(
+      renderText(() => implementBuildingPrompt(undefined, "high", false, false, false)),
+    ).toContain("the quickest way that works")
+  })
+
   it("keeps a fix turn to the feedback file's rules", () => {
     expect(renderText(() => implementFixPrompt())).toContain(".gtd/FEEDBACK.md")
   })

package/src/workflows/shared/text.ts

@@ -1091,6 +1091,7 @@ export const implementBuildingPrompt = (
   tier?: "low" | "high",
   amend?: boolean,
   afterRefactor?: boolean,
+  flagMode = true,
 ): string =>
   `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
@@ -1106,7 +1107,11 @@ ${
       ? `- 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 === undefined || amend === true
@@ -1116,11 +1121,13 @@ ${
   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

package/src/workflows/shared/vars.ts

@@ -25,6 +25,7 @@ export const defaults: Readonly<Record<string, string>> = {
   reviewSeverityMinP: "0.7",
   refactorFlagPattern: "\\bGTD_FLAG_\\w+",
   seamAllow: [...testFileGlobs, ".gtd/**"].join(", "),
+  flagMode: "true",
   // GTD_FLAG_RISK_TIER, recorded at process start; only "1" is on.
   flag_risk_tier: "0",
   // Decides the turn count: one `build.quality.<lens>` scope per entry, each