@pmelab/gtd 37.0.0 → 38.1.0

package/.claude-plugin/plugin.json

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

@@ -313,6 +313,12 @@ note, past 70% (or when the context is about to be compacted) the turn stops and
 nothing lands. A step's `context` option, or the bundled workflows'
 `contextLimit` option, moves the two limits — see
 [Context limits](https://github.com/pmelab/gtd/blob/main/docs/driver.md#context-limits).
+In `feature`, a naive pass, refactor or build turn that wrapped up that way is a
+snapshot: a fresh turn picks up from it with the handoff note and the criteria
+still open, up to 3 times per phase, across its retries (`continuations`), and a
+phase whose continuations keep stopping, or close nothing twice in a row
+(`continuationStall`), rests for a person — see
+[Continuations](https://github.com/pmelab/gtd/blob/main/docs/configuration.md#continuations).
 
 ### Or drive it from inside Claude Code
 
@@ -638,6 +644,15 @@ 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).
 
+**Coarse slices (`sliceMaxCriteria`, default 8).** A change with more acceptance
+criteria than the cap is built in slices: after design an agent groups related
+criteria (same flow or subsystem) into `.gtd/SLICES.md`, as few slices as the
+cap allows, and each slice — naive pass, refactor and rebuild when judged so,
+health loop, quality lap — runs in order from where the previous one landed.
+`gtd slices` lists them as `feature-1`, `feature-2`, … (`refactor-<n>` ahead of
+a refactored one). A change within the cap is one `feature` slice, as before.
+See [Coarse slices](docs/configuration.md#coarse-slices).
+
 **Flag mode (`flagMode`, on by default).** On, the naive pass's judge runs as
 above and a rebuilt implementation is asked for a new release flag (none at a
 `low` risk tier); a pass the judge lets land is not asked for one. A project

package/dist/chunks/{reserved-zAfoJtR7.mjs → reserved-CfQ8eurM.mjs}

@@ -133,9 +133,12 @@ const defaults = {
 	refactorFlagPattern: "\\bGTD_FLAG_\\w+",
 	seamAllow: [...testFileGlobs, ".gtd/**"].join(", "),
 	flagMode: "true",
+	sliceMaxCriteria: "8",
 	flag_risk_tier: "0",
 	qualityReviews: "correctness, owasp-security, ponytail-review, test-audit, conventions, spec-challenge",
-	refactorQualityReviews: "correctness, ponytail-review, conventions"
+	refactorQualityReviews: "correctness, ponytail-review, conventions",
+	continuations: "3",
+	continuationStall: "2"
 };
 /** Environment settings. */
 const envDefaults = {
@@ -592,6 +595,24 @@ printf '%s\\n' ${[
 	].map(quote).join(" ")} > ${quote(".gtd/REQUIREMENTS.md")}
 `;
 };
+const slicingPrompt = (cap) => `${stateFileRules}
+- Read \`.gtd/REQUIREMENTS.md\`: its \`## Acceptance Criteria\` are settled
+  and more than ${cap}, too many to build in one slice
+- Group them into slices in \`.gtd/SLICES.md\`, one \`## <title>\` heading per
+  slice over a \`- AC-<n>\` list item per criterion it builds. Put criteria of
+  the same flow or subsystem together; every criterion in exactly one slice,
+  at most ${cap} per slice
+- Keep it coarse: as few slices as the cap allows, never one per criterion
+- Order the slices so each builds on the ones before: they run in that order,
+  each from where the previous one landed
+- Change nothing but \`.gtd/SLICES.md\` — leave the criteria as they are
+- Leave everything uncommitted and finish your turn — do not commit
+`;
+/** The line telling a slice's turn which criteria are its own; empty for a single slice. */
+const sliceLine = (ids) => ids === void 0 ? "" : `- This slice builds ${ids.join(", ")} only: every rule here about the criteria
+  means these. The others are for other slices, before or after it — leave
+  them unbuilt and untested
+`;
 const designSystem = () => `${designPersona}
 
 ${agentConduct}`;
@@ -635,7 +656,7 @@ ${strays.map((path) => `  - \`${displayPath(path)}\``).join("\n")}
 - Introduce no new flag read and add no second read of an existing one:
   every match of \`${pattern}\` may move, never increase in number`;
 const withRules = (rules) => rules === void 0 ? "" : `${rules}\n`;
-const refactorBuildingPrompt = ({ pkg, strays, pattern, reference, feedback = false, note = false }) => `${stateFileRules}
+const refactorBuildingPrompt = ({ pkg, strays, pattern, reference, feedback = false, note = false, from }) => `${stateFileRules}
 - The package to implement is \`${pkg}\`; never delete it
 ${note ? `- The package's \`## Refactor note\` section names the seams to open and the
   shape each takes, written from the whole naive pass: build exactly those
@@ -650,8 +671,9 @@ ${reference === void 0 ? "" : `- Reference only: \`git show ${reference} -- ${st
   restructuring afresh here, minus the feature's own behaviour. A
   refactor that touches none of it is wrong, however clean — never
   swap in an unrelated tidy-up
-`}- Leave everything uncommitted and finish your turn — do not commit
-`;
+`}${handoffRule()}
+- Leave everything uncommitted and finish your turn — do not commit
+${from === void 0 ? "" : continuationLines(from)}`;
 const refactorFixPrompt = (strays, pattern) => `${stateFileRules}
 ${fixFeedbackPrompt}
 ${refactorRules(strays, pattern)}
@@ -1219,7 +1241,7 @@ Print the closing message and stop — this writes nothing itself.
 const listed = (paths, unreadable = []) => paths.map((path) => `  - \`${displayPath(path)}\`${unreadable.includes(path) ? " (unreadable)" : ""}`).join("\n");
 const isRed = (retry) => "red" in retry;
 const isFault = (retry) => "fault" in retry;
-const pickUp = (hash) => `Pick it up — \`git diff --binary ${hash}^ ${hash} | git apply\``;
+const pickUp = (hash, exclude) => `Pick it up — \`git diff --binary --no-color --no-ext-diff --no-textconv ${hash}^ ${hash}${exclude === void 0 ? "" : ` -- ${quote(":(top)")} ${quote(`:(top,exclude)${exclude}`)}`} | git apply\``;
 const criteriaBinding = (refused) => `- Its \`## Acceptance Criteria\` (\`AC-<n>\`) bind this turn: re-read them from
   the file, never from memory, and stop only when each one holds. They are
   settled — ${refused ? "a turn that changes them is refused" : "leave them as they are"}`;
@@ -1238,9 +1260,35 @@ re-implement. It changed these files outside the expected set:
 ${listed(retry.strays)}
 Start over and choose a different approach; do not rebuild the same diff.
 `;
-const naivePassPrompt = (retry) => `${stateFileRules}
+const quoted = (text) => text.trimEnd().split("\n").map((line) => line === "" ? "" : `  > ${line}`).join("\n");
+/** Every turn a continuation may pick up tells its agent where the note goes. */
+const handoffRule = () => `- Should you be told to stop at a context limit, write the handoff note to
+  \`.gtd/HANDOFF.md\` — what you touched, what was next — and finish your turn:
+  a fresh turn picks up from what you leave, broken or not. That file is the one
+  exception to any path rule here; write it at no other time`;
+/** `pickUp`: how the snapshot gets into the tree — absent when it already is. */
+const continuationLines = (from, pickUp) => `
+Your previous turn stopped at its context limit; this fresh turn picks up from
+its snapshot (\`${from.snapshot}\`). ${pickUp === void 0 ? "Its work is already in the tree." : `${pickUp}.`} Its handoff note:
+
+${quoted(from.note === "" ? "(empty)" : from.note)}
+
+Still open: ${from.open.length === 0 ? "nothing the workflow can count — finish what the note says is next" : from.open.join(", ")}.
+${pickUp === void 0 ? "Delete `.gtd/HANDOFF.md` once you are done; rewrite it should you be stopped again.\n" : ""}`;
+const oversizedMessage = (phase, from, why, narrowable = true) => `The ${phase} keeps outgrowing its context: ${"cap" in why ? why.cap === 0 ? "continuations are off (`continuations` is 0) and the turn stopped at its context limit" : `${why.cap} continuation${why.cap === 1 ? "" : "s"} ran and the last still stopped at its context limit` : `the last ${why.stall} continuation${why.stall === 1 ? "" : "s"} closed nothing still open`}. The last snapshot is \`${from.snapshot}\`; still open: ${from.open.length === 0 ? "nothing countable" : from.open.join(", ")}.
+
+Its handoff note:
+
+${quoted(from.note === "" ? "(empty)" : from.note)}
+
+Land to go on: a fresh round of continuations picks up from that snapshot${narrowable ? ` — narrow
+\`.gtd/REQUIREMENTS.md\` first if the change is too big, or raise the context limit` : ` — raise
+the context limit first if the refactor is too big`}. \`gtd abandon\` gives the change up.
+`;
+/** `from`: a continuation of a pass that stopped at its context limit, in place of `retry`'s pick-up. */
+const naivePassPrompt = (retry, slice, from) => `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
-${criteriaBinding(false)}
+${sliceLine(slice)}${criteriaBinding(false)}
 - Implement them the quickest way that works — the naive version. Do not
   restructure, abstract or refactor around the change; it may land exactly as
   you leave it, and a reviewer makes it fit
@@ -1255,9 +1303,20 @@ ${criteriaBinding(false)}
 - Run \`${env.testCommand}\` and finish only once it is green with every
   criterion's test passing: the next step runs it on your diff and sends a red
   pass back
-- Leave \`.gtd/\` untouched
+- Leave \`.gtd/\` untouched, a handoff note excepted
+${handoffRule()}
 - Leave everything uncommitted and finish your turn — do not commit
-${retry === void 0 ? "" : naiveRetry(retry)}`;
+${from !== void 0 ? `${continuationLines(from, pickUp(from.snapshot, ".gtd/HANDOFF.md"))}${retry === void 0 ? "" : isFault(retry) ? `
+The pass this continues was a retry: its tests fell short, and still must not:
+${retry.fault}
+` : isRed(retry) ? `
+The pass this continues was a retry after a red suite (\`.gtd/FEEDBACK.md\`
+holds the output): finish only once the suite is green.
+` : `
+The pass this continues was a retry after a \`reject\`: keep away from the
+approach that changed these files outside the expected set:
+${listed(retry.strays)}
+`}` : retry === void 0 ? "" : naiveRetry(retry)}`;
 const carries = (rebuild) => (rebuild.acceptance?.ids.length ?? 0) > 0;
 const rebuildLines = ({ note, acceptance }) => `${note === void 0 ? "" : `- The refactor note (\`.gtd/REFACTOR-NOTE.md\`) named the seams the refactor
   opened; plug the change into them:
@@ -1290,9 +1349,13 @@ const afterRefactorLine = (rebuild) => `- A reviewed refactor has just landed an
   though never a release flag. Build only what is still missing, held to every
   rule below; if nothing is, ${carries(rebuild) ? "carry over the acceptance tests below and change nothing else" : "change nothing and finish your turn"}
 `;
-const implementBuildingPrompt = (reference, tier, amend, afterRefactor, flagMode = true, rebuild = {}) => `${stateFileRules}
+const flagLine = (flagMode, tier, amend, sliced) => !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" : sliced ? `- Put the new behaviour behind the release flag an earlier slice of this
+  change added; only when none did, behind a new one, following the
+  repository's flag conventions` : `- Put the new behaviour behind a new release flag, following the
+  repository's flag conventions`;
+const implementBuildingPrompt = (reference, tier, amend, afterRefactor, flagMode = true, rebuild = {}, slice, from) => `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
-${criteriaBinding(true)}
+${sliceLine(slice)}${criteriaBinding(true)}
 ${afterRefactor === true ? afterRefactorLine(rebuild) : ""}${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
 ` : flagMode ? `- Implement them properly, fitting the codebase's seams and conventions
@@ -1301,14 +1364,14 @@ ${afterRefactor === true ? afterRefactorLine(rebuild) : ""}${amend === true ? `-
 `}${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${carries(rebuild) ? ", its acceptance tests excepted (below)" : ""}
-`}${rebuildLines(rebuild)}${!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`}
+`}${rebuildLines(rebuild)}${flagLine(flagMode, tier, amend, slice !== void 0)}
 - Write the tests first, then the code that makes them pass. Name each
   criterion's ID in the test that covers it (\`[AC-3] …\`): once the suite is
   green a judge checks every ID has a passing test, and sends uncovered ones back
+${handoffRule()}
 - Leave \`.gtd/REQUIREMENTS.md\` in place and everything uncommitted, then
   finish your turn
-`;
+${from === void 0 ? "" : continuationLines(from)}`;
 const implementFixPrompt = () => `${stateFileRules}
 ${fixFeedbackPrompt}
 - Leave everything uncommitted and finish your turn — do not commit
@@ -1383,9 +1446,9 @@ const coverageMessage = () => `Judging acceptance-criteria coverage. Run \`gtd j
 \`yes\`/\`no\` verdict per criterion ID — or land without a verdict, which
 counts every criterion as uncovered.
 `;
-const coveringPrompt = (uncovered) => `${stateFileRules}
+const coveringPrompt = (uncovered, slice) => `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
-${criteriaBinding(true)}
+${sliceLine(slice)}${criteriaBinding(true)}
 - A judge found no passing test in this change that covers ${uncovered.join(", ")}.
   Write a behaviour-level test for each, naming its ID in the test or scenario
   name (\`[${uncovered[0]}] …\`), and fix the code if the test shows it falls short
@@ -1412,6 +1475,8 @@ const REVIEW = ".gtd/REVIEW.md";
 const REFACTOR = ".gtd/REFACTOR.md";
 const REFACTOR_NOTE = ".gtd/REFACTOR-NOTE.md";
 const QUALITY = ".gtd/QUALITY.md";
+const SLICES = ".gtd/SLICES.md";
+const HANDOFF = ".gtd/HANDOFF.md";
 const planner = () => env.plannerModel ?? "";
 const coder = () => env.coderModel ?? "";
 const fixCheck = (rules) => agentWithSkills("fix", buildFixPrompt(rules), {
@@ -1605,8 +1670,11 @@ const ShippedOptions = Struct({
 	reviewSeverityMinP: setting,
 	refactorFlagPattern: setting,
 	seamAllow: setting,
+	sliceMaxCriteria: setting,
 	qualityReviews: setting,
 	refactorQualityReviews: setting,
+	continuations: setting,
+	continuationStall: setting,
 	testCommand: setting,
 	plannerModel: setting,
 	coderModel: setting,
@@ -1710,4 +1778,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { normaliseCriteriaScript as $, buildReviewAwaitAfterDeferMessage as A, criterionLine as B, fixRisks as C, registryEntry as Ct, reviewing as D, reviewQuality as E, clearCriteriaMessage as F, finisherSystem as G, designGateAnswerMessage as H, clearCriteriaQuestion as I, idleMessage as J, fixReviewNotesPrompt as K, coverageMessage as L, buildReviewFixNitsPrompt as M, buildReviewTriageMessage as N, agentWithSkills as O, builderSystem as P, naivePassPrompt as Q, coverageQuestion as R, fixQuality as S, flipProblems as St, reviewMissing as T, designSystem as U, deferNotesScript as V, designTriagePrompt as W, implementFixPrompt as X, implementBuildingPrompt as Y, naiveApplyFailure as Z, REQUIREMENTS as _, defaults as _t, flagModeOn as a, refactorRules as at, coder as b, flagMentions as bt, baseline as c, reviewGateBlockedMessage as ct, guarded as d, seamByHandMessage as dt, qualityUnresolvedMessage as et, healthy as f, seamSteerMessage as ft, REFACTOR_NOTE as g, unwindFailure as gt, REFACTOR as h, unwindFailedMessage as ht, skills as i, refactorNotePrompt as it, buildReviewCollectingPrompt as j, buildReviewAnswerQuestionsPrompt as k, escalation as l, reviewNotesCapture as lt, QUALITY as m, uncoveredMessage as mt, summary as n, refactorDroppedRefusal as nt, flagShipped as o, reviewEditNotesCapture as ot, FEEDBACK as p, startGateBlockedMessage as pt, handOffAwaitReviewMessage as q, access as r, refactorFixPrompt as rt, shipped as s, reviewEditsCapture as st, steering as t, refactorBuildingPrompt as tt, gate as u, reviewerSystem as ut, REVIEW as v, envDefaults as vt, planner as w, requireFlag as wt, fixCheck as x, flagReferences as xt, awaitReview as y, testFileGlobs as yt, coveringPrompt as z };
+export { naiveApplyFailure as $, agentWithSkills as A, coverageQuestion as B, fixCheck as C, testFileGlobs as Ct, reviewMissing as D, registryEntry as Dt, planner as E, flipProblems as Et, buildReviewTriageMessage as F, designSystem as G, criterionLine as H, builderSystem as I, fixReviewNotesPrompt as J, designTriagePrompt as K, clearCriteriaMessage as L, buildReviewAwaitAfterDeferMessage as M, buildReviewCollectingPrompt as N, reviewQuality as O, requireFlag as Ot, buildReviewFixNitsPrompt as P, implementFixPrompt as Q, clearCriteriaQuestion as R, coder as S, envDefaults as St, fixRisks as T, flagReferences as Tt, deferNotesScript as U, coveringPrompt as V, designGateAnswerMessage as W, idleMessage as X, handOffAwaitReviewMessage as Y, implementBuildingPrompt as Z, REFACTOR_NOTE as _, startGateBlockedMessage as _t, flagModeOn as a, refactorDroppedRefusal as at, SLICES as b, unwindFailure as bt, baseline as c, refactorRules as ct, guarded as d, reviewGateBlockedMessage as dt, naivePassPrompt as et, healthy as f, reviewNotesCapture as ft, REFACTOR as g, slicingPrompt as gt, QUALITY as h, seamSteerMessage as ht, skills as i, refactorBuildingPrompt as it, buildReviewAnswerQuestionsPrompt as j, reviewing as k, escalation as l, reviewEditNotesCapture as lt, HANDOFF as m, seamByHandMessage as mt, summary as n, oversizedMessage as nt, flagShipped as o, refactorFixPrompt as ot, FEEDBACK as p, reviewerSystem as pt, finisherSystem as q, access as r, qualityUnresolvedMessage as rt, shipped as s, refactorNotePrompt as st, steering as t, normaliseCriteriaScript as tt, gate as u, reviewEditsCapture as ut, REQUIREMENTS as v, uncoveredMessage as vt, fixQuality as w, flagMentions as wt, awaitReview as x, defaults as xt, REVIEW as y, unwindFailedMessage as yt, coverageMessage as z };

package/dist/chunks/{tail-BRC4DGdV.mjs → tail-C7yaWvaS.mjs}

@@ -1,6 +1,6 @@
 import { read, refuse, removeScript, run, scope, showScript, vars } from "../flows.mjs";
 import { fixFindings, lensEntriesOf, lensOf, qualityLap as qualityLap$1, reviewToHandOff } from "../workflow-kit.mjs";
-import { C as fixRisks, D as reviewing, E as reviewQuality, S as fixQuality, T as reviewMissing, d as guarded, f as healthy, l as escalation, m as QUALITY, q as handOffAwaitReviewMessage, v as REVIEW, x as fixCheck, y as awaitReview } from "./reserved-zAfoJtR7.mjs";
+import { C as fixCheck, D as reviewMissing, O as reviewQuality, T as fixRisks, Y as handOffAwaitReviewMessage, d as guarded, f as healthy, h as QUALITY, k as reviewing, l as escalation, w as fixQuality, x as awaitReview, y as REVIEW } from "./reserved-CfQ8eurM.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/chunks/{wire-CSsa3Wxd.mjs → wire-BJuZWR3C.mjs}

@@ -591,7 +591,7 @@ const contextHook = (input) => {
 	};
 	if (tokens >= limit.soft * window) return {
 		kind: "soft",
-		reason: `Context limit: ${used} used, past the ${percent(limit.soft)} soft limit. Stop working now. Do not start anything new; end your turn with a short handoff note as your answer: what you touched, and what was next.`
+		reason: `Context limit: ${used} used, past the ${percent(limit.soft)} soft limit. Stop working now. Do not start anything new; end your turn with a short handoff note as your answer: what you touched, and what was next. Where your instructions name a file for that note, write it there too.`
 	};
 };
 /** A decision as Claude Code's settings-hook JSON output. */

package/dist/gtd.bundle.mjs

@@ -37839,7 +37839,7 @@ var init_ContextLimit = __esmMin((() => {
 		};
 		if (tokens >= limit.soft * window) return {
 			kind: "soft",
-			reason: `Context limit: ${used} used, past the ${percent(limit.soft)} soft limit. Stop working now. Do not start anything new; end your turn with a short handoff note as your answer: what you touched, and what was next.`
+			reason: `Context limit: ${used} used, past the ${percent(limit.soft)} soft limit. Stop working now. Do not start anything new; end your turn with a short handoff note as your answer: what you touched, and what was next. Where your instructions name a file for that note, write it there too.`
 		};
 	};
 	hookOutput = (decision) => decision.kind === "soft" ? {

package/dist/testkit.mjs

@@ -1,5 +1,5 @@
 import { applyScript, checkScript, configProblems, configure, installContext, isFactoryWorkflow, moveScript, protocolMismatch, removeScript, restoreScript, revertScript, showScript, t as flows_exports } from "./flows.mjs";
-import { A as beatKindOf, B as ACCESS_REFUSAL, C as renderLandPlain, D as renderBeatJson, E as beatDocument, O as statusOf, S as renderLandJson, T as renderBeatPlain, U as renderFormat, _ as selectPath, a as contextLimitFault, g as resolveSession, h as globMatches, j as demandOf, l as parseContextWindow, m as slicesDocument, o as contextShapeFault, p as renderSlicesJson, v as judgeJson, x as noopText, y as landFields } from "./chunks/wire-CSsa3Wxd.mjs";
+import { A as beatKindOf, B as ACCESS_REFUSAL, C as renderLandPlain, D as renderBeatJson, E as beatDocument, O as statusOf, S as renderLandJson, T as renderBeatPlain, U as renderFormat, _ as selectPath, a as contextLimitFault, g as resolveSession, h as globMatches, j as demandOf, l as parseContextWindow, m as slicesDocument, o as contextShapeFault, p as renderSlicesJson, v as judgeJson, x as noopText, y as landFields } from "./chunks/wire-BJuZWR3C.mjs";
 import { C as headingSections, S as headingSectionBodies, a as unansweredQuestions, b as parseThreadsWithFindings, n as openThreads, r as steeringFormatFor, s as parseCodeThreads, t as BUILT_IN_MODE_NAMES, w as formatFinding } from "./chunks/steering-DVILanVf.mjs";
 import { $ as logWarning, $i as NodeInspectSymbol, $n as map$5, $r as make$19, $t as provide$1, A as catchIf, Ai as add, An as scopeMake, Ar as flatMap$3, At as suspend$5, B as flatMap$4, Bi as getOrElse, Bn as get$3, Br as sync$1, Bt as unsafeMakeLatch, C as all$1, Ci as toArray, Cn as isInterrupted, Cr as exitFail, Ct as sandbox, D as async, Di as GenericTag, Dn as squash, Dr as exitZipRight, Dt as scopedWith$1, E as asVoid$1, Ei as unsafeHead, En as reduceWithContext, Er as exitVoid, Et as scoped$4, F as ensuring$2, Fi as fromIterable, Fn as join$3, Fr as map$3, Ft as tryMap, G as forkIn, Gi as none, Gn as TypeId$10, Gr as whenEffect, Gt as zipLeft, H as fnUntraced, Hi as isSome, Hn as modify$1, Hr as uninterruptible, Ht as when, I as exit, Ii as splitAt, In as sequential, Ir as onInterrupt, It as tryPromise, J as ignore, Ji as left, Jn as all, Jr as DeferredTypeId$1, Jt as spaced$1, K as forkScoped, Ki as some, Kn as Class, Kr as withFiberRuntime, Kt as zipRight$3, L as fail$5, Li as filter$1, Ln as bind, Lr as scopeClose, Lt as try_, M as die$2, Mi as getOption, Mn as _await$2, Mr as interruptAsFiber, Mt as tap, N as dieMessage, Ni as omit, Nn as inheritAll$1, Nr as interruptFiber, Nt as tapErrorCause, O as catchAll$1, Oi as Reference, On as ensuring$3, Or as fiberId, Ot as serviceOption, P as either, Pi as empty$5, Pn as interruptAllAs$1, Pr as interruptible$1, Pt as timeout, Q as isEffect, Qi as BaseProto, Qn as isFailure, Qr as ids, Qt as mergeAll$2, R as failCause$4, Ri as flatMap$5, Rn as bindTo, Rr as succeed$4, Rt as uninterruptible$1, S as addFinalizer$1, Si as takeRight, Sn as isDieType, Sr as exitAs, St as runtime, T as as, Ti as unsafeGet, Tn as map$6, Tr as exitSucceed, Tt as scopeWith, U as forEach$2, Ui as map$8, Un as set$1, Ur as uninterruptibleMask$1, Ut as withFiberRuntime$1, V as flatten$4, Vi as isNone, Vn as make$16, Vr as tap$1, Vt as unsafeMakeSemaphore$1, W as forkDaemon, Wi as match$4, Wn as update$1, Wr as void_$2, Wt as zip$1, X as interruptible, Xi as right, Xn as fail$4, Xr as combine, Xt as tagged, Y as interrupt$4, Yi as match$2, Yn as die, Yr as empty$6, Yt as TaggedError$1, Z as intoDeferred, Zi as pipeArguments, Zn as failCause$3, Zr as combineAll, Zt as fromEffect$5, _ as decodeSync, _i as of, _n as fail$3, _r as deferredIsDone, _t as raceWith, a as Literal, aa as constTrue, ai as size$2, an as updateContext$1, ar as zipRight$2, at as matchCause, b as acquireRelease, bi as reverse, bn as interrupt$3, br as deferredUnsafeDone, bt as runPromise, c as String$, ca as dual, ci as append$1, cn as Scope, cr as asyncInterrupt, ct as negate, d as Union, di as empty$4, dn as close, dr as deferredAwait, dt as orElse, ea as format, ei as none$1, en as provideMerge$1, er as mapBoth, et as makeSemaphore, f as between, fi as filter, fn as extend, fr as deferredComplete, ft as orElseSucceed, gi as map$7, gn as die$1, gr as deferredInterruptWith, gt as race, hi as isEmpty$2, hn as NoSuchElementException, hr as deferredInterrupt, ht as provideService, i as Defect, ia as constFalse, ii as has, in as unsafeRunPromiseExit, ir as zip$2, it as match$5, j as catchTag, ji as get$5, jn as scopeTag, jr as interrupt$2, jt as sync$2, k as catchAllCause, ki as Tag, kn as forEachConcurrentDiscard, kr as fiberRefLocally, kt as succeed$6, l as Struct, la as identity, li as appendAll, ln as addFinalizer, lr as catchAll, lt as onError, m as optional$1, mi as isChunk, mn as make$18, mr as deferredFailCause, mt as provide$2, n as Boolean$, na as equals, ni as make$17, nn as succeed$3, nr as succeed$5, nt as mapBoth$1, o as Never, oa as constUndefined, oi as decode, on as forkIn$1, or as as$1, ot as matchCauseEffect, p as decodeUnknown, pi as fromIterable$1, pn as fork, pr as deferredFail, pt as promise, q as gen, qi as isLeft, qn as spanTag, qr as zipRight$1, qt as zipWith, r as Cause, ra as hasProperty, ri as set$2, rn as unsafeFork, rr as void_$3, rt as mapError, s as Number$, sa as constVoid, si as isFinite, sn as unsafeMakeSemaphore, sr as asVoid, st as matchEffect, t as Array$, ta as toJSON, ti as get$4, tn as scoped$3, tr as match$3, tt as map$4, u as TaggedError, ua as pipe, ui as drop, un as addFinalizerExit, ur as currentContext$1, ut as orDie, v as encodeSync, vi as prepend, vn as failureOrCause, vr as deferredMake, vt as repeat, w as annotateLogs, wi as unsafeFromArray, wn as isInterruptedOnly, wr as exitFailCause, wt as scope, x as acquireUseRelease$2, xi as take$2, xn as interruptors, xr as deferredUnsafeMake, xt as runPromiseExit$1, y as _void, yi as reduce, yn as flipCauseOption, yr as deferredSucceed, yt as retry, z as fiberIdWith, zi as fromNullable, zn as sleep, zr as suspend$4, zt as uninterruptibleMask } from "./chunks/Schema-DO5ttJaI.mjs";
 import { createRequire } from "node:module";

package/dist/wire.mjs

@@ -1,2 +1,2 @@
-import { A as beatKindOf, B as ACCESS_REFUSAL, C as renderLandPlain, D as renderBeatJson, E as beatDocument, F as EXIT_RUNTIME_ERROR, H as WIRE_SCHEMA, I as EXIT_SIGINT, L as EXIT_SIGTERM, M as stallDiagnosis, N as EXIT_CODES, O as statusOf, P as EXIT_OK, R as EXIT_STRAYS_FOUND, S as renderLandJson, T as renderBeatPlain, U as renderFormat, V as UNATTRIBUTED_MODEL, _ as selectPath, a as contextLimitFault, b as landProseText, c as hookOutput, d as transcriptTokens, f as usageTokens, g as resolveSession, h as globMatches, i as contextHook, j as demandOf, k as BEAT_KINDS, l as parseContextWindow, m as slicesDocument, n as CONTEXT_STOP_FILE_ENV, o as contextShapeFault, p as renderSlicesJson, r as DEFAULT_CONTEXT_LIMIT, s as contextWindowFor, t as CONTEXT_LIMIT_MARKER, u as subagentTranscriptPath, v as judgeJson, w as DEMAND_BRIEFING, x as noopText, y as landFields, z as EXIT_USAGE_ERROR } from "./chunks/wire-CSsa3Wxd.mjs";
+import { A as beatKindOf, B as ACCESS_REFUSAL, C as renderLandPlain, D as renderBeatJson, E as beatDocument, F as EXIT_RUNTIME_ERROR, H as WIRE_SCHEMA, I as EXIT_SIGINT, L as EXIT_SIGTERM, M as stallDiagnosis, N as EXIT_CODES, O as statusOf, P as EXIT_OK, R as EXIT_STRAYS_FOUND, S as renderLandJson, T as renderBeatPlain, U as renderFormat, V as UNATTRIBUTED_MODEL, _ as selectPath, a as contextLimitFault, b as landProseText, c as hookOutput, d as transcriptTokens, f as usageTokens, g as resolveSession, h as globMatches, i as contextHook, j as demandOf, k as BEAT_KINDS, l as parseContextWindow, m as slicesDocument, n as CONTEXT_STOP_FILE_ENV, o as contextShapeFault, p as renderSlicesJson, r as DEFAULT_CONTEXT_LIMIT, s as contextWindowFor, t as CONTEXT_LIMIT_MARKER, u as subagentTranscriptPath, v as judgeJson, w as DEMAND_BRIEFING, x as noopText, y as landFields, z as EXIT_USAGE_ERROR } from "./chunks/wire-BJuZWR3C.mjs";
 export { ACCESS_REFUSAL, BEAT_KINDS, CONTEXT_LIMIT_MARKER, CONTEXT_STOP_FILE_ENV, DEFAULT_CONTEXT_LIMIT, DEMAND_BRIEFING, EXIT_CODES, EXIT_OK, EXIT_RUNTIME_ERROR, EXIT_SIGINT, EXIT_SIGTERM, EXIT_STRAYS_FOUND, EXIT_USAGE_ERROR, UNATTRIBUTED_MODEL, WIRE_SCHEMA, beatDocument, beatKindOf, contextHook, contextLimitFault, contextShapeFault, contextWindowFor, demandOf, globMatches, hookOutput, judgeJson, landFields, landProseText, noopText, parseContextWindow, renderBeatJson, renderBeatPlain, renderFormat, renderLandJson, renderLandPlain, renderSlicesJson, resolveSession, selectPath, slicesDocument, stallDiagnosis, statusOf, subagentTranscriptPath, transcriptTokens, usageTokens };

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { Ct as registryEntry, _t as defaults, b as coder, i as skills, n as summary, o as flagShipped, r as access, t as steering, vt as envDefaults, wt as requireFlag, xt as flagReferences } from "../chunks/reserved-zAfoJtR7.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-BRC4DGdV.mjs";
+import { Dt as registryEntry, Ot as requireFlag, S as coder, St as envDefaults, Tt as flagReferences, i as skills, n as summary, o as flagShipped, r as access, t as steering, xt as defaults } from "../chunks/reserved-CfQ8eurM.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-C7yaWvaS.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 () => {