@pmelab/gtd 52.1.0 → 53.0.0

package/dist/gtd.bundle.mjs

@@ -7,7 +7,7 @@ import { isIP } from "node:net";
 import * as Crypto from "node:crypto";
 import { createHash, randomUUID } from "node:crypto";
 import * as NFS from "node:fs";
-import { appendFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import * as OS from "node:os";
 import { homedir, networkInterfaces, tmpdir } from "node:os";
 import * as Path from "node:path";
@@ -6766,7 +6766,7 @@ var init_label = __esmMin((() => {
 }));
 //#endregion
 //#region node_modules/effect/dist/esm/internal/core-effect.js
-var annotateLogs$1, asSome, try_$1, catchAllDefect$1, catchTag$1, diffFiberRefs, bind, bindTo, match$4, fiberRefs, ignore$1, logWithLevel, logWarning$1, logError$1, mapErrorCause, negate$1, orElseSucceed$1, patchFiberRefs, promise$1, provideService$1, provideServiceEffect, sandbox$1, sleep$1, succeedNone, summarized, tapErrorCause$1, tryPromise$1, tryMap$1, updateFiberRefs, when$1, serviceOption$1;
+var annotateLogs$1, asSome, try_$1, catchTag$1, diffFiberRefs, bind, bindTo, match$4, fiberRefs, ignore$1, logWithLevel, logWarning$1, logError$1, mapErrorCause, negate$1, orElseSucceed$1, patchFiberRefs, promise$1, provideService$1, provideServiceEffect, sandbox$1, sleep$1, succeedNone, summarized, tapErrorCause$1, tryPromise$1, tryMap$1, updateFiberRefs, when$1, serviceOption$1;
 var init_core_effect = __esmMin((() => {
 	init_Clock();
 	init_Context();
@@ -6801,13 +6801,6 @@ var init_core_effect = __esmMin((() => {
 			}
 		});
 	};
-	catchAllDefect$1 = /*#__PURE__*/ dual(2, (self, f) => catchAllCause$1(self, (cause) => {
-		const option = find(cause, (_) => isDieType$1(_) ? some(_) : none$4());
-		switch (option._tag) {
-			case "None": return failCause$6(cause);
-			case "Some": return f(option.value.defect);
-		}
-	}));
 	catchTag$1 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, ...args) => {
 		const f = args[args.length - 1];
 		let predicate;
@@ -7656,7 +7649,7 @@ _A: (_) => _ };
 //#endregion
 //#region node_modules/effect/dist/esm/internal/metric/hook.js
 var MetricHookSymbolKey, MetricHookTypeId, metricHookVariance, make$25, bigint0$1, counter$1, frequency, gauge, histogram$1, summary, calculateQuantiles, resolveQuantile;
-var init_hook$1 = __esmMin((() => {
+var init_hook = __esmMin((() => {
 	init_Array();
 	init_Duration();
 	init_Function();
@@ -7953,7 +7946,7 @@ var init_registry = __esmMin((() => {
 	init_Function();
 	init_MutableHashMap();
 	init_Option();
-	init_hook$1();
+	init_hook();
 	init_keyType();
 	init_pair();
 	MetricRegistrySymbolKey = "effect/MetricRegistry";
@@ -11382,7 +11375,7 @@ var init_MutableQueue = __esmMin((() => {
 }));
 //#endregion
 //#region node_modules/effect/dist/esm/Effect.js
-var isEffect, all$1, forEach$2, async, withFiberRuntime, fail$7, failCause$2, die, dieMessage, gen, promise, succeed$3, suspend$5, sync$1, _void, catchAll, catchAllCause, catchAllDefect, catchIf, catchTag, ignore, sandbox, retry, try_, tryMap, tryPromise, interrupt, interruptible, uninterruptible, uninterruptibleMask, as, asVoid, map$4, mapBoth$1, mapError$1, negate, acquireRelease, acquireUseRelease$2, addFinalizer, ensuring$2, onError, scope$1, scopeWith, scopedWith$1, scoped$3, fiberIdWith, forkDaemon, forkIn, forkScoped, timeout, provide$1, provideService, serviceOption, either, exit$1, intoDeferred, when, flatMap$4, andThen, flatten$5, race, raceWith, tap, tapErrorCause, repeat, match$2, matchCause, matchCauseEffect, matchEffect, logWarning, logError, annotateLogs, orDie, orElse$1, orElseSucceed, runtime, unsafeMakeSemaphore, makeSemaphore, unsafeMakeLatch, runFork$1, runPromise, runSync, zip$1, zipLeft, zipRight$1, zipWith, fnUntraced;
+var isEffect, all$1, forEach$2, async, withFiberRuntime, fail$7, failCause$2, die, dieMessage, gen, promise, succeed$3, suspend$5, sync$1, _void, catchAll, catchAllCause, catchIf, catchTag, ignore, sandbox, retry, try_, tryMap, tryPromise, interrupt, interruptible, uninterruptible, uninterruptibleMask, as, asVoid, map$4, mapBoth$1, mapError$1, negate, acquireRelease, acquireUseRelease$2, addFinalizer, ensuring$2, onError, scope$1, scopeWith, scopedWith$1, scoped$3, fiberIdWith, forkDaemon, forkIn, forkScoped, timeout, provide$1, provideService, serviceOption, either, exit$1, intoDeferred, when, flatMap$4, andThen, flatten$5, race, raceWith, tap, tapErrorCause, repeat, match$2, matchCause, matchCauseEffect, matchEffect, logWarning, logError, annotateLogs, orDie, orElse$1, orElseSucceed, runtime, unsafeMakeSemaphore, makeSemaphore, unsafeMakeLatch, runFork$1, runPromise, runSync, zip$1, zipLeft, zipRight$1, zipWith, fnUntraced;
 var init_Effect = __esmMin((() => {
 	init_core_effect();
 	init_core();
@@ -11408,7 +11401,6 @@ var init_Effect = __esmMin((() => {
 	_void = void_$4;
 	catchAll = catchAll$1;
 	catchAllCause = catchAllCause$1;
-	catchAllDefect = catchAllDefect$1;
 	catchIf = catchIf$1;
 	catchTag = catchTag$1;
 	ignore = ignore$1;
@@ -14226,7 +14218,7 @@ function getBrands(ast) {
 		onSome: (brands) => brands.map((brand) => ` & Brand<${formatUnknown(brand)}>`).join("")
 	});
 }
-var TypeConstructorAnnotationId, BrandAnnotationId, SchemaIdAnnotationId, MessageAnnotationId, MissingMessageAnnotationId, IdentifierAnnotationId, TitleAnnotationId, AutoTitleAnnotationId, DescriptionAnnotationId, ExamplesAnnotationId, DefaultAnnotationId, JSONSchemaAnnotationId, ArbitraryAnnotationId, PrettyAnnotationId, EquivalenceAnnotationId, DocumentationAnnotationId, ConcurrencyAnnotationId, BatchingAnnotationId, ParseIssueTitleAnnotationId, ParseOptionsAnnotationId, DecodingFallbackAnnotationId, SurrogateAnnotationId, StableFilterAnnotationId, getAnnotation, getBrandAnnotation, getMessageAnnotation, getMissingMessageAnnotation, getTitleAnnotation, getAutoTitleAnnotation, getIdentifierAnnotation, getDescriptionAnnotation, getConcurrencyAnnotation, getBatchingAnnotation, getParseIssueTitleAnnotation$1, getParseOptionsAnnotation, getDecodingFallbackAnnotation, getSurrogateAnnotation, getStableFilterAnnotation, hasStableFilter, JSONIdentifierAnnotationId, getJSONIdentifierAnnotation, getJSONIdentifier, Declaration, createASTGuard, Literal$1, isLiteral, UniqueSymbol, UndefinedKeyword, undefinedKeyword, NeverKeyword, neverKeyword, UnknownKeyword, unknownKeyword, AnyKeyword, anyKeyword, StringKeyword, stringKeyword, isStringKeyword, NumberKeyword, numberKeyword, isNumberKeyword, BooleanKeyword, booleanKeyword, isBooleanKeyword, BigIntKeyword, bigIntKeyword, SymbolKeyword, symbolKeyword, isSymbolKeyword, Type$1, OptionalType, getRestASTs, TupleType, formatTuple, PropertySignature, isParameter, IndexSignature, TypeLiteral, formatIndexSignatures, formatTypeLiteral, isTypeLiteral, sortCandidates, literalMap, flatten$2, unify, Union$1, mapMembers, isMembers, isUnion, toJSONMemoMap, Suspend, Refinement$1, isRefinement$1, defaultParseOption, Transformation$1, isTransformation$1, FinalTransformation, createTransformationGuard, ComposeTransformation, composeTransformation, PropertySignatureTransformation$1, TypeLiteralTransformation, isTypeLiteralTransformation, annotations, STRING_KEYWORD_PATTERN, NUMBER_KEYWORD_PATTERN, getTemplateLiteralSpanTypePattern, handleTemplateLiteralSpanTypeParens, getTemplateLiteralPattern, getTemplateLiteralRegExp, record$2, pickAnnotations, omitAnnotations, preserveTransformationAnnotations, typeAST, getTransformationFrom, encodedAST_, encodedAST, toJSONAnnotations, getEncodedParameter, formatKeyword, getOrElseExpected, getExpected;
+var TypeConstructorAnnotationId, BrandAnnotationId, SchemaIdAnnotationId, MessageAnnotationId, MissingMessageAnnotationId, IdentifierAnnotationId, TitleAnnotationId, AutoTitleAnnotationId, DescriptionAnnotationId, ExamplesAnnotationId, DefaultAnnotationId, JSONSchemaAnnotationId, ArbitraryAnnotationId, PrettyAnnotationId, EquivalenceAnnotationId, DocumentationAnnotationId, ConcurrencyAnnotationId, BatchingAnnotationId, ParseIssueTitleAnnotationId, ParseOptionsAnnotationId, DecodingFallbackAnnotationId, SurrogateAnnotationId, StableFilterAnnotationId, getAnnotation, getBrandAnnotation, getMessageAnnotation, getMissingMessageAnnotation, getTitleAnnotation, getAutoTitleAnnotation, getIdentifierAnnotation, getDescriptionAnnotation, getConcurrencyAnnotation, getBatchingAnnotation, getParseIssueTitleAnnotation$1, getParseOptionsAnnotation, getDecodingFallbackAnnotation, getSurrogateAnnotation, getStableFilterAnnotation, hasStableFilter, JSONIdentifierAnnotationId, getJSONIdentifierAnnotation, getJSONIdentifier, Declaration, createASTGuard, Literal$1, isLiteral, UniqueSymbol, UndefinedKeyword, undefinedKeyword, NeverKeyword, neverKeyword, UnknownKeyword, unknownKeyword, AnyKeyword, anyKeyword, StringKeyword, stringKeyword, isStringKeyword, NumberKeyword, numberKeyword, isNumberKeyword, BooleanKeyword, booleanKeyword, isBooleanKeyword, BigIntKeyword, bigIntKeyword, SymbolKeyword, symbolKeyword, isSymbolKeyword, Type$1, OptionalType, getRestASTs, TupleType, formatTuple, PropertySignature, isParameter, IndexSignature, TypeLiteral, formatIndexSignatures, formatTypeLiteral, isTypeLiteral, sortCandidates, literalMap, flatten$2, unify, Union$1, mapMembers, isMembers, isUnion, toJSONMemoMap, Suspend, Refinement$1, isRefinement$1, defaultParseOption, Transformation$1, isTransformation$1, FinalTransformation, createTransformationGuard, ComposeTransformation, composeTransformation, PropertySignatureTransformation$1, TypeLiteralTransformation, isTypeLiteralTransformation, annotations, STRING_KEYWORD_PATTERN, NUMBER_KEYWORD_PATTERN, getTemplateLiteralSpanTypePattern, handleTemplateLiteralSpanTypeParens, getTemplateLiteralPattern, getTemplateLiteralRegExp, record$1, pickAnnotations, omitAnnotations, preserveTransformationAnnotations, typeAST, getTransformationFrom, encodedAST_, encodedAST, toJSONAnnotations, getEncodedParameter, formatKeyword, getOrElseExpected, getExpected;
 var init_SchemaAST = __esmMin((() => {
 	init_Array();
 	init_Function();
@@ -15189,7 +15181,7 @@ var init_SchemaAST = __esmMin((() => {
 		return pattern;
 	};
 	getTemplateLiteralRegExp = (ast) => new RegExp(`^${getTemplateLiteralPattern(ast, false, true)}$`);
-	record$2 = (key, value) => {
+	record$1 = (key, value) => {
 		const propertySignatures = [];
 		const indexSignatures = [];
 		const go = (key) => {
@@ -16774,7 +16766,7 @@ var init_Schema = __esmMin((() => {
 				const issFrom = [];
 				const issTo = [];
 				for (const r of records) {
-					const { indexSignatures, propertySignatures } = record$2(r.key.ast, r.value.ast);
+					const { indexSignatures, propertySignatures } = record$1(r.key.ast, r.value.ast);
 					propertySignatures.forEach((ps) => {
 						from.push(ps);
 						to.push(new PropertySignature(ps.name, typeAST(ps.type), ps.isOptional, ps.isReadonly, ps.annotations));
@@ -16789,7 +16781,7 @@ var init_Schema = __esmMin((() => {
 		}
 		const iss = [];
 		for (const r of records) {
-			const { indexSignatures, propertySignatures } = record$2(r.key.ast, r.value.ast);
+			const { indexSignatures, propertySignatures } = record$1(r.key.ast, r.value.ast);
 			propertySignatures.forEach((ps) => pss.push(ps));
 			indexSignatures.forEach((is) => iss.push(is));
 		}
@@ -19962,7 +19954,7 @@ var init_esm = __esmMin((() => {
 	init_mergeStrategy();
 	init_metric();
 	init_boundaries();
-	init_hook$1();
+	init_hook();
 	init_key();
 	init_keyType();
 	init_label();
@@ -21023,10 +21015,7 @@ while :; do
       model="$(gtd next --json=model)"
       system="$(gtd next --json=system)"
       validate="$(gtd next --json=validate)"
-      context="$(gtd next --json=context)"
       log="$(gtd next --json=log)"
-      # Absolute, since the hook runs wherever the agent last cd'ed to.
-      case "$log" in /*) ;; *) log="$(git rev-parse --show-toplevel)/$log" ;; esac
       # \`model\` is a hint, not a model name — the bundled workflow ships
       # \`smart\` and \`base\`, which \`claude --model\` rejects. Resolve them
       # from your environment; unset, the hint is dropped and the agent runs
@@ -21035,18 +21024,6 @@ while :; do
         smart) model="\${GTD_LOOP_MODEL_SMART:-}" ;;
         base) model="\${GTD_LOOP_MODEL_BASE:-}" ;;
       esac
-      # The step's context limit, as a Claude Code hook after every tool
-      # call and before compacting. Past \`hard\` it stops the turn and
-      # appends why to the stop file, so we land nothing and stop too.
-      soft="$(printf '%s' "$context" | sed -n 's/.*"soft":\\([0-9.]*\\).*/\\1/p')"
-      hard="$(printf '%s' "$context" | sed -n 's/.*"hard":\\([0-9.]*\\).*/\\1/p')"
-      window="\${GTD_LOOP_CONTEXT_WINDOW:-}"
-      case "$model" in *'[1m]'* | *'[1M]'*) window="\${window:-1000000}" ;; esac
-      hook="gtd context-hook\${soft:+ --soft $soft}\${hard:+ --hard $hard}\${window:+ --window $window}"
-      hooks="[{\\"hooks\\":[{\\"type\\":\\"command\\",\\"command\\":\\"$hook\\"}]}]"
-      settings="{\\"hooks\\":{\\"PostToolUse\\":$hooks,\\"PreCompact\\":$hooks}}"
-      stop="$log.context-stop"
-      rm -f "$stop"
       # One turn, its prompt on stdin. The prompt embeds a full diff, so it
       # never goes on argv — argv is capped (~1 MB on macOS, and POSIX
       # guarantees only 4 KB, ARG_MAX), and a diff crosses that far sooner
@@ -21054,15 +21031,15 @@ while :; do
       # whether \`claude --resume\` re-applies the original session's is a
       # harness detail gtd cannot verify from outside. Its JSON envelope
       # goes to the log, and its \`total_cost_usd\` adds up into $cost. An
-      # \`is_error\` envelope (max turns, an error mid-turn) or one another
-      # hook stopped fails the turn even at exit 0: landing it would land
-      # the failure as work. Only a turn that never ran (no envelope: the
+      # \`is_error\` envelope (max turns, an error mid-turn) or one a hook
+      # stopped fails the turn even at exit 0: landing it would land the
+      # failure as work. Only a turn that never ran (no envelope: the
       # session flag was refused) is worth retrying under the other flag.
       turn() {
-        out="$(GTD_LOOP_CONTEXT_STOP_FILE="$stop" claude -p "$@" \\
+        out="$(claude -p "$@" \\
           \${model:+--model "$model"} \\
           \${system:+--system-prompt "$system"} \\
-          --settings "$settings" --output-format json \\
+          --output-format json \\
           --dangerously-skip-permissions 2>>"$log")" && ok=0 || ok=$?
         printf '%s\\n' "$out" >>"$log"
         case "$out" in *'"type":"result"'*) ran=true ;; *) ran=false ;; esac
@@ -21072,10 +21049,6 @@ while :; do
         usd="$(printf '%s\\n' "$out" | sed -n 's/.*"total_cost_usd":\\([0-9.eE+-]*\\).*/\\1/p' | tail -n 1)"
         [ -z "$usd" ] || cost="$(awk -v a="\${cost:-0}" -v b="$usd" 'BEGIN { printf "%.6f", a + b }')"
         [ "\${cost:-}" != 0.000000 ] || cost=
-        if [ -s "$stop" ]; then
-          cat "$stop" >&2
-          exit 1
-        fi
         return "$ok"
       }
       # Plain \`gtd next\` (not --json=content) renders the diff once.
@@ -21544,6 +21517,16 @@ way — an existing \`gtd-loop\` survives untouched beside the new
 \`gtd-door review [base]\`). When either is still present beside the suite,
 name it to the user as superseded and ask before removing it — never remove
 one unasked.
+
+An older \`gtd-build\` passed a \`gtd context-hook\` hook to every turn, and
+an older setup guide had it registered in Claude Code's own settings
+(\`PostToolUse\`/\`PreCompact\`). That command no longer exists: a hook
+still calling it fails on every tool call. Replace such a \`gtd-build\` as a
+differing file above, and look for a \`gtd context-hook\` entry in the user's
+Claude Code settings files (\`~/.claude/settings.json\`, the repository's
+\`.claude/settings.json\` and \`.claude/settings.local.json\`): name each file
+to the user, then remove that entry alone, leaving every other key
+byte-identical.
 `;
 const EDITOR_INTEGRATION = `
 ## Editor integration: offer it, don't bury it
@@ -21705,20 +21688,6 @@ const scope = async (scope, fn) => {
 		context.popScope();
 	}
 };
-/**
-* Mark the span `fn` covers as one named slice of the process. Lands no
-* commit, prefixes no step name, opens no memory scope.
-*/
-const slice = async (name, fn) => {
-	const context = ctx();
-	if (typeof context.enterSlice !== "function") return fn();
-	context.enterSlice(name);
-	try {
-		return await fn();
-	} finally {
-		context.leaveSlice?.();
-	}
-};
 const read = (path) => ctx().read(path);
 /** Every path in the tree matching `pattern` (`*` stays within a segment, `**` crosses them). */
 const glob = (pattern) => ctx().glob(pattern);
@@ -22299,7 +22268,6 @@ var flows_exports = /* @__PURE__ */ __exportAll({
 	sections: () => sections,
 	showScript: () => showScript,
 	skillsFor: () => skillsFor,
-	slice: () => slice,
 	start: () => start,
 	threads: () => threads,
 	vars: () => vars,
@@ -37502,470 +37470,440 @@ const accessShapeFault = (value) => {
 };
 const sameGlobs = (a, b) => a === void 0 || b === void 0 ? a === b : a.length === b.length && a.every((g, i) => g === b[i]);
 const sameAccess = (a, b) => sameGlobs(a?.read, b?.read) && sameGlobs(a?.write, b?.write);
-//#endregion
-//#region src/wire/constants.ts
-var renderFormat, ACCESS_REFUSAL;
-var init_constants = __esmMin((() => {
-	renderFormat = (fmt, ...args) => {
-		let i = 0;
-		return fmt.replace(/%s/g, () => args[i++] ?? "");
-	};
-	ACCESS_REFUSAL = "gtd land: this turn wrote outside its write access — revert these paths, then run `gtd land` again:";
-}));
-//#endregion
-//#region src/wire/ExitCodes.ts
-var init_ExitCodes = __esmMin((() => {}));
-//#endregion
-//#region src/wire/types.ts
-var init_types = __esmMin((() => {}));
+/** The plain-text twin of `OutcomeScript.ts`'s `printfLine`. Lives here so `src/wire/`'s encoders reach it without importing out of the leaf. */
+const renderFormat = (fmt, ...args) => {
+	let i = 0;
+	return fmt.replace(/%s/g, () => args[i++] ?? "");
+};
+/** The first line of the landing refusal for a turn that wrote outside its `write` access — a stable marker drivers and tests grep for. */
+const ACCESS_REFUSAL = "gtd land: this turn wrote outside its write access — revert these paths, then run `gtd land` again:";
 //#endregion
 //#region src/wire/Demand.ts
-var beatKindOf, stallDiagnosis, demandOf;
-var init_Demand = __esmMin((() => {
-	beatKindOf = (input) => {
-		if (input.stalled) return "stalled";
-		if (input.contentKind === "message" && input.dirty) return "capture";
-		return input.contentKind;
-	};
-	stallDiagnosis = (state, actor) => `stalled at "${state}": the last gtd(${actor}): ${state} turn landed an empty attempt, the tree is clean, and another dispatch would repeat it.\n\nTwo ways out:\n  - sharpen the step's prompt so the turn has something concrete to author\n  - pass allowEmpty: true to the step, so an empty turn completes it and the\n    flow decides what follows — finishing, or an escalation step after N\n    empty turns\n`;
-	demandOf = (input) => {
-		const { rendered, kind, session, validate } = input;
-		const content = kind === "stalled" ? stallDiagnosis(rendered.state, rendered.actor) : rendered.content;
-		const skills = rendered.skills !== void 0 && rendered.skills.length > 0 ? rendered.skills : void 0;
-		const access = rendered.access ?? {
-			read: null,
-			write: null
-		};
-		return kind === "prompt" ? {
-			kind,
-			content,
-			session,
-			validate,
-			skills,
-			access
-		} : {
-			kind,
-			content
-		};
+/**
+* The beat kind for a rest, in precedence order:
+*
+* 1. `stalled` — `Edge.ts`'s `stalledAt` verdict, passed in as a plain
+*    boolean (this module never resolves it itself). `stalledAt` already
+*    requires a clean tree, so this can never collide with `capture` below.
+* 2. `capture` — a `message` rest with a DIRTY tree: the human already
+*    acted; a driver lands it immediately.
+* 3. Otherwise, the content kind verbatim (`script`/`prompt`, or `message`
+*    on a clean tree).
+*/
+const beatKindOf = (input) => {
+	if (input.stalled) return "stalled";
+	if (input.contentKind === "message" && input.dirty) return "capture";
+	return input.contentKind;
+};
+/**
+* The `stalled` beat's own content: a diagnosis naming the stuck step and
+* the ways out. The first line is shaped so a stderr grep for
+* `stalled at "<state>"` stays a stable substring (see
+* `tests/integration/features/driver-doc.feature`).
+*/
+const stallDiagnosis = (state, actor) => `stalled at "${state}": the last gtd(${actor}): ${state} turn landed an empty attempt, the tree is clean, and another dispatch would repeat it.\n\nTwo ways out:\n  - sharpen the step's prompt so the turn has something concrete to author\n  - pass allowEmpty: true to the step, so an empty turn completes it and the\n    flow decides what follows — finishing, or an escalation step after N\n    empty turns\n`;
+/**
+* Assemble one `Demand` — the ONLY place a rest's resolved content becomes
+* `Demand.content` (`stallDiagnosis` at `kind === "stalled"`, the rendered
+* content otherwise), and the only place `session`/`validate`/`skills`/`access` are
+* attached, which the `prompt` variant's own type makes impossible to do at
+* any other kind.
+*/
+const demandOf = (input) => {
+	const { rendered, kind, session, validate } = input;
+	const content = kind === "stalled" ? stallDiagnosis(rendered.state, rendered.actor) : rendered.content;
+	const skills = rendered.skills !== void 0 && rendered.skills.length > 0 ? rendered.skills : void 0;
+	const access = rendered.access ?? {
+		read: null,
+		write: null
 	};
-}));
+	return kind === "prompt" ? {
+		kind,
+		content,
+		session,
+		validate,
+		skills,
+		access
+	} : {
+		kind,
+		content
+	};
+};
 //#endregion
 //#region src/wire/BeatStatus.ts
-var statusOf;
-var init_BeatStatus = __esmMin((() => {
-	statusOf = (input) => {
-		const { rendered, idle, initial, workflow, log, changes, next, cost, costByModel, approvals } = input;
-		return {
-			idle,
-			initial,
-			model: rendered.model,
-			system: rendered.system !== void 0 && rendered.system !== "" ? rendered.system : void 0,
-			context: rendered.context,
-			log,
-			state: rendered.state,
-			actor: rendered.actor,
-			workflow,
-			label: rendered.label,
-			memory: rendered.memory,
-			file: rendered.file,
-			mode: rendered.mode,
-			changes,
-			next,
-			cost,
-			costByModel,
-			judge: rendered.judge,
-			approvals
-		};
+/**
+* Assemble one `BeatStatus`. `system` is omitted (not just falsy) when its
+* rendered value is the empty string, unlike `model`: an empty
+* `--system-prompt ""` would silently delete the harness's own default
+* instead of failing loudly.
+*/
+const statusOf = (input) => {
+	const { rendered, idle, initial, workflow, log, changes, next, cost, costByModel, approvals } = input;
+	return {
+		idle,
+		initial,
+		model: rendered.model,
+		system: rendered.system !== void 0 && rendered.system !== "" ? rendered.system : void 0,
+		log,
+		state: rendered.state,
+		actor: rendered.actor,
+		workflow,
+		label: rendered.label,
+		memory: rendered.memory,
+		file: rendered.file,
+		mode: rendered.mode,
+		changes,
+		next,
+		cost,
+		costByModel,
+		judge: rendered.judge,
+		approvals
 	};
-}));
+};
 //#endregion
 //#region src/wire/BeatDocument.ts
-var nextField, assertNeverDemand, dispatchFieldsOf, beatDocument, renderBeatJson;
-var init_BeatDocument = __esmMin((() => {
-	init_constants();
-	nextField = (next) => next === null ? null : { target: next.target };
-	assertNeverDemand = (demand) => {
-		throw new Error(`unreachable demand: ${JSON.stringify(demand)}`);
-	};
-	dispatchFieldsOf = (demand) => {
-		switch (demand.kind) {
-			case "prompt": return {
-				session: demand.session,
-				validate: demand.validate,
-				skills: demand.skills,
-				access: demand.access
-			};
-			case "capture":
-			case "message":
-			case "script":
-			case "stalled": return {
-				session: void 0,
-				validate: void 0,
-				skills: void 0,
-				access: void 0
-			};
-			default: return assertNeverDemand(demand);
-		}
-	};
-	beatDocument = (demand, status) => {
-		const { session, validate, skills, access } = dispatchFieldsOf(demand);
-		const hasCost = status.cost > 0;
-		return {
-			schema: 1,
-			kind: demand.kind,
-			content: demand.content,
-			idle: status.idle,
-			initial: status.initial,
-			session,
-			model: status.model,
-			system: status.system,
-			context: status.context,
-			validate,
-			log: status.log,
-			state: status.state,
-			actor: status.actor,
-			workflow: status.workflow,
-			label: status.label,
-			memory: status.memory,
-			file: status.file,
-			mode: status.mode,
-			changes: status.changes,
-			next: nextField(status.next),
-			cost: hasCost ? status.cost : void 0,
-			costByModel: hasCost ? status.costByModel : void 0,
-			judge: status.judge,
-			skills,
-			access,
-			approvals: status.approvals
-		};
+/** `gtd next --json`'s `next` key — `null` when landing would commit nothing. */
+const nextField = (next) => next === null ? null : { target: next.target };
+/** Unreachable in a well-typed call — used as the `default` arm of an exhaustive switch over `Demand["kind"]`, so a future `BeatKind` member that isn't handled fails `tsc`, not just review. */
+const assertNeverDemand = (demand) => {
+	throw new Error(`unreachable demand: ${JSON.stringify(demand)}`);
+};
+/**
+* The ONE exhaustive switch translating a `Demand` into its wire
+* `session`/`validate`/`skills`/`access` set — only the `prompt` variant carries
+* any of them, and every other member is listed explicitly (not a
+* `default:` fallthrough) so adding a sixth `BeatKind` without adding its
+* case here fails `tsc` at the `assertNeverDemand` call, not silently
+* falling through to "no session."
+*/
+const dispatchFieldsOf = (demand) => {
+	switch (demand.kind) {
+		case "prompt": return {
+			session: demand.session,
+			validate: demand.validate,
+			skills: demand.skills,
+			access: demand.access
+		};
+		case "capture":
+		case "message":
+		case "script":
+		case "stalled": return {
+			session: void 0,
+			validate: void 0,
+			skills: void 0,
+			access: void 0
+		};
+		default: return assertNeverDemand(demand);
+	}
+};
+/**
+* Flatten a `Demand` plus its `BeatStatus` into the single 25-key document
+* `gtd next --json` emits — the ONLY place the two are joined. `cost`/
+* `costByModel` are omitted together, exactly when no cost was recorded
+* (`cost <= 0`).
+*/
+const beatDocument = (demand, status) => {
+	const { session, validate, skills, access } = dispatchFieldsOf(demand);
+	const hasCost = status.cost > 0;
+	return {
+		schema: 1,
+		kind: demand.kind,
+		content: demand.content,
+		idle: status.idle,
+		initial: status.initial,
+		session,
+		model: status.model,
+		system: status.system,
+		validate,
+		log: status.log,
+		state: status.state,
+		actor: status.actor,
+		workflow: status.workflow,
+		label: status.label,
+		memory: status.memory,
+		file: status.file,
+		mode: status.mode,
+		changes: status.changes,
+		next: nextField(status.next),
+		cost: hasCost ? status.cost : void 0,
+		costByModel: hasCost ? status.costByModel : void 0,
+		judge: status.judge,
+		skills,
+		access,
+		approvals: status.approvals
 	};
-	renderBeatJson = (document) => JSON.stringify(document) + "\n";
-}));
+};
+const renderBeatJson = (document) => JSON.stringify(document) + "\n";
 //#endregion
 //#region src/wire/BeatPlain.ts
-var breakdownIsInformative, costStatusLines, pendingStatusLines, nextStatusLine, definedFields, beatHeaderLines, SCRIPT_INSTRUCTION, CAPTURE_INSTRUCTION, DEMAND_BRIEFING, selfValidateInstruction, renderBeatPlain;
-var init_BeatPlain = __esmMin((() => {
-	init_constants();
-	breakdownIsInformative = (byModel) => byModel.length > 1 || byModel.length === 1 && byModel[0].model !== "unspecified";
-	costStatusLines = (cost, byModel) => {
-		if (cost <= 0) return [];
-		const lines = [`Cost: ${cost}`];
-		if (breakdownIsInformative(byModel)) for (const m of byModel) lines.push(`  ${m.model}: ${m.cost}`);
-		return lines;
-	};
-	pendingStatusLines = (statusChanges) => statusChanges.length === 0 ? ["Pending: (clean)"] : ["Pending:", ...statusChanges.map((c) => `  ${c.status} ${c.path}`)];
-	nextStatusLine = (next) => next === null ? "Next: (nothing would land)" : `Next: → ${next.target}`;
-	definedFields = (entries) => {
-		const result = {};
-		for (const [key, value] of entries) if (value !== void 0) result[key] = value;
-		return result;
-	};
-	beatHeaderLines = (document) => {
-		const optional = definedFields([
-			["Label", document.label],
-			["Model", document.model],
-			["Memory", document.memory],
-			["File", document.file],
-			["Mode", document.mode]
-		]);
-		return [
-			`State: ${document.state}`,
-			`Awaits: ${document.actor}`,
-			`Workflow: ${document.workflow}`,
-			...Object.entries(optional).map(([key, value]) => `${key}: ${value}`),
-			...costStatusLines(document.cost ?? 0, document.costByModel ?? []),
-			...pendingStatusLines(document.changes),
-			nextStatusLine(document.next)
-		];
-	};
-	SCRIPT_INSTRUCTION = "Run this script:";
-	CAPTURE_INSTRUCTION = "The edit is already made — run `gtd land` to land it.";
-	DEMAND_BRIEFING = {
-		capture: {
-			instructionLine: CAPTURE_INSTRUCTION,
-			suppressHeader: false
-		},
-		message: {
-			instructionLine: void 0,
-			suppressHeader: false
-		},
-		script: {
-			instructionLine: SCRIPT_INSTRUCTION,
-			suppressHeader: false
-		},
-		stalled: {
-			instructionLine: void 0,
-			suppressHeader: false
-		},
-		prompt: {
-			instructionLine: void 0,
-			suppressHeader: true
-		}
-	};
-	selfValidateInstruction = (command, file) => `\nBefore finishing your turn, run \`${command}\` — it checks ${file} — and fix every violation it reports until it exits cleanly. Do not finish while it still reports violations.\n`;
-	renderBeatPlain = (document, selfValidateCommand) => {
-		const content = document.content.endsWith("\n") ? document.content : document.content + "\n";
-		const briefing = DEMAND_BRIEFING[document.kind];
-		if (briefing.suppressHeader) return selfValidateCommand !== void 0 && document.file !== void 0 ? content + selfValidateInstruction(selfValidateCommand, document.file) : content;
-		const body = beatHeaderLines(document).join("\n") + "\n\n" + content;
-		return briefing.instructionLine !== void 0 ? `${briefing.instructionLine}\n` + body : body;
-	};
-}));
+/**
+* True when the per-model breakdown adds information beyond the `Cost:`
+* total: more than one model, or a single model that carries an actual
+* `--model` tag (a lone `unspecified` bucket just restates the total, so
+* it's suppressed).
+*/
+const breakdownIsInformative = (byModel) => byModel.length > 1 || byModel.length === 1 && byModel[0].model !== "unspecified";
+const costStatusLines = (cost, byModel) => {
+	if (cost <= 0) return [];
+	const lines = [`Cost: ${cost}`];
+	if (breakdownIsInformative(byModel)) for (const m of byModel) lines.push(`  ${m.model}: ${m.cost}`);
+	return lines;
+};
+const pendingStatusLines = (statusChanges) => statusChanges.length === 0 ? ["Pending: (clean)"] : ["Pending:", ...statusChanges.map((c) => `  ${c.status} ${c.path}`)];
+const nextStatusLine = (next) => next === null ? "Next: (nothing would land)" : `Next: → ${next.target}`;
+/** Builds `{[key]: value}` for each entry whose value isn't `undefined` — the shared "omit absent optional fields" shape the header uses. */
+const definedFields = (entries) => {
+	const result = {};
+	for (const [key, value] of entries) if (value !== void 0) result[key] = value;
+	return result;
+};
+/**
+* The header block's own lines — `State:`/`Awaits:`/`Workflow:`/optional `Label:`/
+* `Model:`/`Memory:`/`File:`/`Mode:`/`Cost:`(+breakdown)/`Pending:`/`Next:`,
+* in that order. Used by `renderBeatPlain`'s header-showing kinds below.
+*/
+const beatHeaderLines = (document) => {
+	const optional = definedFields([
+		["Label", document.label],
+		["Model", document.model],
+		["Memory", document.memory],
+		["File", document.file],
+		["Mode", document.mode]
+	]);
+	return [
+		`State: ${document.state}`,
+		`Awaits: ${document.actor}`,
+		`Workflow: ${document.workflow}`,
+		...Object.entries(optional).map(([key, value]) => `${key}: ${value}`),
+		...costStatusLines(document.cost ?? 0, document.costByModel ?? []),
+		...pendingStatusLines(document.changes),
+		nextStatusLine(document.next)
+	];
+};
+/**
+* One entry per `BeatKind`, typed as `Record<BeatKind, DemandBriefing>` so
+* the object literal itself is exhaustive: adding or removing a `BeatKind`
+* member without updating this map fails `tsc`, the same guarantee
+* `dispatchFieldsOf`'s switch (`BeatDocument.ts`) gives the JSON side. Exported
+* so the one cross-cutting exhaustiveness test (`BeatDocument.test.ts`) can
+* assert against it directly, rather than re-deriving it from
+* `renderBeatPlain`'s output. Replaces the old `renderBeatPlain`'s hand-written
+* `if (kind === "script") … if (kind === "capture") …` pair.
+*/
+const DEMAND_BRIEFING = {
+	capture: {
+		instructionLine: "The edit is already made — run `gtd land` to land it.",
+		suppressHeader: false
+	},
+	message: {
+		instructionLine: void 0,
+		suppressHeader: false
+	},
+	script: {
+		instructionLine: "Run this script:",
+		suppressHeader: false
+	},
+	stalled: {
+		instructionLine: void 0,
+		suppressHeader: false
+	},
+	prompt: {
+		instructionLine: void 0,
+		suppressHeader: true
+	}
+};
+/**
+* The self-validation instruction appended to a `prompt` beat's plain output
+* only — a structured (`--json`) driver runs the `validate` field
+* itself instead. Advisory either way: `gtd land` refuses a turn whose
+* steering file is invalid regardless of whether this was followed.
+*/
+const selfValidateInstruction = (command, file) => `\nBefore finishing your turn, run \`${command}\` — it checks ${file} — and fix every violation it reports until it exits cleanly. Do not finish while it still reports violations.\n`;
+/**
+* `gtd next`'s plain-text encoding, driven by `DEMAND_BRIEFING`. At
+* `kind === "prompt"` the status header is suppressed and only `content`
+* plus the self-validation instruction is emitted — those bytes ARE the
+* agent's input, so gtd's own bookkeeping (state name, edges, pending
+* changes) must not be prefixed onto it. Every other kind gets the header
+* plus its instruction line, since its plain output is read by a human or
+* driver, never an agent. `selfValidateCommand` is already resolved; this
+* function never resolves it itself.
+*/
+const renderBeatPlain = (document, selfValidateCommand) => {
+	const content = document.content.endsWith("\n") ? document.content : document.content + "\n";
+	const briefing = DEMAND_BRIEFING[document.kind];
+	if (briefing.suppressHeader) return selfValidateCommand !== void 0 && document.file !== void 0 ? content + selfValidateInstruction(selfValidateCommand, document.file) : content;
+	const body = beatHeaderLines(document).join("\n") + "\n\n" + content;
+	return briefing.instructionLine !== void 0 ? `${briefing.instructionLine}\n` + body : body;
+};
 //#endregion
 //#region src/wire/Land.ts
-var landFields, renderLandJson, FMT_NOOP, FMT_LAND_PROSE, noopText, landProseText, renderLandPlain;
-var init_Land = __esmMin((() => {
-	init_constants();
-	landFields = (input) => ({
-		schema: 1,
-		script: input.script,
-		settled: input.settled,
-		idle: input.idle,
-		state: input.state,
-		subject: input.subject,
-		cost: input.cost,
-		model: input.model
-	});
-	renderLandJson = (fields) => JSON.stringify(fields) + "\n";
-	FMT_NOOP = "nothing to do at \"%s\"\n";
-	FMT_LAND_PROSE = "commit everything with this message: %s\n";
-	noopText = (state) => renderFormat(FMT_NOOP, state);
-	landProseText = (subject) => renderFormat(FMT_LAND_PROSE, subject);
-	renderLandPlain = (fields, command = "land") => fields.subject !== null ? `${landProseText(fields.subject).trimEnd()}\n(run \`gtd ${command} --json=script | sh\` to get the landing script)\n` : noopText(fields.state);
-}));
+/** Assembles one `gtd land` result's fields in `LandFields`' declared order — the ONLY place `gtd land --json`'s wire shape is built. */
+const landFields = (input) => ({
+	schema: 1,
+	script: input.script,
+	settled: input.settled,
+	idle: input.idle,
+	state: input.state,
+	subject: input.subject,
+	cost: input.cost,
+	model: input.model
+});
+const renderLandJson = (fields) => JSON.stringify(fields) + "\n";
+const FMT_NOOP = "nothing to do at \"%s\"\n";
+const FMT_LAND_PROSE = "commit everything with this message: %s\n";
+/** `nothing to do at "<state>"` — a no-op step's plain-text line, and the text a print-only script's own `printf` carries. */
+const noopText = (state) => renderFormat(FMT_NOOP, state);
+/** `commit everything with this message: <subject>` — plain `gtd land`'s own stdout at a pending diff (no script); `--json` keeps emitting the script itself, unaffected. */
+const landProseText = (subject) => renderFormat(FMT_LAND_PROSE, subject);
+/**
+* `gtd land`'s plain-text encoding — names the commit subject at a real
+* landing and points at `--json=script`, since the script itself is
+* unreachable from plain output; prints the existing no-op note otherwise.
+* `command` names the invocation to point at — `"land"` by default, but
+* `gtd judge answer` (the only other caller of `planLanding`/`landFields`)
+* passes its own two-word name so the hint stays runnable verbatim.
+*/
+const renderLandPlain = (fields, command = "land") => fields.subject !== null ? `${landProseText(fields.subject).trimEnd()}\n(run \`gtd ${command} --json=script | sh\` to get the landing script)\n` : noopText(fields.state);
 //#endregion
 //#region src/wire/Judge.ts
-var judgeJson;
-var init_Judge = __esmMin((() => {
-	init_constants();
-	judgeJson = (state, questions) => JSON.stringify({
-		schema: 1,
-		state,
-		questions
-	});
-}));
+const judgeJson = (state, questions) => JSON.stringify({
+	schema: 1,
+	state,
+	questions
+});
 //#endregion
 //#region src/wire/Select.ts
-var toSelection, NOT_FOUND, ARRAY_INDEX, resolveSegment, selectPath;
-var init_Select = __esmMin((() => {
-	toSelection = (value) => {
-		if (Array.isArray(value)) return {
-			kind: "value",
-			text: value.map((entry) => JSON.stringify(entry)).join("\n")
-		};
-		if (typeof value === "object") return {
-			kind: "value",
-			text: JSON.stringify(value)
-		};
-		return {
-			kind: "value",
-			text: String(value)
-		};
+/**
+* Renders a fully-walked leaf value: scalars/booleans stringify directly,
+* arrays become one `JSON.stringify` per entry, newline-joined.
+* `selectPath`'s loop already returns `absent` for `undefined`/`null` after
+* every segment (including the last), so neither ever reaches here.
+*/
+const toSelection = (value) => {
+	if (Array.isArray(value)) return {
+		kind: "value",
+		text: value.map((entry) => JSON.stringify(entry)).join("\n")
 	};
-	NOT_FOUND = Symbol("not-found");
-	ARRAY_INDEX = /^\d+$/;
-	resolveSegment = (current, segment) => {
-		if (Array.isArray(current)) return ARRAY_INDEX.test(segment) && Number(segment) < current.length ? current[Number(segment)] : NOT_FOUND;
-		if (typeof current === "object" && current !== null) {
-			const record = current;
-			return Object.prototype.hasOwnProperty.call(record, segment) ? record[segment] : NOT_FOUND;
-		}
-		return NOT_FOUND;
+	if (typeof value === "object") return {
+		kind: "value",
+		text: JSON.stringify(value)
 	};
-	selectPath = (fields, path) => {
-		try {
-			let current = fields;
-			for (const segment of path.split(".")) {
-				current = resolveSegment(current, segment);
-				if (current === NOT_FOUND) return {
-					kind: "unknown",
-					path
-				};
-				if (current === void 0 || current === null) return { kind: "absent" };
-			}
-			return toSelection(current);
-		} catch {
-			return {
+	return {
+		kind: "value",
+		text: String(value)
+	};
+};
+/** A segment that resolves to no key at all (missing from an object, out-of-range or non-numeric against an array) — distinct from a present key holding `undefined`. */
+const NOT_FOUND = Symbol("not-found");
+/** An all-digits segment (`"0"`, `"12"`) — the only shape an array segment resolves against. */
+const ARRAY_INDEX = /^\d+$/;
+/**
+* One step of the walk: looks `segment` up on `current`, or reports
+* `NOT_FOUND` for a key that was never there (a primitive has no keys).
+* Against an array, only an all-digits segment resolves — an in-range index
+* (`skills.0` reads the first declared skill), never a non-index own key
+* (`length`/`map`/every other inherited array member stays `NOT_FOUND`).
+* Against an object, presence is an OWN-property test
+* (`Object.prototype.hasOwnProperty`), never the `in` operator — `in` walks
+* the prototype chain, so it would resolve inherited members
+* (`constructor`, `toString`, `hasOwnProperty`, `valueOf`, ...) as real
+* document fields.
+*/
+const resolveSegment = (current, segment) => {
+	if (Array.isArray(current)) return ARRAY_INDEX.test(segment) && Number(segment) < current.length ? current[Number(segment)] : NOT_FOUND;
+	if (typeof current === "object" && current !== null) {
+		const record = current;
+		return Object.prototype.hasOwnProperty.call(record, segment) ? record[segment] : NOT_FOUND;
+	}
+	return NOT_FOUND;
+};
+/**
+* Walks `fields` by dotted key path. Never throws — any unwalkable shape
+* (a primitive mid-path, an out-of-range or non-numeric array segment)
+* degrades to `unknown`, and a present-but-`undefined` value anywhere along
+* the path short-circuits the whole remaining path to `absent` rather than
+* reporting a key that was never actually missing.
+*/
+const selectPath = (fields, path) => {
+	try {
+		let current = fields;
+		for (const segment of path.split(".")) {
+			current = resolveSegment(current, segment);
+			if (current === NOT_FOUND) return {
 				kind: "unknown",
 				path
 			};
+			if (current === void 0 || current === null) return { kind: "absent" };
 		}
-	};
-}));
+		return toSelection(current);
+	} catch {
+		return {
+			kind: "unknown",
+			path
+		};
+	}
+};
 //#endregion
 //#region src/wire/Sessions.ts
-var GTD_SESSION_NAMESPACE, toBytes, toUuidString, uuidv5, resolveSession;
-var init_Sessions = __esmMin((() => {
-	GTD_SESSION_NAMESPACE = "ca4be249-805e-41c1-8b6a-75a11c011e25";
-	toBytes = (uuid) => Buffer.from(uuid.replace(/-/g, ""), "hex");
-	toUuidString = (bytes) => {
-		const hex = bytes.toString("hex");
-		return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
-	};
-	uuidv5 = (namespace, name) => {
-		const bytes = createHash("sha1").update(toBytes(namespace)).update(name, "utf8").digest().subarray(0, 16);
-		bytes[6] = bytes[6] & 15 | 80;
-		bytes[8] = bytes[8] & 63 | 128;
-		return toUuidString(bytes);
-	};
-	resolveSession = (memoryKey, resume, mint = randomUUID) => memoryKey === void 0 ? {
-		sessionId: mint(),
-		resume: false
-	} : {
-		sessionId: uuidv5(GTD_SESSION_NAMESPACE, memoryKey),
-		resume
-	};
-}));
+/** Fixed forever — every derived session id descends from this one constant. */
+const GTD_SESSION_NAMESPACE = "ca4be249-805e-41c1-8b6a-75a11c011e25";
+const toBytes = (uuid) => Buffer.from(uuid.replace(/-/g, ""), "hex");
+const toUuidString = (bytes) => {
+	const hex = bytes.toString("hex");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+};
+/**
+* UUIDv5 (RFC 4122 §4.3), hand-rolled over `node:crypto`'s SHA-1 rather than
+* a dependency — correctness is checked against the RFC's own DNS-namespace
+* test vector in `Sessions.test.ts`.
+*/
+const uuidv5 = (namespace, name) => {
+	const bytes = createHash("sha1").update(toBytes(namespace)).update(name, "utf8").digest().subarray(0, 16);
+	bytes[6] = bytes[6] & 15 | 80;
+	bytes[8] = bytes[8] & 63 | 128;
+	return toUuidString(bytes);
+};
+/**
+* Resolves a `prompt` rest's session id: with no `memoryKey` there's no
+* history to derive a stable id from, so it mints an ephemeral one and forces
+* `resume: false`; otherwise the id is deterministic (`uuidv5`) and `resume`
+* is passed through as given.
+*/
+const resolveSession = (memoryKey, resume, mint = randomUUID) => memoryKey === void 0 ? {
+	sessionId: mint(),
+	resume: false
+} : {
+	sessionId: uuidv5(GTD_SESSION_NAMESPACE, memoryKey),
+	resume
+};
 //#endregion
 //#region src/wire/Glob.ts
-var ESCAPE_RE, compile, globMatches;
-var init_Glob = __esmMin((() => {
-	ESCAPE_RE = /[.+^${}()|[\]\\?]/g;
-	compile = (glob) => {
-		let pattern = "^";
-		let i = 0;
-		while (i < glob.length) {
-			const char = glob[i];
-			if (char !== "*") {
-				pattern += char.replace(ESCAPE_RE, "\\$&");
-				i += 1;
-			} else if (glob[i + 1] !== "*") {
-				pattern += "[^/]*";
-				i += 1;
-			} else if (glob[i + 2] === "/") {
-				pattern += "(?:.*/)?";
-				i += 3;
-			} else {
-				pattern += ".*";
-				i += 2;
-			}
-		}
-		return new RegExp(`${pattern}$`, "s");
-	};
-	globMatches = (path, glob) => compile(glob).test(path);
-}));
-//#endregion
-//#region src/wire/Slices.ts
-var slicesDocument, renderSlicesJson;
-var init_Slices = __esmMin((() => {
-	init_constants();
-	slicesDocument = (slices) => ({
-		schema: 1,
-		slices: slices.map(({ name, base, tip, closed }) => ({
-			name,
-			base,
-			tip,
-			closed
-		}))
-	});
-	renderSlicesJson = (document) => JSON.stringify(document) + "\n";
-}));
-//#endregion
-//#region src/wire/ContextLimit.ts
-var DEFAULT_CONTEXT_LIMIT, DEFAULT_WINDOW, LONG_WINDOW, contextWindowFor, parseContextWindow, CONTEXT_STOP_FILE_ENV, contextShapeFault, contextLimitFault, record$1, count, usageTokens, transcriptTokens, CONTEXT_LIMIT_MARKER, percent, contextHook, hookOutput;
-var init_ContextLimit = __esmMin((() => {
-	DEFAULT_CONTEXT_LIMIT = {
-		soft: .6,
-		hard: .7
-	};
-	DEFAULT_WINDOW = 2e5;
-	LONG_WINDOW = 1e6;
-	contextWindowFor = (model) => model !== void 0 && /\[1m\]/i.test(model) ? LONG_WINDOW : DEFAULT_WINDOW;
-	parseContextWindow = (raw) => {
-		const n = Number(raw);
-		return raw !== void 0 && raw.trim() !== "" && Number.isInteger(n) && n > 0 ? n : void 0;
-	};
-	CONTEXT_STOP_FILE_ENV = "GTD_LOOP_CONTEXT_STOP_FILE";
-	contextShapeFault = (limit) => {
-		if (typeof limit !== "object" || limit === null || Array.isArray(limit)) return `context must be an object { soft, hard }, got ${JSON.stringify(limit)}`;
-		const unknown = Object.keys(limit).filter((key) => key !== "soft" && key !== "hard");
-		if (unknown.length > 0) return `unknown key(s) ${unknown.join(", ")} in context`;
-		const shares = limit;
-		for (const key of ["soft", "hard"]) {
-			const value = shares[key];
-			if (value === void 0) continue;
-			if (typeof value !== "number" || !(value > 0 && value <= 1)) return `context.${key} must be a share of the context window in (0, 1], got ${JSON.stringify(value)}`;
-		}
-	};
-	contextLimitFault = (limit) => {
-		const shape = contextShapeFault(limit);
-		if (shape !== void 0) return shape;
-		const shares = limit;
-		const soft = shares.soft ?? DEFAULT_CONTEXT_LIMIT.soft;
-		const hard = shares.hard ?? DEFAULT_CONTEXT_LIMIT.hard;
-		return soft < hard ? void 0 : `context.soft (${soft}) must be below context.hard (${hard})`;
-	};
-	record$1 = (value) => typeof value === "object" && value !== null ? value : void 0;
-	count = (value) => typeof value === "number" && value > 0 ? value : 0;
-	usageTokens = (usage) => {
-		const u = record$1(usage);
-		if (u === void 0) return void 0;
-		return count(u["input_tokens"]) + count(u["cache_read_input_tokens"]) + count(u["cache_creation_input_tokens"]);
-	};
-	transcriptTokens = (transcript) => {
-		const lines = transcript.split("\n");
-		for (let i = lines.length - 1; i >= 0; i--) {
-			const line = lines[i].trim();
-			if (line === "") continue;
-			let entry;
-			try {
-				entry = JSON.parse(line);
-			} catch {
-				continue;
-			}
-			if (record$1(entry)?.["type"] !== "assistant") continue;
-			const tokens = usageTokens(record$1(record$1(entry)?.["message"])?.["usage"]);
-			if (tokens !== void 0) return tokens;
+const ESCAPE_RE = /[.+^${}()|[\]\\?]/g;
+const compile = (glob) => {
+	let pattern = "^";
+	let i = 0;
+	while (i < glob.length) {
+		const char = glob[i];
+		if (char !== "*") {
+			pattern += char.replace(ESCAPE_RE, "\\$&");
+			i += 1;
+		} else if (glob[i + 1] !== "*") {
+			pattern += "[^/]*";
+			i += 1;
+		} else if (glob[i + 2] === "/") {
+			pattern += "(?:.*/)?";
+			i += 3;
+		} else {
+			pattern += ".*";
+			i += 2;
 		}
-	};
-	CONTEXT_LIMIT_MARKER = "gtd: context limit";
-	percent = (share) => `${Math.round(share * 100)}%`;
-	contextHook = (input) => {
-		const { event, tokens, window, limit } = input;
-		if (event === "PreCompact") return {
-			kind: "hard",
-			stopReason: `${CONTEXT_LIMIT_MARKER}: the context is about to be compacted — the run is too big for one turn`
-		};
-		if (tokens === void 0) return void 0;
-		const used = `${tokens} of ${window} tokens`;
-		if (tokens >= limit.hard * window) return {
-			kind: "hard",
-			stopReason: `${CONTEXT_LIMIT_MARKER}: ${used}, past the ${percent(limit.hard)} hard limit`
-		};
-		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. Where your instructions name a file for that note, write it there too.`
-		};
-	};
-	hookOutput = (decision) => decision.kind === "soft" ? {
-		decision: "block",
-		reason: decision.reason
-	} : {
-		continue: false,
-		stopReason: decision.stopReason
-	};
-}));
-//#endregion
-//#region src/wire/index.ts
-var init_wire = __esmMin((() => {
-	init_constants();
-	init_ExitCodes();
-	init_types();
-	init_Demand();
-	init_BeatStatus();
-	init_BeatDocument();
-	init_BeatPlain();
-	init_Land();
-	init_Judge();
-	init_Select();
-	init_Sessions();
-	init_Glob();
-	init_Slices();
-	init_ContextLimit();
-}));
+	}
+	return new RegExp(`${pattern}$`, "s");
+};
+const globMatches = (path, glob) => compile(glob).test(path);
 //#endregion
 //#region src/replay/RefName.ts
-init_wire();
 const FORBIDDEN = /[\u0000- \u007f~^:?*[\\]/;
 /** Why `name` cannot be (part of) a git ref name, or `undefined` when it can. */
 const refNameFault = (name) => {
@@ -37981,32 +37919,6 @@ const refNameFault = (name) => {
 	}
 };
 //#endregion
-//#region src/replay/Slices.ts
-const IMPLICIT_SLICE = "main";
-/** Same shape as mark()'s name rule; kept local so @pmelab/gtd/flows publishes no regex. */
-const SLICE_NAME = /^[a-z][a-z0-9-]*$/;
-/**
-* Folds boundaries into ranges: each kept span's base is the previous kept
-* span's `leftAt`, so a gap before a span belongs to it, and the last span
-* runs to the episode tip. A closed span that landed nothing is dropped.
-*/
-const sliceRanges = (spans, episode) => {
-	if (spans.some((s) => s.enteredAt === "" || s.leftAt === "")) throw new Error("sliceRanges: a pending turn's \"\" hash is not a commit");
-	const kept = spans.filter((s) => s.leftAt === void 0 || s.enteredAt !== s.leftAt);
-	if (kept.length === 0) return [{
-		name: IMPLICIT_SLICE,
-		base: episode.base,
-		tip: episode.tip,
-		open: true
-	}];
-	return kept.map((s, i) => ({
-		name: s.name,
-		base: i === 0 ? episode.base : kept[i - 1].leftAt ?? episode.base,
-		tip: i === kept.length - 1 ? episode.tip : s.leftAt ?? episode.tip,
-		open: i === kept.length - 1
-	}));
-};
-//#endregion
 //#region src/replay/Tree.ts
 const treeFromRecord = (files) => ({
 	paths: () => Object.keys(files).sort(),
@@ -38313,15 +38225,6 @@ const budgeted = (evidence, budgetBytes) => {
 		truncated
 	};
 };
-const scopeLabel = (chain) => {
-	const path = chain.flatMap((o) => o.name === void 0 ? [] : [o.name]).join(".");
-	if (chain.at(-1)?.name !== void 0) return `scope "${path}"`;
-	return path === "" ? "an unnamed scope" : `an unnamed scope inside "${path}"`;
-};
-const inheritedContext = (layers) => layers.reduce((merged, layer) => layer === void 0 ? merged : {
-	...merged,
-	...Object.fromEntries(Object.entries(layer).filter(([, value]) => value !== void 0))
-}, void 0);
 const sameSkills = (a, b) => (a?.length ?? 0) === (b?.length ?? 0) && (a ?? []).every((skill, i) => skill === b?.[i]);
 const samePersona = (a, b) => a.model === b.model && a.system === b.system && sameSkills(a.skills, b.skills) && sameAccess(a.access, b.access);
 /**
@@ -38341,7 +38244,6 @@ const KNOWN_OPTIONS = {
 		...STEERING_OPTIONS,
 		"model",
 		"system",
-		"context",
 		"allowEmpty",
 		"keep"
 	]),
@@ -38386,7 +38288,6 @@ const replay = async (input) => {
 	const keptTips = /* @__PURE__ */ new Map();
 	let landed;
 	const marks = [];
-	const slices = [];
 	let outcome;
 	let signal;
 	const settled = new Promise((resolve) => {
@@ -38456,13 +38357,11 @@ const replay = async (input) => {
 				if (s.model !== void 0) persona.model = s.model;
 				if (s.system !== void 0) persona.system = s.system;
 			}
-			const context = inheritedContext([...scopes.map((s) => s.context), request.options.context]);
 			return {
 				...request,
 				options: {
 					...persona,
-					...request.options,
-					...context === void 0 ? {} : { context }
+					...request.options
 				}
 			};
 		}
@@ -38596,31 +38495,14 @@ const replay = async (input) => {
 			rest: step,
 			trace,
 			landed,
-			marks,
-			slices: slices.map((s) => ({ ...s }))
+			marks
 		});
 		return landPending(step, input.pending);
 	};
-	const scopeContextFault = () => {
-		for (const [i, s] of scopes.entries()) {
-			const fault = s.context === void 0 ? void 0 : contextShapeFault(s.context);
-			if (fault !== void 0) return `the context of ${scopeLabel(scopes.slice(0, i + 1))}: ${fault}`;
-		}
-	};
-	const resolvedContextFault = (request) => {
-		const own = request.options.context;
-		const layered = scopeContextFault() ?? (own === void 0 ? void 0 : contextShapeFault(own));
-		if (layered !== void 0) return layered;
-		const resolved = resolve(request);
-		const context = resolved.kind === "agent" ? resolved.options.context : void 0;
-		return context === void 0 ? void 0 : contextLimitFault(context);
-	};
 	const requestFault = (request) => {
 		if (request.kind === "run" && typeof request.body !== "string") return `gtd: step "${scoped(request.name)}": a run() body is a shell script string — decide in flow code, then render the script (see checkScript and friends)`;
 		if (request.kind !== "agent") return void 0;
 		const name = scoped(request.name);
-		const contextFault = resolvedContextFault(request);
-		if (contextFault !== void 0) return `gtd: step "${name}": ${contextFault}`;
 		if (request.options.keep === true) {
 			if (request.options.allowEmpty === true) return `gtd: step "${name}": keep: true cannot be combined with allowEmpty — a turn that changes nothing has nothing to keep`;
 			const refFault = name.includes("/") ? "it contains \"/\"" : refNameFault(name);
@@ -38652,8 +38534,7 @@ const replay = async (input) => {
 		via,
 		trace,
 		landed,
-		marks,
-		slices: slices.map((s) => ({ ...s }))
+		marks
 	};
 	const changesSince = (hash) => {
 		const tree = treeAt(hash);
@@ -38678,31 +38559,6 @@ const replay = async (input) => {
 			scopes.pop();
 			scopeCallIds.pop();
 		},
-		enterSlice: (name) => {
-			if (outcome !== void 0) return;
-			const fail = (message) => {
-				finish({
-					kind: "failed",
-					message
-				});
-				throw new Stop();
-			};
-			if (typeof name !== "string" || !SLICE_NAME.test(name)) fail(`gtd: slice "${name}": name must match ${SLICE_NAME}`);
-			if (name === "main") fail(`gtd: slice "${IMPLICIT_SLICE}" is reserved for the implicit slice`);
-			const open = slices.find((s) => s.leftAt === void 0);
-			if (open !== void 0) fail(`gtd: slice "${name}" is entered inside slice "${open.name}" — slices do not nest`);
-			if (slices.some((s) => s.name === name)) fail(`gtd: slice "${name}" is entered twice in this episode — a loop must sit inside its slice`);
-			slices.push({
-				name,
-				enteredAt: position.hash,
-				leftAt: void 0
-			});
-		},
-		leaveSlice: () => {
-			if (outcome !== void 0) return;
-			const open = slices.find((s) => s.leftAt === void 0);
-			if (open !== void 0) open.leftAt = position.hash;
-		},
 		read: (path) => position.tree.read(path),
 		glob: (pattern) => position.tree.paths().filter((path) => globMatches(path, pattern)),
 		changes: () => changesBetween(previousPosition.tree, position.tree),
@@ -39781,7 +39637,6 @@ const planStep = (snapshot, opts = {}) => {
 };
 //#endregion
 //#region src/step/accessRefusal.ts
-init_wire();
 /**
 * The landing refusal for changes outside `write`, or `undefined` when every
 * path is allowed. `null` is unrestricted. The message is the fix prompt: gtd
@@ -39881,14 +39736,12 @@ const resolveBase = (commandLabel, value) => gen(function* () {
 });
 //#endregion
 //#region src/step/strayPaths.ts
-init_wire();
 /** Globs use the `access.write` dialect (`globMatches`). */
 const strayPaths = (touched, allow) => touched.filter((path) => !allow.some((glob) => globMatches(path, glob))).sort();
 //#endregion
 //#region src/edge/Edge.ts
 init_esm();
 init_steering();
-init_wire();
 const EMPTY_TREE$1 = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 const ACTORS = /* @__PURE__ */ new Set([
 	"agent",
@@ -40241,10 +40094,6 @@ const commonOf = (step) => {
 		...optional("mode", options.mode)
 	};
 };
-const stepContext = (context) => context === void 0 ? void 0 : {
-	...optional("soft", context.soft),
-	...optional("hard", context.hard)
-};
 const promptDef = (common, request, skills, access) => ({
 	...common,
 	kind: "prompt",
@@ -40253,7 +40102,6 @@ const promptDef = (common, request, skills, access) => ({
 	...optional("system", request.options.system),
 	...optional("allowEmpty", request.options.allowEmpty),
 	...optional("keep", request.options.keep),
-	...optional("context", stepContext(request.options.context)),
 	...optional("skills", skills),
 	...optional("access", access)
 });
@@ -40317,8 +40165,7 @@ const hintsOf = (def) => ({
 	...optional("system", def.system),
 	...optional("mode", def.mode),
 	...optional("skills", def.skills),
-	...optional("access", def.access),
-	...optional("context", def.context)
+	...optional("access", def.access)
 });
 const normalizeStatus = (raw) => raw === "A" ? "A" : raw === "D" ? "D" : "M";
 /** Per-model token totals, highest-cost first (ties broken by model name). */
@@ -40395,10 +40242,6 @@ const pendingChanges = (git, withIndex) => gen(function* () {
 	const seen = new Set(worktree.map((e) => e.path));
 	return [...worktree, ...(yield* git.stagedPaths()).filter((e) => !seen.has(e.path))];
 });
-const sliceRangesOf = (slices, run) => sliceRanges(slices, {
-	base: run.startParentHash,
-	tip: run.trace.at(-1)?.hash ?? run.startParentHash
-});
 /** Resolve the rest at `ref`, or at HEAD when `ref` is `undefined`. */
 const restAt = (ref, startOverrides = {}) => gen(function* () {
 	const git = yield* GitService;
@@ -40442,64 +40285,6 @@ const restAt = (ref, startOverrides = {}) => gen(function* () {
 	};
 });
 const currentRest = restAt(void 0);
-/** Every slice refusal reads `<command>: refused — <reason>`; replay's own `gtd: ` lead is dropped. */
-const slicesDivergence = (command, run, outcome) => {
-	const reason = outcome.kind === "rest" && run.closingHash !== void 0 ? `${run.closingHash.slice(0, 7)} closes a process that does not end under today's config` : replayError(outcome)?.message.replace(/^gtd: /, "") ?? "replay failed";
-	return /* @__PURE__ */ new Error(`${command}: refused — ${reason}`);
-};
-/**
-* The replay `gtd slices` and `gtd summary --slice` share: the slice ranges of
-* `run`, plus whether HEAD closes it. Reads like `historyTrail`, never
-* `restAt`: it narrates and writes nothing.
-*/
-const replayedSlices = (config, run, how) => gen(function* () {
-	const workspace = yield* Workspace;
-	const host = yield* Host;
-	if (run.trace.length === 0) return yield* fail$7(/* @__PURE__ */ new Error(`${how.command}: refused — HEAD neither closes nor sits inside a process`));
-	const closing = run.closingHash;
-	let outcome;
-	let versionWarning;
-	if (closing !== void 0) {
-		const replayed = yield* replayFinishedProcess(config, run, closing, {
-			command: how.command,
-			configReason: how.configReason,
-			notEnded: (o) => slicesDivergence(how.command, run, o)
-		});
-		outcome = replayed.outcome;
-		versionWarning = replayed.versionWarning;
-	} else {
-		const { setup } = yield* setupFor(config, run, workspace, host);
-		outcome = yield* promise(() => replayFor(setup));
-		if (outcome.kind !== "rest") return yield* fail$7(slicesDivergence(how.command, run, outcome));
-	}
-	return {
-		ranges: sliceRangesOf(outcome.slices, run),
-		closed: closing !== void 0,
-		...versionWarning !== void 0 ? { versionWarning } : {}
-	};
-});
-/**
-* The slices of the process HEAD closes or sits inside, current episode only,
-* stack order. Returns a version warning for a closed run.
-*/
-const processSlices = gen(function* () {
-	const git = yield* GitService;
-	const config = yield* (yield* ConfigService).load;
-	const run = yield* runAtHead(git, config.workflow);
-	const { ranges, closed, versionWarning } = yield* replayedSlices(config, run, {
-		command: "gtd slices",
-		configReason: "HEAD's process replays under today's config; revert or stash the edit to list its slices"
-	});
-	return {
-		slices: ranges.map(({ name, base, tip, open }) => ({
-			name,
-			base,
-			tip,
-			closed: closed || !open
-		})),
-		...versionWarning !== void 0 ? { versionWarning } : {}
-	};
-});
 /**
 * Whether `gtd --workflow <name>` can start a process here: the workflow must
 * reach a step from the tree the opening commit would capture. That step is
@@ -40706,85 +40491,31 @@ const snapshotFromRest = (rest, verdicts) => gen(function* () {
 		landing
 	};
 });
-const narrowToSlice = (run, slice) => {
-	if (slice === void 0) return {
-		trace: run.trace,
-		costEntries: run.costEntries
-	};
-	const from = slice.base === run.startParentHash ? -1 : run.trace.findIndex((e) => e.hash === slice.base);
-	const to = run.trace.findIndex((e) => e.hash === slice.tip);
-	const trace = run.trace.slice(from + 1, to + 1);
-	const hashes = new Set(trace.map((e) => e.hash));
-	return {
-		trace,
-		costEntries: run.costEntries.filter((c) => hashes.has(c.hash))
-	};
-};
 const humanCommitsOf = (trace, entryCommit) => trace.filter((entry) => entry.actor === "human" && entry.hash !== entryCommit).map((entry) => ({
 	hash: entry.hash,
 	state: entry.state
 }));
-const summaryInput = (run, slice, settings) => {
+const summaryInput = (run, settings) => {
 	const entryCommit = run.trace[0].hash;
-	const { trace, costEntries } = narrowToSlice(run, slice);
-	const { total, byModel } = costTotals(costEntries);
+	const { total, byModel } = costTotals(run.costEntries);
 	return {
 		entryCommit,
-		processBase: slice?.base ?? run.startParentHash,
-		processTip: slice?.tip ?? run.trace[run.trace.length - 1].hash,
-		humanCommits: humanCommitsOf(trace, entryCommit),
+		processBase: run.startParentHash,
+		processTip: run.trace[run.trace.length - 1].hash,
+		humanCommits: humanCommitsOf(run.trace, entryCommit),
 		processCost: total,
 		processCostByModel: byModel,
 		marks: run.marks,
-		...settings,
-		...slice !== void 0 ? { slice } : {}
+		...settings
 	};
 };
-const locateSlice = (config, run, sliceName) => gen(function* () {
-	if (sliceName === void 0) return {};
-	const { ranges, versionWarning } = yield* replayedSlices(config, run, {
-		command: "gtd summary",
-		configReason: "HEAD's process replays under today's config; revert or stash the edit to summarize its slices"
-	});
-	const warn = versionWarning !== void 0 ? { versionWarning } : {};
-	const at = ranges.findIndex((r) => r.name === sliceName);
-	if (at < 0) return {
-		unknownSlice: `gtd summary: refused — no slice named "${sliceName}"; the slices, in stack order: ${ranges.map((r) => r.name).join(", ")}`,
-		...warn
-	};
-	const { base, tip } = ranges[at];
-	return {
-		slice: {
-			name: sliceName,
-			base,
-			tip,
-			index: at + 1,
-			count: ranges.length
-		},
-		...warn
-	};
-});
-/**
-* A plain call never replays; under a slice, `entryCommit` and `marks` stay
-* whole-process.
-*/
-const summaryFor = (run, sliceName) => gen(function* () {
+const summaryFor = (run) => gen(function* () {
 	const config = yield* (yield* ConfigService).load;
 	const host = yield* Host;
 	const resolved = yield* workflowOf(config, run);
 	const summary = resolved.def.summary;
-	if (summary === void 0) return { prompt: void 0 };
-	if (sliceName === void 0 && run.trace.length === 0) return { prompt: void 0 };
-	const located = yield* locateSlice(config, run, sliceName);
-	if ("unknownSlice" in located) return {
-		prompt: void 0,
-		...located
-	};
-	const { slice, versionWarning } = located;
-	return {
-		prompt: summary(summaryInput(run, slice, settingsFor(resolved, run.pinnedVars, host.env, {}, {}))),
-		...versionWarning !== void 0 ? { versionWarning } : {}
-	};
+	if (summary === void 0 || run.trace.length === 0) return { prompt: void 0 };
+	return { prompt: summary(summaryInput(run, settingsFor(resolved, run.pinnedVars, host.env, {}, {}))) };
 });
 /** Repository-relative paths of the config files today's config and the process's own record name; one outside the repository cannot be read at a ref, so it is left out. */
 const inRepoConfigPaths = (root, files, recorded) => {
@@ -41088,7 +40819,6 @@ const combinedScript = (required, optional) => {
 };
 //#endregion
 //#region src/emit/OutcomeScript.ts
-init_wire();
 /**
 * A `printf '<fmt>' <args...>` bash statement — `args` are already-valid bash
 * tokens (a `shellQuote`d literal, a `"$(git …)"` substitution), never
@@ -41343,7 +41073,6 @@ var ToolCommands = class extends Tag("ToolCommands")() {};
 //#endregion
 //#region src/cli/Output.ts
 init_esm();
-init_wire();
 /**
 * A command-level failure that should exit like a CLI usage error (2), not a
 * generic runtime failure (1): an unknown `--json=<path>` selector, or a
@@ -41369,7 +41098,6 @@ const writeJson = (json, out, document) => gen(function* () {
 //#endregion
 //#region src/cli/Strays.ts
 init_esm();
-init_wire();
 const resolveSide = (git, side) => git.resolveRef(`${side}^{commit}`).pipe(mapError$1(() => new GtdError(`gtd strays: unknown revision '${side}'`)));
 /** stdout carries the array alone; the summary is ungated stderr so a quiet run still explains its exit code, the per-path lines are narration. */
 const runStraysCommand = (command, json, out) => gen(function* () {
@@ -41469,10 +41197,8 @@ const runHistoryFetchCommand = (remote, out) => sync$1(() => {
 //#endregion
 //#region src/cli/Metrics.ts
 init_esm();
-init_wire();
 const QUALITY$1 = ".gtd/QUALITY.md";
 const LENS = /^((?:.*\.)?quality\.[^.]+)\.reviewing$/;
-const CONTINUE = /(^|\.)continue\./;
 const inSeam = (step) => step.startsWith("seam.");
 const phaseOf = (step) => {
 	const scope = step.split(".")[0];
@@ -41491,13 +41217,12 @@ const add = (into, key, n) => {
 };
 const roundAll = (record) => Object.fromEntries(Object.entries(record).map(([k, v]) => [k, round(v)]));
 const emptyTally = () => ({
-	slices: {
+	builds: {
 		decided: 0,
 		landed: 0,
 		rebuilt: 0,
 		refactored: 0
 	},
-	continuations: record(),
 	byModel: record(),
 	byPhase: {
 		naive: 0,
@@ -41514,9 +41239,8 @@ const emptyTally = () => ({
 });
 const sum = (record) => Object.values(record).reduce((a, b) => a + b, 0);
 const finish = (t) => ({
-	slices: t.slices,
-	refactorFirstRate: t.slices.decided === 0 ? null : round(t.slices.rebuilt / t.slices.decided, 3),
-	continuations: t.continuations,
+	builds: t.builds,
+	refactorFirstRate: t.builds.decided === 0 ? null : round(t.builds.rebuilt / t.builds.decided, 3),
 	cost: {
 		total: round(sum(t.byModel)),
 		byModel: roundAll(t.byModel),
@@ -41544,33 +41268,33 @@ const tallyCost = (t, open, costs, phase) => {
 		if (phase === "implement" && open.rebuilding) t.doubleWork.rebuild += cost;
 	}
 };
-/** A slice is decided where its turns leave the seam: for `implement.applying` the naive pass landed — unless it fails to apply and is built afresh — anywhere else it is rebuilt. */
+/** A build is decided where its turns leave the seam: for `implement.applying` the naive pass landed — unless it fails to apply and is built afresh — anywhere else it is rebuilt. */
 const tallyDecision = (t, open, at, to) => {
 	if (at === "implement.closing") open.rebuilding = false;
 	if (open.applying !== void 0 && at === "implement.applying") {
 		const naive = open.applying;
 		open.applying = void 0;
 		if (to !== "implement.building") return;
-		t.slices.landed--;
+		t.builds.landed--;
 		rebuild(t, open, naive);
 		return;
 	}
 	if (!inSeam(at) || inSeam(to)) return;
-	t.slices.decided++;
+	t.builds.decided++;
 	const naive = open.naive;
 	open.naive = 0;
 	if (to === "implement.applying") {
 		open.applying = naive;
 		open.rebuilding = false;
-		t.slices.landed++;
+		t.builds.landed++;
 		return;
 	}
 	rebuild(t, open, naive);
-	if (at === "seam.note") t.slices.refactored++;
+	if (at === "seam.note") t.builds.refactored++;
 };
 const rebuild = (t, open, naive) => {
 	open.rebuilding = true;
-	t.slices.rebuilt++;
+	t.builds.rebuilt++;
 	t.doubleWork.naive += naive;
 };
 /** Oldest first; a commit gtd did not write is skipped. */
@@ -41587,7 +41311,6 @@ const processMetrics = (commits) => {
 		if (subject === void 0) continue;
 		const at = subject.from ?? subject.to;
 		tallyCost(t, open, message.cost, phaseOf(at));
-		if (subject.actor === "agent" && CONTINUE.test(at)) add(t.continuations, at.replace(CONTINUE, "$1"), 1);
 		const lens = LENS.exec(at)?.[1];
 		if (lens !== void 0 && commit.findings > 0) add(t.byLens, lens, commit.findings);
 		if (message.marks.some((m) => m.name === "flaky")) add(t.flaky, at, 1);
@@ -41598,8 +41321,7 @@ const processMetrics = (commits) => {
 const totalMetrics = (all) => {
 	const t = emptyTally();
 	for (const m of all) {
-		for (const key of Object.keys(t.slices)) t.slices[key] += m.slices[key];
-		for (const [k, v] of Object.entries(m.continuations)) add(t.continuations, k, v);
+		for (const key of Object.keys(t.builds)) t.builds[key] += m.builds[key];
 		for (const [k, v] of Object.entries(m.cost.byModel)) add(t.byModel, k, v);
 		for (const key of Object.keys(t.byPhase)) t.byPhase[key] += m.cost.byPhase[key];
 		t.doubleWork.naive += m.cost.doubleWork.naive;
@@ -41636,12 +41358,10 @@ const readProcessMetrics = (entry) => gen(function* () {
 const printable = (s) => s.replace(/[\x00-\x1f\x7f-\x9f\u2028\u2029]/g, "?");
 const listed = (record) => Object.entries(record).map(([k, v]) => `${printable(k)} ${v}`).join(", ");
 const line = (label, m) => {
-	const { slices, cost } = m;
+	const { builds, cost } = m;
 	const percent = m.refactorFirstRate === null ? "-" : `${Math.round(m.refactorFirstRate * 100)}%`;
-	const continued = sum(m.continuations);
 	return [
-		`${label}: ${slices.decided} slices, ${slices.rebuilt} rebuilt (refactor-first ${percent}), ${slices.refactored} refactored`,
-		`${continued} continuations${continued > 0 ? ` (${listed(m.continuations)})` : ""}`,
+		`${label}: ${builds.decided} builds, ${builds.rebuilt} rebuilt (refactor-first ${percent}), ${builds.refactored} refactored`,
 		`cost ${cost.total} (${listed(cost.byPhase)}; by model ${listed(cost.byModel) || "-"}), double work ${cost.doubleWork.total}`,
 		`${m.findings.total} findings${m.findings.total > 0 ? ` (${listed(m.findings.byLens)})` : ""}`,
 		`${m.flaky.total} flaky${m.flaky.total > 0 ? ` (${listed(m.flaky.byStep)})` : ""}`
@@ -41838,7 +41558,7 @@ const processJudgments = (commits) => {
 	});
 };
 const NOT_COMPARABLE = { tailsNotComparable: "true" };
-const field$1 = (key, value) => value === void 0 ? {} : { [key]: value };
+const field = (key, value) => value === void 0 ? {} : { [key]: value };
 const JUDGES = {
 	retry: ({ reads, i, scope }, v) => {
 		const reports = reportsBefore(reads, i, scope);
@@ -41848,8 +41568,8 @@ const JUDGES = {
 		const known = previous !== void 0 && current !== void 0;
 		return {
 			state: comparable ? {
-				...field$1("previous", previous),
-				...field$1("current", current)
+				...field("previous", previous),
+				...field("current", current)
 			} : NOT_COMPARABLE,
 			outcome: known && comparable && answerOf(v.answer) === "identical" ? retryOutcome(reads, i, scope) : null
 		};
@@ -41857,12 +41577,12 @@ const JUDGES = {
 	triage: ({ reads, i }, v) => {
 		const finding = reads[i].commit.findings?.find((f) => f.id === v.id);
 		return {
-			state: field$1(v.id, finding && `## ${finding.title}\n\n${finding.body}`),
+			state: field(v.id, finding && `## ${finding.title}\n\n${finding.body}`),
 			outcome: triageOutcome(reads, i, answerOf(v.answer), finding)
 		};
 	},
 	clear: ({ reads, i, sketch }, v) => ({
-		state: field$1("sketch", sketch),
+		state: field("sketch", sketch),
 		outcome: clearOutcome(reads, i, v)
 	})
 };
@@ -42049,7 +41769,6 @@ const runHistoryJudgesCommand = (refs, vars, jsonl, json, out) => gen(function*
 //#endregion
 //#region src/cli/Program.ts
 init_esm();
-init_wire();
 init_steering();
 const selfGtd = () => {
 	const script = process.argv[1];
@@ -42131,16 +41850,10 @@ const planLanding = (opts = {}, current) => gen(function* () {
 * closes or sits inside its own closing message. Writes nothing — no git, no
 * state transition, no file. Refuses (throws, mapped to the runtime-error
 * exit code) when the workflow declares no `summary` prompt, or the resolved
-* run has no commits to name. `--slice` also refuses an unknown slice name
-* (listing the valid slices), a config edited since the process closed, and a
-* replay that diverged. The edge never narrates: the CLI prints the
-* version warning, before the unknown-slice refusal; a replay refusal carries
-* it in its message.
-*/
-const runSummaryCommand = (out, sliceName) => gen(function* () {
-	const { prompt, versionWarning, unknownSlice } = yield* summaryFor(yield* summaryRun, sliceName);
-	if (versionWarning !== void 0) yield* (yield* Narrator).warn(versionWarning);
-	if (unknownSlice !== void 0) return yield* fail$7(new Error(unknownSlice));
+* run has no commits to name.
+*/
+const runSummaryCommand = (out) => gen(function* () {
+	const { prompt } = yield* summaryFor(yield* summaryRun);
 	if (prompt === void 0) return yield* fail$7(/* @__PURE__ */ new Error("gtd summary: refused — either this workflow declares no \"summary:\" template, or there is no finished/in-flight process to summarize at HEAD"));
 	out.write(prompt.endsWith("\n") ? prompt : prompt + "\n");
 });
@@ -42185,17 +41898,6 @@ const readStdin = () => tryPromise({
 	},
 	catch: (e) => e instanceof Error ? e : new Error(String(e))
 });
-/** Stdout is written once: a hook reads one JSON document, or none. */
-const runContextHookCommand = (command, out) => gen(function* () {
-	const tools = yield* ToolCommands;
-	const input = yield* readStdin();
-	out.write(yield* tools.contextHook({
-		input,
-		...command.soft !== void 0 ? { soft: command.soft } : {},
-		...command.hard !== void 0 ? { hard: command.hard } : {},
-		...command.window !== void 0 ? { window: command.window } : {}
-	}));
-});
 /** Stdout is written once, after the answerer resolves — a rejection leaves it empty. */
 const runJudgeRunCommand = (command, out) => gen(function* () {
 	const host = yield* Host;
@@ -42337,17 +42039,6 @@ const runDoorsCommand = (json, out) => gen(function* () {
 	if (json.kind === "document") out.write(`${JSON.stringify(document)}\n`);
 	else yield* writeSelection(out, document, json.path);
 });
-const runSlicesCommand = (json, out) => gen(function* () {
-	const { slices, versionWarning } = yield* processSlices;
-	if (versionWarning !== void 0) yield* (yield* Narrator).warn(versionWarning);
-	if (json.kind === "off") {
-		out.write(slices.map((s) => `${s.name} ${s.base}..${s.tip}\n`).join(""));
-		return;
-	}
-	const document = slicesDocument(slices);
-	if (json.kind === "document") out.write(renderSlicesJson(document));
-	else yield* writeSelection(out, document, json.path);
-});
 /**
 * Ends the process underway without completing it. Nothing is discarded: a
 * `git reset --mixed` to the process's start commit leaves every turn
@@ -42654,7 +42345,6 @@ const needsOf = (kind) => {
 	switch (kind) {
 		case "lsp":
 		case "install":
-		case "contextHook":
 		case "judgeRun":
 		case "strays": return "none";
 		case "check":
@@ -42683,7 +42373,6 @@ const dispatchVoidCommand = (command, json, out) => {
 		case "start": return runStartCommand(command.actor, command.workflow, command.vars, out, command.label);
 		case "door": return runDoorCommand(command.name, command.args, out);
 		case "doors": return runDoorsCommand(json, out);
-		case "slices": return runSlicesCommand(json, out);
 		case "abandon": return runAbandonCommand(out);
 		case "restore": return runRestoreCommand(out);
 		case "next": return runNextCommand(json, out);
@@ -42693,8 +42382,7 @@ const dispatchVoidCommand = (command, json, out) => {
 			return runCheckCommand(command.mode, command.file, command.openQuestions ?? false, command.openThreads ?? false);
 		case "uncheck": return runUncheckCommand(command.file);
 		case "install": return runInstallCommand(out);
-		case "contextHook": return runContextHookCommand(command, out);
-		case "summary": return runSummaryCommand(out, command.slice);
+		case "summary": return runSummaryCommand(out);
 		case "base": return runBaseCommand(out);
 		case "judge": return runJudgeCommand(json, out);
 		case "judgeAnswer": return runJudgeAnswerCommand(json, out);
@@ -42733,23 +42421,17 @@ const runCommand = (command, json, out) => {
 //#endregion
 //#region src/cli/Cli.ts
 init_esm();
-init_wire();
 const nonNegativeNumber = (raw, flag) => {
 	const n = Number(raw);
 	if (raw.trim() === "" || !Number.isFinite(n) || n < 0) return left(`gtd: ${flag} must be a non-negative number — got "${raw}"`);
 	return right(n);
 };
-const share = (raw, flag) => {
-	const n = Number(raw);
-	return raw.trim() !== "" && n > 0 && n <= 1 ? right(n) : left(`gtd: ${flag} must be a share of the context window in (0, 1] — got "${raw}"`);
-};
 const JSON_KINDS = /* @__PURE__ */ new Set([
 	"next",
 	"land",
 	"judge",
 	"judgeAnswer",
 	"doors",
-	"slices",
 	"historyList",
 	"historyShow",
 	"historyMetrics",
@@ -42763,10 +42445,10 @@ const FLAGS = [
 		repeatable: false,
 		scope: (kind) => JSON_KINDS.has(kind),
 		decode: ([raw]) => right(raw ?? ""),
-		scopeError: "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer`/`gtd doors`/`gtd slices`/`gtd history list`/`gtd history show`/`gtd history metrics`/`gtd history judges`/`gtd strays` — every other command prints plain text; see `gtd install` for the driver protocol briefing",
+		scopeError: "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer`/`gtd doors`/`gtd history list`/`gtd history show`/`gtd history metrics`/`gtd history judges`/`gtd strays` — every other command prints plain text; see `gtd install` for the driver protocol briefing",
 		valueHint: "<path>",
 		help: [
-			"(gtd next/gtd land/gtd judge/gtd judge answer/gtd doors/gtd slices/gtd history",
+			"(gtd next/gtd land/gtd judge/gtd judge answer/gtd doors/gtd history",
 			"list/gtd history show/gtd history metrics/gtd history judges/gtd strays only) output structured JSON. Bare --json prints the whole document;",
 			"--json=<path> (a dotted key path into that document, e.g.",
 			"kind, content, session.id) prints just that value: a",
@@ -42883,54 +42565,6 @@ const FLAGS = [
 			"GTD_JUDGE_MODEL, then judge.json, then sonnet"
 		]
 	},
-	{
-		name: "--soft",
-		arity: 1,
-		repeatable: false,
-		scope: (kind) => kind === "contextHook",
-		decode: ([raw]) => share(raw ?? "", "--soft"),
-		scopeError: "gtd: --soft is only valid for `gtd context-hook`",
-		valueHint: "<share>",
-		help: ["(gtd context-hook only) the soft limit; default 0.6"]
-	},
-	{
-		name: "--hard",
-		arity: 1,
-		repeatable: false,
-		scope: (kind) => kind === "contextHook",
-		decode: ([raw]) => share(raw ?? "", "--hard"),
-		scopeError: "gtd: --hard is only valid for `gtd context-hook`",
-		valueHint: "<share>",
-		help: ["(gtd context-hook only) the hard limit; default 0.7"]
-	},
-	{
-		name: "--window",
-		arity: 1,
-		repeatable: false,
-		scope: (kind) => kind === "contextHook",
-		decode: ([raw]) => {
-			const window = parseContextWindow(raw);
-			return window !== void 0 ? right(window) : left(`gtd: --window must be a positive integer — got "${raw ?? ""}"`);
-		},
-		scopeError: "gtd: --window is only valid for `gtd context-hook`",
-		valueHint: "<tokens>",
-		help: ["(gtd context-hook only) the model's context window in", "tokens; default 200000"]
-	},
-	{
-		name: "--slice",
-		arity: 1,
-		repeatable: false,
-		scope: (kind) => kind === "summary",
-		decode: ([raw]) => right(raw),
-		scopeError: "gtd: --slice is only valid for `gtd summary`",
-		valueHint: "<name>",
-		help: [
-			"(gtd summary only) the closing-message prompt for one",
-			"slice, named as `gtd slices` lists it: its own range, human",
-			"commits and cost. An unknown name is refused (exit 1) with",
-			"every valid slice listed"
-		]
-	},
 	{
 		name: "--workflow",
 		arity: 1,
@@ -43221,22 +42855,6 @@ const COMMAND_ROWS = [
 			"else it writes nothing."
 		]
 	},
-	{
-		token: "context-hook",
-		kind: "contextHook",
-		arity: "none",
-		details: [
-			"A Claude Code PostToolUse and PreCompact hook that stops an",
-			"agent turn at a share of its context window. Reads the",
-			"hook's input on stdin and the context the transcript's",
-			"latest assistant message used. Past --soft it blocks with a",
-			"request to end the turn with a handoff note; past --hard,",
-			"or at PreCompact, it stops the turn with a stopReason",
-			"starting \"gtd: context limit\". Prints nothing otherwise,",
-			"and for a subagent's tool call. Always exits 0 on valid",
-			"input; see docs/driver.md"
-		]
-	},
 	{
 		token: "summary",
 		kind: "summary",
@@ -43250,15 +42868,10 @@ const COMMAND_ROWS = [
 			"no state transition, no file, no session identity — the",
 			"driver pipes the output to a cold agent and does what it",
 			"wants with the result (a squash, an amend, a PR body).",
-			"--slice <name> prints it for one slice instead: its own",
-			"range, human commits and cost (see `gtd slices`); it also",
-			"refuses an unknown slice name, and a HEAD-closing process",
-			"whose config files differ from the working tree or whose",
-			"replay diverged; an open last slice is provisional. Refuses",
-			"(exit 1) when the workflow declares no summary: template,",
-			"or when the resolved run has no commits to name — plain",
-			"gtd summary is runnable any time before the next thing",
-			"lands on the branch"
+			"Refuses (exit 1) when the workflow declares no summary:",
+			"template, or when the resolved run has no commits to name —",
+			"it is runnable any time before the next thing lands on the",
+			"branch"
 		]
 	},
 	{
@@ -43304,25 +42917,6 @@ const COMMAND_ROWS = [
 			"value off it. Writes nothing"
 		]
 	},
-	{
-		token: "slices",
-		kind: "slices",
-		arity: "none",
-		details: [
-			"List the slices of the process HEAD closes or sits inside,",
-			"first slice first: one `name base..tip` line each (full",
-			"hashes; plain output carries no promise). --json prints",
-			"{ schema: 1, slices: [{ name, base, tip, closed }] };",
-			"--json=<path> reads one value off it. Writes nothing: no",
-			"git, no state transition, no session identity. When HEAD",
-			"closes a process, every slice is listed as closed; a gtd",
-			"version mismatch only warns on stderr. Refuses (exit 1)",
-			"when HEAD neither closes nor sits inside a process, or when",
-			"today's config disagrees with history about the process:",
-			"HEAD closes it and its config files differ from the working",
-			"tree, or the replay diverged"
-		]
-	},
 	{
 		token: "judge",
 		kind: "judge",
@@ -43424,11 +43018,11 @@ const COMMAND_ROWS = [
 			many: true
 		},
 		details: [
-			"Report how the kept processes went: slices whose naive pass",
-			"landed or was rebuilt (the refactor-first rate), continuations",
-			"per phase, Gtd-Cost by model and phase with the double work of",
-			"a rebuild, quality-lap findings per lens, and red checks that",
-			"passed on their re-check — per process and in total. Each <ref>",
+			"Report how the kept processes went: builds whose naive pass",
+			"landed or was rebuilt (the refactor-first rate), Gtd-Cost by",
+			"model and phase with the double work of a rebuild, quality-lap",
+			"findings per lens, and red checks that passed on their",
+			"re-check — per process and in total. Each <ref>",
 			"is read as by history show, but a branch name means every",
 			"process kept from it; none means every ref.",
 			"Reads commit subjects and trailers, never replays, so a",
@@ -43757,23 +43351,9 @@ const parseArgv = (argv) => {
 			verbose
 		};
 	}
-	if (kind === "contextHook") return {
-		kind: "command",
-		command: {
-			kind: "contextHook",
-			...bag["--soft"] !== void 0 ? { soft: bag["--soft"] } : {},
-			...bag["--hard"] !== void 0 ? { hard: bag["--hard"] } : {},
-			...bag["--window"] !== void 0 ? { window: bag["--window"] } : {}
-		},
-		json,
-		verbose
-	};
 	if (kind === "summary") return {
 		kind: "command",
-		command: {
-			kind: "summary",
-			...bag["--slice"] !== void 0 ? { slice: bag["--slice"] } : {}
-		},
+		command: { kind: "summary" },
 		json,
 		verbose
 	};
@@ -59472,88 +59052,6 @@ var init_lsp = __esmMin((() => {
 	init_Lsp();
 }));
 //#endregion
-//#region src/hook/HookHost.ts
-var HookHost, liveHookHost;
-var init_HookHost = __esmMin((() => {
-	init_esm();
-	HookHost = class extends Tag("HookHost")() {};
-	liveHookHost = succeed$2(HookHost, {
-		env: process.env,
-		readFile: (path) => try_({
-			try: () => {
-				try {
-					return readFileSync(path, "utf-8");
-				} catch (error) {
-					if (error.code === "ENOENT") return void 0;
-					throw error;
-				}
-			},
-			catch: (error) => /* @__PURE__ */ new Error(`could not read ${path}: ${String(error)}`)
-		}),
-		appendFile: (path, text) => sync$1(() => appendFileSync(path, text))
-	});
-}));
-//#endregion
-//#region src/hook/ContextHook.ts
-var field, limitOf, parseInput, tokensOf, recordStop, runContextHook;
-var init_ContextHook = __esmMin((() => {
-	init_esm();
-	init_wire();
-	init_HookHost();
-	field = (value, key) => typeof value === "object" && value !== null ? value[key] : void 0;
-	limitOf = (request) => {
-		const limit = {
-			soft: request.soft ?? DEFAULT_CONTEXT_LIMIT.soft,
-			hard: request.hard ?? DEFAULT_CONTEXT_LIMIT.hard
-		};
-		const fault = contextLimitFault(limit);
-		return fault === void 0 ? succeed$3(limit) : fail$7(/* @__PURE__ */ new Error(`gtd context-hook: ${fault}`));
-	};
-	parseInput = (text) => try_({
-		try: () => JSON.parse(text),
-		catch: () => /* @__PURE__ */ new Error("gtd context-hook: stdin is not a hook's JSON input")
-	}).pipe(map$4((input) => {
-		const event = field(input, "hook_event_name");
-		if (event !== "PostToolUse" && event !== "PreCompact") return void 0;
-		if (field(input, "agent_id") !== void 0) return void 0;
-		const path = field(input, "transcript_path");
-		return {
-			event,
-			transcript: typeof path === "string" && path !== "" ? path : void 0
-		};
-	}));
-	tokensOf = (input) => input.event === "PostToolUse" && input.transcript !== void 0 ? flatMap$4(HookHost, (host) => host.readFile(input.transcript)).pipe(map$4((text) => text === void 0 ? void 0 : transcriptTokens(text))) : succeed$3(void 0);
-	recordStop = (stopReason) => flatMap$4(HookHost, (host) => {
-		const file = host.env[CONTEXT_STOP_FILE_ENV];
-		return file === void 0 || file === "" ? _void : host.appendFile(file, `${stopReason}\n`).pipe(catchAllDefect(() => _void));
-	});
-	runContextHook = (request) => gen(function* () {
-		const limit = yield* limitOf(request);
-		const input = yield* parseInput(request.input);
-		if (input === void 0) return "";
-		const decision = contextHook({
-			event: input.event,
-			tokens: yield* tokensOf(input),
-			window: request.window ?? contextWindowFor(void 0),
-			limit
-		});
-		if (decision === void 0) return "";
-		if (decision.kind === "hard") yield* recordStop(decision.stopReason);
-		return `${JSON.stringify(hookOutput(decision))}\n`;
-	});
-}));
-//#endregion
-//#region src/hook/index.ts
-var hook_exports = /* @__PURE__ */ __exportAll({
-	HookHost: () => HookHost,
-	liveHookHost: () => liveHookHost,
-	runContextHook: () => runContextHook
-});
-var init_hook = __esmMin((() => {
-	init_HookHost();
-	init_ContextHook();
-}));
-//#endregion
 //#region src/judges/providers/io.ts
 var liveJudgeIo;
 var init_io = __esmMin((() => {
@@ -60036,10 +59534,6 @@ const liveToolCommands = effect$1(ToolCommands, gen(function* () {
 			const { startLspServer } = await Promise.resolve().then(() => (init_lsp(), lsp_exports));
 			return () => startLspServer({ gtd });
 		}),
-		contextHook: (request) => lazy("context-hook", async () => {
-			const { runContextHook, liveHookHost } = await Promise.resolve().then(() => (init_hook(), hook_exports));
-			return () => runContextHook(request).pipe(provide$1(liveHookHost));
-		}),
 		judge: async (request) => {
 			const { runJudge } = await Promise.resolve().then(() => (init_judges(), judges_exports)).catch((error) => {
 				throw loadFailure("judge")(error);