@pmelab/gtd 63.0.0 → 64.1.0

package/dist/chunks/{testkit-DwypA7cH.mjs → testkit-DfWZQCWQ.mjs}

@@ -1,23 +1,22 @@
-import { C as moveScript, D as revertScript, E as restoreScript, H as installContext, K as markedOptions, O as showScript, S as checkScript, T as removeScript, Y as protocolMismatch, i as configure, k as writeScript$1, n as configProblems, o as isFactoryWorkflow, p as numeric, s as answered, t as flows_exports, x as applyScript } from "./flows-DENt0uWV.mjs";
+import { C as moveScript, D as revertScript, E as restoreScript, H as installContext, K as markedOptions, O as showScript, S as checkScript, T as removeScript, Y as protocolMismatch, i as configure, k as writeScript$1, n as configProblems, o as isFactoryWorkflow, p as numeric, s as answered, t as flows_exports, x as applyScript } from "./flows-B7ZRCe-B.mjs";
 import { M as renderFormat, O as ACCESS_REFUSAL, a as renderScriptJson, d as renderLandPlain, f as DEMAND_BRIEFING, g as statusOf, h as renderBeatJson, i as judgeJson, k as PIN_PATH, l as noopText, m as beatDocument, n as resolveSession, o as scriptFields, p as renderBeatPlain, r as selectPath, s as landFields, t as globMatches, u as renderLandJson, v as beatKindOf, y as demandOf } from "./wire-CPNSm_9N.mjs";
-import { M as headingSectionBodies, N as formatFinding, a as sections, c as openThreads, i as sectionBodies, l as steeringFormatFor, o as threads, r as openQuestions, s as BUILT_IN_MODE_NAMES, t as parseCodeThreads, u as unansweredQuestions } from "./steering-DF_BMadH.mjs";
+import { F as headingSectionBodies, I as formatFinding, a as sections, c as openThreads, d as formatFromSpec, i as sectionBodies, l as steeringFormatFor, o as threads, r as openQuestions, s as BUILT_IN_MODE_NAMES, t as parseCodeThreads, u as unansweredQuestions } from "./steering-Cem5i6Xl.mjs";
 import { createRequire, isBuiltin } from "node:module";
 import * as Crypto from "node:crypto";
 import { createHash } from "node:crypto";
-import { PassThrough, finished } from "node:stream";
-import * as NodeChildProcess from "node:child_process";
-import { execFileSync } from "node:child_process";
-import * as NFS from "node:fs";
-import { existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
-import * as Path from "node:path";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import * as OS from "node:os";
 import { homedir, tmpdir } from "node:os";
-import { gzipSync } from "node:zlib";
 import * as NodeUrl from "node:url";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
 import { stripVTControlCharacters } from "node:util";
 import { runInThisContext } from "node:vm";
+import { gzipSync } from "node:zlib";
+import * as NodeChildProcess from "node:child_process";
+import { execFileSync } from "node:child_process";
+import * as NFS from "node:fs";
+import { lstatSync, mkdirSync, readFileSync, readlinkSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { PassThrough, finished } from "node:stream";
+import * as Path from "node:path";
 import "vitest";
 //#region node_modules/effect/dist/Pipeable.js
 /**
@@ -3399,7 +3398,7 @@ const map$6 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : some(f(
 * @category sequencing
 * @since 2.0.0
 */
-const flatMap$3 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : f(self.value));
+const flatMap$4 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : f(self.value));
 //#endregion
 //#region node_modules/effect/dist/Context.js
 /**
@@ -5636,7 +5635,7 @@ var FiberImpl = class {
 			return;
 		}
 		const interruptChildren = fiberMiddleware.interruptChildren && fiberMiddleware.interruptChildren(this);
-		if (interruptChildren !== void 0) return this.evaluate(flatMap$1(interruptChildren, () => exit));
+		if (interruptChildren !== void 0) return this.evaluate(flatMap$2(interruptChildren, () => exit));
 		this._exit = exit;
 		this.cache.runtimeMetrics?.recordFiberEnd(this.context, this._exit);
 		if (this._parent) {
@@ -5671,7 +5670,7 @@ var FiberImpl = class {
 				if (!yielding && !cache.preventYield && cache.scheduler.shouldYield(this)) {
 					yielding = true;
 					const prev = current;
-					current = flatMap$1(yieldNow, () => prev);
+					current = flatMap$2(yieldNow, () => prev);
 				}
 				current = cache.tracerContext ? cache.tracerContext(current, this) : current[evaluate$1](this);
 				if (current === Yield) {
@@ -5954,7 +5953,7 @@ const asyncFinalizer = /*#__PURE__*/ makePrimitive({
 		}
 	},
 	[contE](cause, _fiber) {
-		return hasInterrupts(cause) ? flatMap$1(combineFinalizerCause(exitFailCause(cause), this[args]()), () => failCause$3(cause)) : failCause$3(cause);
+		return hasInterrupts(cause) ? flatMap$2(combineFinalizerCause(exitFailCause(cause), this[args]()), () => failCause$3(cause)) : failCause$3(cause);
 	}
 });
 /** @internal */
@@ -6015,7 +6014,7 @@ const fromIteratorEagerUnsafe = (evaluate) => {
 				return suspend$3(() => {
 					if (isFirstExecution) {
 						isFirstExecution = false;
-						return flatMap$1(state.value, (value) => fromIteratorUnsafe(iterator, value));
+						return flatMap$2(state.value, (value) => fromIteratorUnsafe(iterator, value));
 					} else return suspend$3(() => fromIteratorUnsafe(evaluate()));
 				});
 			}
@@ -6138,13 +6137,13 @@ const raceAllFirst = (all, options) => withFiber$1((parent) => {
 /** @internal */
 const raceFirst$1 = /*#__PURE__*/ dual((args) => isEffect(args[1]), (self, that, options) => raceAllFirst([self, that], options));
 /** @internal */
-const flatMap$1 = /*#__PURE__*/ dual(2, (self, f) => new ContImpl(self, andThenCont, f));
+const flatMap$2 = /*#__PURE__*/ dual(2, (self, f) => new ContImpl(self, andThenCont, f));
 /** @internal */
 const effectIsExit = (effect) => effect[ExitTypeId] !== void 0;
 /** @internal */
 const flatMapEager$1 = /*#__PURE__*/ dual(2, (self, f) => {
 	if (effectIsExit(self)) return self._tag === "Success" ? f(self.value) : self;
-	return flatMap$1(self, f);
+	return flatMap$2(self, f);
 });
 /** @internal */
 const map$2 = /*#__PURE__*/ dual(2, (self, f) => new ContImpl(self, mapCont, f));
@@ -6195,11 +6194,11 @@ const provideService$1 = function() {
 };
 const provideServiceImpl = (self, service, implementation) => updateContext(self, add$1(service, implementation));
 /** @internal */
-const zipWith$1 = /*#__PURE__*/ dual((args) => isEffect(args[1]), (self, that, f, options) => options?.concurrent ? map$2(all$1([self, that], { concurrency: 2 }), ([a, a2]) => f(a, a2)) : flatMap$1(self, (a) => map$2(that, (a2) => f(a, a2))));
+const zipWith$1 = /*#__PURE__*/ dual((args) => isEffect(args[1]), (self, that, f, options) => options?.concurrent ? map$2(all$1([self, that], { concurrency: 2 }), ([a, a2]) => f(a, a2)) : flatMap$2(self, (a) => map$2(that, (a2) => f(a, a2))));
 /** @internal */
 const forever$1 = /*#__PURE__*/ dual((args) => isEffect(args[0]), (self, options) => whileLoop$1({
 	while: constTrue,
-	body: constant(options?.disableYield ? self : flatMap$1(self, (_) => yieldNow)),
+	body: constant(options?.disableYield ? self : flatMap$2(self, (_) => yieldNow)),
 	step: constVoid
 }));
 /** @internal */
@@ -6474,7 +6473,7 @@ const scopedWith$1 = (f) => suspend$3(() => {
 	return onExit$1(f(scope), (exit) => suspend$3(() => scopeCloseUnsafe(scope, exit) ?? void_$2));
 });
 /** @internal */
-const acquireRelease$1 = (acquire, release, options) => contextWith((context) => uninterruptibleMask((restore) => flatMap$1(scope, (scope) => tap$1(options?.interruptible ? restore(acquire) : acquire, (a) => scopeAddFinalizerExit(scope, (exit) => provideContext(release(a, exit), context))))));
+const acquireRelease$1 = (acquire, release, options) => contextWith((context) => uninterruptibleMask((restore) => flatMap$2(scope, (scope) => tap$1(options?.interruptible ? restore(acquire) : acquire, (a) => scopeAddFinalizerExit(scope, (exit) => provideContext(release(a, exit), context))))));
 const OnExitImpl = /*#__PURE__*/ function() {
 	const Proto = /*#__PURE__*/ makePrimitiveProto({
 		op: "OnExit",
@@ -6496,7 +6495,7 @@ const OnExitImpl = /*#__PURE__*/ function() {
 			} catch (defect) {
 				eff = exitDie(defect);
 			}
-			return eff ? flatMap$1(eff, (_) => exit) : exit;
+			return eff ? flatMap$2(eff, (_) => exit) : exit;
 		},
 		[contE](cause, _, exit) {
 			exit ??= exitFailCause(cause);
@@ -6506,7 +6505,7 @@ const OnExitImpl = /*#__PURE__*/ function() {
 			} catch (defect) {
 				eff = exitDie(defect);
 			}
-			return eff ? flatMap$1(combineFinalizerCause(exit, eff), (_) => exit) : exit;
+			return eff ? flatMap$2(combineFinalizerCause(exit, eff), (_) => exit) : exit;
 		}
 	});
 	const OnExitImpl = function(effect, onExit, interruptible) {
@@ -6641,7 +6640,7 @@ const resolveConcurrency = (concurrency) => concurrency === "unbounded" ? Number
 const iterateEager = () => (options) => {
 	const onItem = options.onItem;
 	const step = options.step;
-	const resumeSequential = (state, items, index, end, effect) => flatMap$1(exit$1(effect), (itemExit) => step(state, items[index], itemExit, index) ?? runSequential(state, items, index + 1, end) ?? void_$2);
+	const resumeSequential = (state, items, index, end, effect) => flatMap$2(exit$1(effect), (itemExit) => step(state, items[index], itemExit, index) ?? runSequential(state, items, index + 1, end) ?? void_$2);
 	const runSequential = (state, items, index = 0, end = items.length) => {
 		for (; index < end; index++) {
 			const item = items[index];
@@ -6670,7 +6669,7 @@ const iterateConcurrentImpl = (options) => {
 			const defect = exitDie(error);
 			terminal = defect;
 			done = true;
-			return fibers && fibers.size > 0 ? flatMap$1(uninterruptible(fiberInterruptAll(Array.from(fibers))), () => terminal ?? defect) : defect;
+			return fibers && fibers.size > 0 ? flatMap$2(uninterruptible(fiberInterruptAll(Array.from(fibers))), () => terminal ?? defect) : defect;
 		};
 		const go = () => {
 			let paused = false;
@@ -6694,7 +6693,7 @@ const iterateConcurrentImpl = (options) => {
 					if (result) return cb(result);
 					return suspend$3(() => {
 						terminal ??= exitVoid;
-						return flatMap$1(fibers ? fiberInterruptAll(fibers) : void_$2, () => terminal?._tag === "Failure" ? terminal : void_$2);
+						return flatMap$2(fibers ? fiberInterruptAll(fibers) : void_$2, () => terminal?._tag === "Failure" ? terminal : void_$2);
 					});
 				});
 				else {
@@ -6793,7 +6792,7 @@ const forkIn$1 = /*#__PURE__*/ dual((args) => isEffect(args[0]), (self, scope, o
 	return succeed$4(fiber);
 }));
 /** @internal */
-const forkScoped$1 = /*#__PURE__*/ dual((args) => isEffect(args[0]), (self, options) => flatMap$1(scope, (scope) => forkIn$1(self, scope, options)));
+const forkScoped$1 = /*#__PURE__*/ dual((args) => isEffect(args[0]), (self, options) => flatMap$2(scope, (scope) => forkIn$1(self, scope, options)));
 /** @internal */
 const runForkWith = (context) => (effect, options) => {
 	const fiber = new FiberImpl(options?.scheduler ? add$1(context, Scheduler, options.scheduler) : context, options?.uninterruptible !== true);
@@ -6843,6 +6842,17 @@ const runSyncExitWith = (context) => {
 };
 /** @internal */
 const runSyncExit$1 = /*#__PURE__*/ runSyncExitWith(/*#__PURE__*/ empty$3());
+/** @internal */
+const runSyncWith = (context) => {
+	const runSyncExit = runSyncExitWith(context);
+	return (effect) => {
+		const exit = runSyncExit(effect);
+		if (exit._tag === "Failure") throw causeSquash(exit.cause);
+		return exit.value;
+	};
+};
+/** @internal */
+const runSync$2 = /*#__PURE__*/ runSyncWith(/*#__PURE__*/ empty$3());
 const succeedTrue = /*#__PURE__*/ succeed$4(true);
 const succeedFalse = /*#__PURE__*/ succeed$4(false);
 var Latch = class {
@@ -6903,7 +6913,7 @@ var Latch = class {
 		return true;
 	}
 	close = /*#__PURE__*/ sync$1(() => this.closeUnsafe());
-	whenOpen = (self) => flatMap$1(this.await, () => self);
+	whenOpen = (self) => flatMap$2(this.await, () => self);
 	isOpen() {
 		return this._isOpen;
 	}
@@ -8454,6 +8464,43 @@ const effectImpl = (service, effect) => effectContext(map$2(effect, (value) => m
 * @since 2.0.0
 */
 const effectContext = (effect) => fromBuildMemo((_, scope) => provide$2(effect, scope));
+const unwrapKey = /*#__PURE__*/ Service("effect/Layer/unwrap");
+/**
+* Unwraps a `Layer` from an `Effect`, flattening the nested structure.
+*
+* **When to use**
+*
+* Use when you have an `Effect` that produces a `Layer` and you want to
+* use that layer directly.
+*
+* **Details**
+*
+* The resulting Layer will have the combined error and dependency types from
+* both the outer Effect and the inner Layer.
+*
+* **Example** (Unwrapping an effectful layer)
+*
+* ```ts import.meta.vitest
+* import { Context, Effect, Layer } from "effect"
+*
+* class Database extends Context.Service<Database, {
+*   readonly query: (sql: string) => Effect.Effect<string>
+* }>()("Database") {}
+*
+* const layerEffect = Effect.succeed(
+*   Layer.succeed(Database, { query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result")) })
+* )
+*
+* const unwrappedLayer = Layer.unwrap(layerEffect)
+* const program = Database.use((database) => database.query("SELECT 1"))
+* Effect.runSync(Effect.provide(program, unwrappedLayer)) // => "result"
+* ```
+*
+* @stability stable
+* @category converting
+* @since 4.0.0
+*/
+const unwrap$6 = (self) => flatMap$1(effect(unwrapKey)(self), get(unwrapKey));
 const mergeAllEffect = (layers, memoMap, scope) => {
 	const parentScope = forkUnsafe(scope, "parallel");
 	return forEach$2(layers, (layer) => layer.build(memoMap, forkUnsafe(parentScope, "sequential")), { concurrency: layers.length }).pipe(map$2((context) => mergeAll$1(...context)));
@@ -8508,7 +8555,7 @@ const mergeAllEffect = (layers, memoMap, scope) => {
 * @since 2.0.0
 */
 const mergeAll = (...layers) => fromBuildMemo((memoMap, scope) => mergeAllEffect(layers, memoMap, scope));
-const provideWith = (self, that, f) => fromBuildMemo((memoMap, scope) => flatMap$1(Array.isArray(that) ? mergeAllEffect(that, memoMap, scope) : that.build(memoMap, scope), (context) => self.build(memoMap, scope).pipe(provideContext(context), map$2((merged) => f(merged, context)))));
+const provideWith = (self, that, f) => fromBuildMemo((memoMap, scope) => flatMap$2(Array.isArray(that) ? mergeAllEffect(that, memoMap, scope) : that.build(memoMap, scope), (context) => self.build(memoMap, scope).pipe(provideContext(context), map$2((merged) => f(merged, context)))));
 /**
 * Feeds the output services of the dependency layer into the requirements of
 * this layer, returning a layer that provides both sets of services.
@@ -8597,6 +8644,83 @@ const provideWith = (self, that, f) => fromBuildMemo((memoMap, scope) => flatMap
 * @since 2.0.0
 */
 const provideMerge = /*#__PURE__*/ dual(2, (self, that) => provideWith(self, that, (self, that) => merge$2(that, self)));
+/**
+* Constructs a layer dynamically based on the output of this layer.
+*
+* **Example** (Creating services from layer output)
+*
+* ```ts import.meta.vitest
+* import { Context, Effect, Layer } from "effect"
+*
+* class Config extends Context.Service<Config, {
+*   readonly dbUrl: string
+*   readonly logLevel: string
+* }>()("Config") {}
+*
+* class Database extends Context.Service<Database, {
+*   readonly query: (sql: string) => Effect.Effect<string>
+* }>()("Database") {}
+*
+* class Logger extends Context.Service<Logger, {
+*   readonly log: (msg: string) => Effect.Effect<void>
+* }>()("Logger") {}
+*
+* const logs: Array<string> = []
+*
+* // Base config layer
+* const configLayer = Layer.succeed(Config, {
+*   dbUrl: "postgres://localhost:5432/mydb",
+*   logLevel: "debug"
+* })
+*
+* // Dynamically create services based on config
+* const dynamicServiceLayer = configLayer.pipe(
+*   Layer.flatMap((context) => {
+*     const config = Context.get(context, Config)
+*
+*     // Create database layer based on config
+*     const dbLayer = Layer.succeed(Database, {
+*       query: Effect.fn("Database.query")((sql: string) =>
+*         Effect.succeed(
+*           `Querying ${config.dbUrl}: ${sql}`
+*         ))
+*     })
+*
+*     // Create logger layer based on config
+*     const loggerLayer = Layer.succeed(Logger, {
+*       log: Effect.fn("Logger.log")((msg: string) =>
+*         config.logLevel === "debug"
+*           ? Effect.sync(() => logs.push(`[DEBUG] ${msg}`))
+*           : Effect.sync(() => logs.push(msg))
+*       )
+*     })
+*
+*     // Return combined layer
+*     return Layer.mergeAll(dbLayer, loggerLayer)
+*   })
+* )
+*
+* // Use the dynamic services
+* const program = Effect.gen(function*() {
+*   const database = yield* Database
+*   const logger = yield* Logger
+*
+*   yield* logger.log("Starting database query")
+*   const result = yield* database.query("SELECT * FROM users")
+*
+*   return result
+* }).pipe(
+*   Effect.provide(dynamicServiceLayer)
+* )
+* Effect.runSync(program) // => "Querying postgres://localhost:5432/mydb: SELECT * FROM users"
+* logs // => ["[DEBUG] Starting database query"]
+* ```
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const flatMap$1 = /*#__PURE__*/ dual(2, (self, f) => fromBuild((memoMap, scope) => flatMap$2(self.build(memoMap, scope), (context) => f(context).build(memoMap, scope))));
 //#endregion
 //#region node_modules/effect/dist/internal/dateTime.js
 /** @internal */
@@ -8807,7 +8931,7 @@ const matchEffect$1 = /*#__PURE__*/ dual(2, (self, options) => matchCauseEffect$
 }));
 //#endregion
 //#region node_modules/effect/dist/internal/layer.js
-const provideLayer = (self, layer, options) => scopedWith$1((scope) => flatMap$1(options?.local ? buildWithMemoMap(layer, makeMemoMapUnsafe(), scope) : buildWithScope(layer, scope), (context) => provideContext(self, context)));
+const provideLayer = (self, layer, options) => scopedWith$1((scope) => flatMap$2(options?.local ? buildWithMemoMap(layer, makeMemoMapUnsafe(), scope) : buildWithScope(layer, scope), (context) => provideContext(self, context)));
 /** @internal */
 const provide$1 = /*#__PURE__*/ dual((args) => isEffect(args[0]), (self, source, options) => isContext(source) ? provideContext(self, source) : provideLayer(self, Array.isArray(source) ? mergeAll(...source) : source, options));
 //#endregion
@@ -9681,7 +9805,7 @@ const withFiber = withFiber$1;
 * @category sequencing
 * @since 2.0.0
 */
-const flatMap = flatMap$1;
+const flatMap = flatMap$2;
 /**
 * Runs this effect and then runs another effect, optionally using the first
 * effect's success value to choose the next effect.
@@ -11221,6 +11345,65 @@ const runFork = runFork$1;
 */
 const runPromise = runPromise$1;
 /**
+* Executes an effect synchronously and returns its success value.
+*
+* **When to use**
+*
+* Use when you need to execute an effect that is guaranteed to complete
+* synchronously.
+*
+* **Details**
+*
+* If the effect fails, dies, or is interrupted, `runSync` throws the squashed
+* cause instead of returning a value. Typed errors can be thrown directly,
+* including non-Error values. Asynchronous work throws `Cause.AsyncFiberError`.
+* Use `runSyncExit` when you want the failure captured as an `Exit`.
+*
+* **Example** (Running a synchronous effect)
+*
+* ```ts import.meta.vitest
+* import { Effect } from "effect"
+* const output: Array<unknown> = []
+*
+* const program = Effect.sync(() => {
+*   void output.push("Hello, World!")
+*   return 1
+* })
+*
+* const result = Effect.runSync(program)
+* void output.push(result)
+* output // => ["Hello, World!", 1]
+* ```
+*
+* **Example** (Throwing for failed or async effects)
+*
+* ```ts import.meta.vitest
+* import { Effect } from "effect"
+* const output: Array<unknown> = []
+*
+* try {
+*   // Attempt to run an effect that fails
+*   Effect.runSync(Effect.fail("my error"))
+* } catch (e) {
+*   void output.push("failed effect")
+* }
+* try {
+*   // Attempt to run an effect that involves async work
+*   Effect.runSync(Effect.promise(() => Promise.resolve(1)))
+* } catch (e) {
+*   void output.push("async effect")
+* }
+* output // => ["failed effect", "async effect"]
+* ```
+*
+* @see {@link runSyncExit} for a version that returns an `Exit` type instead of
+* throwing an error.
+* @stability stable
+* @category running
+* @since 2.0.0
+*/
+const runSync$1 = runSync$2;
+/**
 * Runs an effect synchronously and captures the outcome safely as an `Exit` type, which
 * represents the outcome (success or failure) of the effect.
 *
@@ -13265,7 +13448,7 @@ const coerce = (value) => isRedacted(value) ? value : String(value);
 //#endregion
 //#region node_modules/effect/dist/internal/schema/annotations.js
 /** @internal */
-function resolve$2(ast) {
+function resolve$3(ast) {
 	return ast.checks ? ast.checks[ast.checks.length - 1].annotations : ast.annotations;
 }
 /** @internal */
@@ -13274,7 +13457,7 @@ const SENTINELS_ANNOTATION_KEY = "~sentinels";
 const CONSTRUCTOR_ANNOTATION_KEY = "~constructor";
 /** @internal */
 const getExpected = /*#__PURE__*/ memoize((ast) => {
-	const identifier = resolve$2(ast)?.identifier;
+	const identifier = resolve$3(ast)?.identifier;
 	if (typeof identifier === "string") return identifier;
 	return ast.getExpected(getExpected);
 });
@@ -15993,8 +16176,8 @@ function compile$1(ast, compile, compileField, base, specialize) {
 /** @internal */
 const invalid = /*#__PURE__*/ Symbol();
 const cache = /*#__PURE__*/ new WeakMap();
-const decodeChild = (ast) => resolve$1(ast).parser;
-const makeChild = (ast) => resolve$1(ast).makeEffect;
+const decodeChild = (ast) => resolve$2(ast).parser;
+const makeChild = (ast) => resolve$2(ast).makeEffect;
 const makeField = (ast) => compileField(ast, makeChild);
 var InterpretedEntry = class {
 	ast;
@@ -16012,7 +16195,7 @@ var InterpretedEntry = class {
 	}
 };
 /** @internal */
-function resolve$1(ast) {
+function resolve$2(ast) {
 	const cached = cache.get(ast);
 	if (cached !== void 0) return cached;
 	const entry = new InterpretedEntry(ast);
@@ -16183,7 +16366,7 @@ function throwConstructorDefect(error) {
 }
 function makeConstructorSync(ast) {
 	let entry;
-	return (input, options) => constructSync(entry ??= resolve$1(ast), input, options);
+	return (input, options) => constructSync(entry ??= resolve$2(ast), input, options);
 }
 function constructSync(entry, input, options) {
 	const parseOptions = options?.disableChecks ? options.parseOptions ? {
@@ -16202,8 +16385,8 @@ function constructSync(entry, input, options) {
 	}
 	return runSync(parserResult(entry.makeEffect(input, parseOptions), input), constructorDefectMessage);
 }
-const normalCompiler = (ast) => resolve$1(ast).parser;
-const constructorCompiler = (ast) => resolve$1(ast).makeEffect;
+const normalCompiler = (ast) => resolve$2(ast).parser;
+const constructorCompiler = (ast) => resolve$2(ast).makeEffect;
 //#endregion
 //#region node_modules/effect/dist/internal/schema/make.js
 /** @internal */
@@ -17627,7 +17810,7 @@ const splitSegments = (pattern) => {
 const drive = /^[A-Za-z]:/;
 const isDrive = (segment) => segment.length === 2 && drive.test(segment);
 const isRoot = (name) => name === "" || name.length === 3 && name[2] === "/" && drive.test(name);
-const isAbsolute$1 = (path) => path.startsWith("/") || path[2] === "/" && drive.test(path);
+const isAbsolute = (path) => path.startsWith("/") || path[2] === "/" && drive.test(path);
 const normalize = (raw) => {
 	const segments = [];
 	let i = 0;
@@ -17970,7 +18153,7 @@ const needsDirectory = (compiled, states) => {
 	}
 	return false;
 };
-const join$1 = (parent, name) => {
+const join = (parent, name) => {
 	if (parent === "") return name === "" ? "/" : name;
 	return parent.endsWith("/") ? parent + name : `${parent}/${name}`;
 };
@@ -17985,10 +18168,10 @@ const walk = /*#__PURE__*/ fnUntraced(function* (fs, compiled, options) {
 	const root = options?.root ?? "";
 	const excludes = compile(options?.exclude ?? [], true);
 	const excludeNeedsDirectory = excludes.nodes.some((node) => node._tag === "End" && node.directoryOnly);
-	const toFsPath = (relative) => isAbsolute$1(relative) ? relative : relative === "" ? root === "" ? "." : root : join$1(root, relative);
+	const toFsPath = (relative) => isAbsolute(relative) ? relative : relative === "" ? root === "" ? "." : root : join(root, relative);
 	const isUnlisted = (value) => value === "." || value === ".." || isRoot(value);
 	const probe = (parent, name, named) => {
-		const path = toFsPath(join$1(parent, name));
+		const path = toFsPath(join(parent, name));
 		return fs.stat(path).pipe(map((info) => info.type), catchReason("PlatformError", "NotFound", () => fs.readLink(path).pipe(as("SymbolicLink"), catchIf(isNotLink, () => succeed$1(void 0)))), catchIf(named ? isMissing : isIgnorable, () => succeed$1(void 0)), map((type) => type === void 0 ? void 0 : {
 			name,
 			type
@@ -18012,7 +18195,7 @@ const walk = /*#__PURE__*/ fnUntraced(function* (fs, compiled, options) {
 		const result = step(compiled, states, name);
 		const next = union(result);
 		if (next.size === 0) return;
-		const relative = join$1(parent, name);
+		const relative = join(parent, name);
 		const nextExcluded = union(step(excludes, excluded, name));
 		const descend = canDescend(compiled, next);
 		const isDirectory = !descend && !needsDirectory(compiled, next) && !excludeNeedsDirectory ? false : type !== "Unknown" && type !== "SymbolicLink" ? type === "Directory" : yield* fs.stat(toFsPath(relative)).pipe(map((info) => info.type === "Directory"), catchIf(isIgnorable, () => succeed$1(false)));
@@ -19295,6 +19478,388 @@ const make$3 = (impl) => Path$1.of({
 		return relative === ".." || relative.startsWith(`..${impl.sep}`) || impl.isAbsolute(relative) ? none() : some(candidate);
 	}
 });
+/**
+* The following functions are adapted from the Node.js source code:
+* https://github.com/nodejs/node/blob/main/lib/internal/url.js
+*
+* The following license applies to these functions:
+* - MIT
+*/
+function normalizeStringPosix(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let code;
+	for (let i = 0; i <= path.length; ++i) {
+		if (i < path.length) code = path.charCodeAt(i);
+		else if (code === 47) break;
+		else code = 47;
+		if (code === 47) {
+			if (lastSlash === i - 1 || dots === 1) {} else if (lastSlash !== i - 1 && dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex !== res.length - 1) {
+							if (lastSlashIndex === -1) {
+								res = "";
+								lastSegmentLength = 0;
+							} else {
+								res = res.slice(0, lastSlashIndex);
+								lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+							}
+							lastSlash = i;
+							dots = 0;
+							continue;
+						}
+					} else if (res.length === 2 || res.length === 1) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = i;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					if (res.length > 0) res += "/..";
+					else res = "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += "/" + path.slice(lastSlash + 1, i);
+				else res = path.slice(lastSlash + 1, i);
+				lastSegmentLength = i - lastSlash - 1;
+			}
+			lastSlash = i;
+			dots = 0;
+		} else if (code === 46 && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+function _format(sep, pathObject) {
+	const dir = pathObject.dir || pathObject.root;
+	const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+	if (!dir) return base;
+	if (dir === pathObject.root) return dir + base;
+	return dir + sep + base;
+}
+function fromFileUrl(url) {
+	if (url.protocol !== "file:") return fail$4(new BadArgument({
+		module: "Path",
+		method: "fromFileUrl",
+		description: "URL must be of scheme file"
+	}));
+	else if (url.hostname !== "") return fail$4(new BadArgument({
+		module: "Path",
+		method: "fromFileUrl",
+		description: "Invalid file URL host"
+	}));
+	const pathname = url.pathname;
+	for (let n = 0; n < pathname.length; n++) if (pathname[n] === "%") {
+		const third = pathname.codePointAt(n + 2) | 32;
+		if (pathname[n + 1] === "2" && third === 102) return fail$4(new BadArgument({
+			module: "Path",
+			method: "fromFileUrl",
+			description: "must not include encoded / characters"
+		}));
+	}
+	return try_({
+		try: () => decodeURIComponent(pathname),
+		catch: (cause) => new BadArgument({
+			module: "Path",
+			method: "fromFileUrl",
+			cause
+		})
+	});
+}
+const resolve$1 = function resolve() {
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	let cwd = void 0;
+	for (let i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+		let path;
+		if (i >= 0) path = arguments[i];
+		else {
+			const process = globalThis.process;
+			if (cwd === void 0 && "process" in globalThis && typeof process === "object" && process !== null && typeof process.cwd === "function") cwd = process.cwd();
+			path = cwd;
+		}
+		if (path.length === 0) continue;
+		resolvedPath = path + "/" + resolvedPath;
+		resolvedAbsolute = path.charCodeAt(0) === 47;
+	}
+	resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute) if (resolvedPath.length > 0) return "/" + resolvedPath;
+	else return "/";
+	else if (resolvedPath.length > 0) return resolvedPath;
+	else return ".";
+};
+const CHAR_FORWARD_SLASH = 47;
+function toFileUrl(filepath) {
+	const outURL = new URL("file://");
+	let resolved = resolve$1(filepath);
+	if (filepath.charCodeAt(filepath.length - 1) === CHAR_FORWARD_SLASH && resolved[resolved.length - 1] !== "/") resolved += "/";
+	outURL.pathname = encodePathChars(resolved);
+	return succeed$1(outURL);
+}
+const percentRegExp = /%/g;
+const backslashRegExp = /\\/g;
+const newlineRegExp = /\n/g;
+const carriageReturnRegExp = /\r/g;
+const tabRegExp = /\t/g;
+function encodePathChars(filepath) {
+	if (filepath.includes("%")) filepath = filepath.replace(percentRegExp, "%25");
+	if (filepath.includes("\\")) filepath = filepath.replace(backslashRegExp, "%5C");
+	if (filepath.includes("\n")) filepath = filepath.replace(newlineRegExp, "%0A");
+	if (filepath.includes("\r")) filepath = filepath.replace(carriageReturnRegExp, "%0D");
+	if (filepath.includes("	")) filepath = filepath.replace(tabRegExp, "%09");
+	return filepath;
+}
+const posixImpl = /*#__PURE__*/ make$3({
+	resolve: resolve$1,
+	normalize(path) {
+		if (path.length === 0) return ".";
+		const isAbsolute = path.charCodeAt(0) === 47;
+		const trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+		path = normalizeStringPosix(path, !isAbsolute);
+		if (path.length === 0 && !isAbsolute) path = ".";
+		if (path.length > 0 && trailingSeparator) path += "/";
+		if (isAbsolute) return "/" + path;
+		return path;
+	},
+	isAbsolute(path) {
+		return path.length > 0 && path.charCodeAt(0) === 47;
+	},
+	join() {
+		if (arguments.length === 0) return ".";
+		let joined;
+		for (let i = 0; i < arguments.length; ++i) {
+			const arg = arguments[i];
+			if (arg.length > 0) if (joined === void 0) joined = arg;
+			else joined += "/" + arg;
+		}
+		if (joined === void 0) return ".";
+		return posixImpl.normalize(joined);
+	},
+	relative(from, to) {
+		if (from === to) return "";
+		from = posixImpl.resolve(from);
+		to = posixImpl.resolve(to);
+		if (from === to) return "";
+		let fromStart = 1;
+		for (; fromStart < from.length; ++fromStart) if (from.charCodeAt(fromStart) !== 47) break;
+		const fromEnd = from.length;
+		const fromLen = fromEnd - fromStart;
+		let toStart = 1;
+		for (; toStart < to.length; ++toStart) if (to.charCodeAt(toStart) !== 47) break;
+		const toLen = to.length - toStart;
+		const length = fromLen < toLen ? fromLen : toLen;
+		let lastCommonSep = -1;
+		let i = 0;
+		for (; i <= length; ++i) {
+			if (i === length) {
+				if (toLen > length) {
+					if (to.charCodeAt(toStart + i) === 47) return to.slice(toStart + i + 1);
+					else if (i === 0) return to.slice(toStart + i);
+				} else if (fromLen > length) {
+					if (from.charCodeAt(fromStart + i) === 47) lastCommonSep = i;
+					else if (i === 0) lastCommonSep = 0;
+				}
+				break;
+			}
+			const fromCode = from.charCodeAt(fromStart + i);
+			if (fromCode !== to.charCodeAt(toStart + i)) break;
+			else if (fromCode === 47) lastCommonSep = i;
+		}
+		let out = "";
+		for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) if (i === fromEnd || from.charCodeAt(i) === 47) if (out.length === 0) out += "..";
+		else out += "/..";
+		if (out.length > 0) return out + to.slice(toStart + lastCommonSep);
+		else {
+			toStart += lastCommonSep;
+			if (to.charCodeAt(toStart) === 47) ++toStart;
+			return to.slice(toStart);
+		}
+	},
+	dirname(path) {
+		if (path.length === 0) return ".";
+		let code = path.charCodeAt(0);
+		const hasRoot = code === 47;
+		let end = -1;
+		let matchedSlash = true;
+		for (let i = path.length - 1; i >= 1; --i) {
+			code = path.charCodeAt(i);
+			if (code === 47) {
+				if (!matchedSlash) {
+					end = i;
+					break;
+				}
+			} else matchedSlash = false;
+		}
+		if (end === -1) return hasRoot ? "/" : ".";
+		if (hasRoot && end === 1) return "//";
+		return path.slice(0, end);
+	},
+	basename(path, ext) {
+		let start = 0;
+		let end = -1;
+		let matchedSlash = true;
+		let i;
+		if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
+			if (ext.length === path.length && ext === path) return "";
+			let extIdx = ext.length - 1;
+			let firstNonSlashEnd = -1;
+			for (i = path.length - 1; i >= 0; --i) {
+				const code = path.charCodeAt(i);
+				if (code === 47) {
+					if (!matchedSlash) {
+						start = i + 1;
+						break;
+					}
+				} else {
+					if (firstNonSlashEnd === -1) {
+						matchedSlash = false;
+						firstNonSlashEnd = i + 1;
+					}
+					if (extIdx >= 0) if (code === ext.charCodeAt(extIdx)) {
+						if (--extIdx === -1) end = i;
+					} else {
+						extIdx = -1;
+						end = firstNonSlashEnd;
+					}
+				}
+			}
+			if (start === end) end = firstNonSlashEnd;
+			else if (end === -1) end = path.length;
+			return path.slice(start, end);
+		} else {
+			for (i = path.length - 1; i >= 0; --i) if (path.charCodeAt(i) === 47) {
+				if (!matchedSlash) {
+					start = i + 1;
+					break;
+				}
+			} else if (end === -1) {
+				matchedSlash = false;
+				end = i + 1;
+			}
+			if (end === -1) return "";
+			return path.slice(start, end);
+		}
+	},
+	extname(path) {
+		let startDot = -1;
+		let startPart = 0;
+		let end = -1;
+		let matchedSlash = true;
+		let preDotState = 0;
+		for (let i = path.length - 1; i >= 0; --i) {
+			const code = path.charCodeAt(i);
+			if (code === 47) {
+				if (!matchedSlash) {
+					startPart = i + 1;
+					break;
+				}
+				continue;
+			}
+			if (end === -1) {
+				matchedSlash = false;
+				end = i + 1;
+			}
+			if (code === 46) {
+				if (startDot === -1) startDot = i;
+				else if (preDotState !== 1) preDotState = 1;
+			} else if (startDot !== -1) preDotState = -1;
+		}
+		if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) return "";
+		return path.slice(startDot, end);
+	},
+	format: function format(pathObject) {
+		if (pathObject === null || typeof pathObject !== "object") throw new TypeError("The \"pathObject\" argument must be of type Object. Received type " + typeof pathObject);
+		return _format("/", pathObject);
+	},
+	parse(path) {
+		const ret = {
+			root: "",
+			dir: "",
+			base: "",
+			ext: "",
+			name: ""
+		};
+		if (path.length === 0) return ret;
+		let code = path.charCodeAt(0);
+		const isAbsolute = code === 47;
+		let start;
+		if (isAbsolute) {
+			ret.root = "/";
+			start = 1;
+		} else start = 0;
+		let startDot = -1;
+		let startPart = 0;
+		let end = -1;
+		let matchedSlash = true;
+		let i = path.length - 1;
+		let preDotState = 0;
+		for (; i >= start; --i) {
+			code = path.charCodeAt(i);
+			if (code === 47) {
+				if (!matchedSlash) {
+					startPart = i + 1;
+					break;
+				}
+				continue;
+			}
+			if (end === -1) {
+				matchedSlash = false;
+				end = i + 1;
+			}
+			if (code === 46) {
+				if (startDot === -1) startDot = i;
+				else if (preDotState !== 1) preDotState = 1;
+			} else if (startDot !== -1) preDotState = -1;
+		}
+		if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+			if (end !== -1) if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);
+			else ret.base = ret.name = path.slice(startPart, end);
+		} else {
+			if (startPart === 0 && isAbsolute) {
+				ret.name = path.slice(1, startDot);
+				ret.base = path.slice(1, end);
+			} else {
+				ret.name = path.slice(startPart, startDot);
+				ret.base = path.slice(startPart, end);
+			}
+			ret.ext = path.slice(startDot, end);
+		}
+		if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
+		else if (isAbsolute) ret.dir = "/";
+		return ret;
+	},
+	sep: "/",
+	fromFileUrl,
+	toFileUrl,
+	toNamespacedPath: identity
+});
+/**
+* Layer that provides the built-in POSIX `Path` implementation.
+*
+* **When to use**
+*
+* Use when you need an effect that requires the `Path` service to run with the
+* built-in POSIX path implementation.
+*
+* **Details**
+*
+* The layer provides a static service whose separator is `/` and whose
+* operations use POSIX path semantics.
+*
+* @see {@link Path} for accessing the `Path` service from an effect
+*
+* @stability unstable
+* @category layers
+* @since 4.0.0
+*/
+const layer$4 = /*#__PURE__*/ succeed$2(Path$1)(posixImpl);
 //#endregion
 //#region node_modules/effect/dist/process/ChildProcessSpawner.js
 /**
@@ -19843,20 +20408,95 @@ const shellScript = (templates, expressions) => {
 	return script;
 };
 //#endregion
+//#region src/platform/NodeRuntime.ts
+const gzip = (source) => gzipSync(source, { level: 9 });
+/** Compiles `source` as a script in this realm, reporting errors against `filename`. */
+const compileScript = (source, filename) => runInThisContext(source, { filename });
+//#endregion
+//#region src/platform/NodeSync.ts
+const MAX_BUFFER = 256 * 1024 * 1024;
+const isAbsent = (e) => {
+	const code = e.code;
+	return code === "ENOENT" || code === "ENOTDIR";
+};
+const orAbsent = (read) => {
+	try {
+		return read();
+	} catch (e) {
+		if (isAbsent(e)) return void 0;
+		throw e;
+	}
+};
+const infoOf = (stats) => ({
+	type: stats.isSymbolicLink() ? "symlink" : stats.isDirectory() ? "directory" : stats.isFile() ? "file" : "other",
+	uid: process.platform === "win32" ? void 0 : stats.uid
+});
+const nodeSyncIo = {
+	readFile: (path) => orAbsent(() => readFileSync(path)),
+	readText: (path) => orAbsent(() => readFileSync(path, "utf8")),
+	writeText: (path, content) => writeFileSync(path, content, "utf8"),
+	makeDirectory: (path) => {
+		mkdirSync(path, { recursive: true });
+	},
+	rename: renameSync,
+	stat: (path) => orAbsent(() => infoOf(statSync(path))),
+	lstat: (path) => orAbsent(() => infoOf(lstatSync(path))),
+	readLink: (path) => readlinkSync(path, "utf8"),
+	realPath: (path) => realpathSync(path),
+	git: (cwd, args) => execFileSync("git", args, {
+		cwd,
+		encoding: "utf8",
+		maxBuffer: MAX_BUFFER
+	}),
+	gitBytes: (cwd, args) => execFileSync("git", args, {
+		cwd,
+		maxBuffer: MAX_BUFFER,
+		stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		]
+	}),
+	hash: (algorithm, ...parts) => {
+		const hash = createHash(algorithm);
+		for (const part of parts) hash.update(part);
+		return hash.digest("hex");
+	}
+};
+//#endregion
 //#region src/platform/Host.ts
 const toError$3 = (e) => e instanceof Error ? e : new Error(String(e));
-const makeHostOps = (opts) => ({
-	root: opts.root,
-	home: opts.home,
-	env: opts.env,
-	scratchDir: opts.scratchDir ?? (opts.env["TMPDIR"] !== void 0 && opts.env["TMPDIR"].length > 0 ? opts.env["TMPDIR"] : tmpdir()),
-	realPath: opts.realPath ?? ((path) => try_({
-		try: () => realpathSync(path),
-		catch: toError$3
-	}))
+/** `TMPDIR` when set and non-empty, else the host's own `fallback`. */
+const scratchDirOf = (env, fallback) => {
+	const dir = env["TMPDIR"];
+	return dir !== void 0 && dir.length > 0 ? dir : fallback;
+};
+const readAll = (stream) => tryPromise({
+	try: async () => {
+		const chunks = [];
+		for await (const chunk of stream) chunks.push(Buffer.from(chunk));
+		return Buffer.concat(chunks).toString("utf8");
+	},
+	catch: toError$3
 });
+const makeHostOps = (opts, proc) => {
+	const script = proc.argv[1];
+	return {
+		scratchDir: scratchDirOf(opts.env, tmpdir()),
+		realPath: (path) => try_({
+			try: () => nodeSyncIo.realPath(path),
+			catch: toError$3
+		}),
+		pid: proc.pid,
+		uid: proc.getuid?.(),
+		self: script === void 0 ? ["gtd"] : [proc.execPath, script],
+		stdin: suspend$2(() => readAll(proc.stdin)),
+		...opts
+	};
+};
+/** Every member not given in `opts` comes from Node: `proc`, its OS and its file system. */
 var Host = class Host extends Service()("Host") {
-	static layer = (opts) => succeed$2(Host, makeHostOps(opts));
+	static layer = (opts, proc = process) => succeed$2(Host, makeHostOps(opts, proc));
 	static Live = Host.layer({
 		root: process.cwd(),
 		home: homedir(),
@@ -20135,16 +20775,14 @@ var GitService = class GitService extends Service()("GitService") {
 //#endregion
 //#region src/platform/Workspace.ts
 const toError$2 = (e) => e instanceof Error ? e : new Error(String(e));
-const MAX_BUFFER = 256 * 1024 * 1024;
 const HASH_CHUNK = 500;
+const encoder$2 = new TextEncoder();
 /** A full sha1 or sha256 object id — the only refs an immutable, disk-cached read is safe to key on. */
 const isObjectHash = (ref) => /^[0-9a-f]{40}$|^[0-9a-f]{64}$/.test(ref);
 const GTD_CACHE_SUBDIR = "gtd-cache";
-const treeCachePath = (commonDir, hash) => join(commonDir, GTD_CACHE_SUBDIR, "trees", hash);
-const blobCachePath = (commonDir, id) => join(commonDir, GTD_CACHE_SUBDIR, "blobs", id);
-const readTextCache = (path) => {
+const readTextCache = (io, path) => {
 	try {
-		return readFileSync(path, "utf8");
+		return io.readText(path);
 	} catch {
 		return;
 	}
@@ -20157,17 +20795,17 @@ const readTextCache = (path) => {
 * cache is a best-effort speedup, never a correctness dependency, and the
 * alternative — failing a gtd command over a cache write — is worse.
 */
-const writeTextCacheAtomic = (path, content) => {
+const writeTextCacheAtomic = (io, paths, pid, path, content) => {
 	try {
-		mkdirSync(dirname(path), { recursive: true });
-		const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-		writeFileSync(tmp, content, "utf8");
-		renameSync(tmp, path);
+		io.makeDirectory(paths.dirname(path));
+		const tmp = `${path}.tmp-${pid}-${Math.random().toString(36).slice(2)}`;
+		io.writeText(tmp, content);
+		io.rename(tmp, path);
 	} catch {}
 };
 /** A commit's `path → blob id` map, serialized as JSON. `undefined` on ANY read failure — missing, truncated, unparseable — so the caller falls back to asking git. */
-const readTreeCache = (commonDir, hash) => {
-	const raw = readTextCache(treeCachePath(commonDir, hash));
+const readTreeCache = (io, file) => {
+	const raw = readTextCache(io, file);
 	if (raw === void 0) return void 0;
 	try {
 		const parsed = JSON.parse(raw);
@@ -20182,7 +20820,7 @@ const readTreeCache = (commonDir, hash) => {
 		return;
 	}
 };
-const writeTreeCache = (commonDir, hash, tree) => writeTextCacheAtomic(treeCachePath(commonDir, hash), JSON.stringify(Object.fromEntries(tree)));
+const writeTreeCache = (io, paths, pid, file, tree) => writeTextCacheAtomic(io, paths, pid, file, JSON.stringify(Object.fromEntries(tree)));
 /** Parses a `:`-prefixed raw-diff header token into its status letter and new blob id. */
 const parseRawDiffHeader = (header) => {
 	const fields = header.slice(1).split(" ").filter((f) => f.length > 0);
@@ -20266,21 +20904,17 @@ const parseLsTree = (out) => {
 * failed read rather than from the key itself, so callers that cache must
 * check `ok` before doing so.
 */
-const fetchTree = (root, ref) => {
+const fetchTree = (io, root, ref) => {
 	try {
 		return {
 			ok: true,
-			entries: parseLsTree(execFileSync("git", [
+			entries: parseLsTree(io.git(root, [
 				"ls-tree",
 				"-r",
 				"-z",
 				"--full-tree",
 				ref
-			], {
-				cwd: root,
-				encoding: "utf8",
-				maxBuffer: MAX_BUFFER
-			}))
+			]))
 		};
 	} catch {
 		return {
@@ -20289,26 +20923,10 @@ const fetchTree = (root, ref) => {
 		};
 	}
 };
-const assertRepoRelative = (path) => {
-	if (isAbsolute(path)) throw new Error(`Workspace: "${path}" is an absolute path — this member takes repo-relative paths only (use "atPath"/"writeAtPath" to read/write outside the repo)`);
+const assertRepoRelative = (paths, path) => {
+	if (paths.isAbsolute(path)) throw new Error(`Workspace: "${path}" is an absolute path — this member takes repo-relative paths only (use "atPath"/"writeAtPath" to read/write outside the repo)`);
 	return path;
 };
-const readFileOrAbsent = (path) => {
-	try {
-		return readFileSync(path, "utf8");
-	} catch (e) {
-		if (e.code === "ENOENT") return void 0;
-		throw e;
-	}
-};
-const lstatOrAbsent = (path) => {
-	try {
-		return lstatSync(path);
-	} catch (e) {
-		if (e.code === "ENOENT") return void 0;
-		throw e;
-	}
-};
 /**
 * Runs `git log --raw` for `base..head` (or all of `head`'s first-parent
 * history when `base` is `undefined`) and splits the output into one
@@ -20316,8 +20934,9 @@ const lstatOrAbsent = (path) => {
 * count, same hashes, in order — since the two disagreeing means the episode
 * bounds no longer match git's own history.
 */
-const runRawLogReplay = (root, base, head, commits) => {
-	const chunks = execFileSync("git", [
+const runRawLogReplay = (io, root, base, head, commits) => {
+	const range = base !== void 0 ? `${base}..${head}` : head;
+	const chunks = io.git(root, [
 		"log",
 		"--first-parent",
 		"--reverse",
@@ -20326,12 +20945,8 @@ const runRawLogReplay = (root, base, head, commits) => {
 		"-r",
 		"--no-abbrev",
 		"--format=%x01%H",
-		base !== void 0 ? `${base}..${head}` : head
-	], {
-		cwd: root,
-		encoding: "utf8",
-		maxBuffer: MAX_BUFFER
-	}).split("
").filter((c) => c.length > 0);
+		range
+	]).split("
").filter((c) => c.length > 0);
 	if (chunks.length !== commits.length) throw new Error(`gtd: episode reconstruction expected ${commits.length} commit(s) from git log, got ${chunks.length} — the episode bounds disagree with git's own history`);
 	return chunks.map((chunk, i) => {
 		const nul = chunk.indexOf("\0");
@@ -20357,8 +20972,11 @@ const foldRawDiffs = (baseTree, replay, rememberTree) => {
 	}
 	return result;
 };
-const makeWorkspaceOps = (root, git, commonDir) => {
-	const resolveAny = (path) => isAbsolute(path) ? path : join(root, path);
+const makeWorkspaceOps = ({ root, pid }, git, commonDir, paths, io) => {
+	const resolveAny = (path) => paths.isAbsolute(path) ? path : paths.join(root, path);
+	const repoPath = (path) => paths.join(root, assertRepoRelative(paths, path));
+	const treeCachePath = (dir, hash) => paths.join(dir, GTD_CACHE_SUBDIR, "trees", hash);
+	const blobCachePath = (dir, id) => paths.join(dir, GTD_CACHE_SUBDIR, "blobs", id);
 	const treeMemo = /* @__PURE__ */ new Map();
 	const blobMemo = /* @__PURE__ */ new Map();
 	/** A commit's tree, from the in-process memo or the on-disk cache — no subprocess. `undefined` on a cold miss. */
@@ -20366,15 +20984,15 @@ const makeWorkspaceOps = (root, git, commonDir) => {
 		const memoHit = treeMemo.get(hash);
 		if (memoHit !== void 0) return memoHit;
 		if (commonDir === void 0) return void 0;
-		const cached = readTreeCache(commonDir, hash);
+		const cached = readTreeCache(io, treeCachePath(commonDir, hash));
 		if (cached !== void 0) treeMemo.set(hash, cached);
 		return cached;
 	};
 	const rememberTree = (hash, tree) => {
 		treeMemo.set(hash, tree);
-		if (commonDir !== void 0) writeTreeCache(commonDir, hash, tree);
+		if (commonDir !== void 0) writeTreeCache(io, paths, pid, treeCachePath(commonDir, hash), tree);
 	};
-	const readSync = (path) => readFileOrAbsent(join(root, assertRepoRelative(path)));
+	const readSync = (path) => io.readText(repoPath(path));
 	/**
 	* A blob's content, keyed on its OWN id rather than a (path, ref) pair —
 	* the same content read from two different commits costs one read, not
@@ -20386,7 +21004,7 @@ const makeWorkspaceOps = (root, git, commonDir) => {
 		const memoHit = blobMemo.get(id);
 		if (memoHit !== void 0) return memoHit;
 		if (commonDir !== void 0) {
-			const cached = readTextCache(blobCachePath(commonDir, id));
+			const cached = readTextCache(io, blobCachePath(commonDir, id));
 			if (cached !== void 0) {
 				blobMemo.set(id, cached);
 				return cached;
@@ -20394,34 +21012,26 @@ const makeWorkspaceOps = (root, git, commonDir) => {
 		}
 		let content;
 		try {
-			content = execFileSync("git", [
+			content = io.git(root, [
 				"cat-file",
 				"-p",
 				id
-			], {
-				cwd: root,
-				encoding: "utf8",
-				maxBuffer: MAX_BUFFER
-			});
+			]);
 		} catch {
 			return;
 		}
 		blobMemo.set(id, content);
-		if (commonDir !== void 0) writeTextCacheAtomic(blobCachePath(commonDir, id), content);
+		if (commonDir !== void 0) writeTextCacheAtomic(io, paths, pid, blobCachePath(commonDir, id), content);
 		return content;
 	};
 	const readCommittedSync = (path, ref = "HEAD") => {
-		const relPath = assertRepoRelative(path);
+		const relPath = assertRepoRelative(paths, path);
 		if (isObjectHash(ref)) {
 			const id = treeSync(ref).get(relPath);
 			return id === void 0 ? void 0 : readBlobSync(id);
 		}
 		try {
-			return execFileSync("git", ["show", `${ref}:${relPath}`], {
-				cwd: root,
-				encoding: "utf8",
-				maxBuffer: MAX_BUFFER
-			});
+			return io.git(root, ["show", `${ref}:${relPath}`]);
 		} catch {
 			return;
 		}
@@ -20431,7 +21041,7 @@ const makeWorkspaceOps = (root, git, commonDir) => {
 			const cached = peekTree(ref);
 			if (cached !== void 0) return cached;
 		}
-		const { ok, entries } = fetchTree(root, ref);
+		const { ok, entries } = fetchTree(io, root, ref);
 		if (!ok) {
 			if (onFailure === "throw") throw new Error(`gtd: failed to read the tree at "${ref}" — git ls-tree did not succeed`);
 			return entries;
@@ -20466,18 +21076,13 @@ const makeWorkspaceOps = (root, git, commonDir) => {
 				return result;
 			}
 			const head = commits[commits.length - 1];
-			const replay = runRawLogReplay(root, base, head, commits);
+			const replay = runRawLogReplay(io, root, base, head, commits);
 			for (const [hash, tree] of foldRawDiffs(baseTree, replay, rememberTree)) result.set(hash, tree);
 			return result;
 		},
 		catch: toError$2
 	});
-	const gitSync = (args, input) => execFileSync("git", args, {
-		cwd: root,
-		encoding: "utf8",
-		maxBuffer: MAX_BUFFER,
-		...input !== void 0 ? { input } : {}
-	});
+	const gitSync = (args) => io.git(root, args);
 	const worktreeSync = () => {
 		const entries = new Map(treeSync("HEAD"));
 		const status = gitSync([
@@ -20492,10 +21097,10 @@ const makeWorkspaceOps = (root, git, commonDir) => {
 		for (const record of status.split("\0")) {
 			if (record.length < 4) continue;
 			const path = record.slice(3).replace(/\/$/, "");
-			const stat = lstatOrAbsent(join(root, path));
+			const stat = io.lstat(paths.join(root, path));
 			if (stat === void 0) entries.delete(path);
-			else if (stat.isSymbolicLink()) entries.set(path, blobId(readlinkSync(join(root, path), "utf8")));
-			else if (stat.isDirectory()) if (lstatOrAbsent(join(root, path, ".git")) === void 0) entries.delete(path);
+			else if (stat.type === "symlink") entries.set(path, blobId(io.readLink(paths.join(root, path))));
+			else if (stat.type === "directory") if (io.lstat(paths.join(root, path, ".git")) === void 0) entries.delete(path);
 			else entries.set(path, gitlinkOf(path));
 			else files.push(path);
 		}
@@ -20513,10 +21118,7 @@ const makeWorkspaceOps = (root, git, commonDir) => {
 	/** A submodule's (or embedded repository's) checked-out commit — what `git add` records for it. */
 	const gitlinkOf = (path) => {
 		try {
-			return execFileSync("git", ["rev-parse", "HEAD"], {
-				cwd: join(root, path),
-				encoding: "utf8"
-			}).trim();
+			return io.git(paths.join(root, path), ["rev-parse", "HEAD"]).trim();
 		} catch {
 			return;
 		}
@@ -20524,8 +21126,8 @@ const makeWorkspaceOps = (root, git, commonDir) => {
 	let objectFormat;
 	const blobId = (content) => {
 		objectFormat ??= gitSync(["rev-parse", "--show-object-format"]).trim();
-		const bytes = Buffer.from(content, "utf8");
-		return createHash(objectFormat === "sha256" ? "sha256" : "sha1").update(`blob ${bytes.length}\0`).update(bytes).digest("hex");
+		const bytes = encoder$2.encode(content);
+		return io.hash(objectFormat === "sha256" ? "sha256" : "sha1", `blob ${bytes.length}\0`, bytes);
 	};
 	return {
 		treeSync,
@@ -20537,27 +21139,28 @@ const makeWorkspaceOps = (root, git, commonDir) => {
 			catch: toError$2
 		}),
 		write: (path, content) => try_({
-			try: () => writeFileSync(join(root, assertRepoRelative(path)), content, "utf8"),
+			try: () => io.writeText(repoPath(path), content),
 			catch: toError$2
 		}),
 		committed: (path, ref = "HEAD") => try_({
-			try: () => assertRepoRelative(path),
+			try: () => assertRepoRelative(paths, path),
 			catch: toError$2
 		}).pipe(flatMap((relPath) => git.readFileAtRef(ref, relPath).pipe(catch_(() => succeed$1(void 0))))),
 		readCommittedSync,
-		atPath: (path) => readFileOrAbsent(resolveAny(path)),
+		atPath: (path) => io.readText(resolveAny(path)),
 		writeAtPath: (path, content) => try_({
-			try: () => writeFileSync(resolveAny(path), content, "utf8"),
+			try: () => io.writeText(resolveAny(path), content),
 			catch: toError$2
 		})
 	};
 };
 var Workspace = class Workspace extends Service()("Workspace") {
 	static Live = effect(Workspace, gen(function* () {
-		const { root } = yield* Host;
+		const host = yield* Host;
 		const git = yield* GitService;
+		const paths = yield* Path$1;
 		const commonDir = yield* git.gitCommonDir().pipe(catch_(() => succeed$1(void 0)));
-		return makeWorkspaceOps(root, git, commonDir);
+		return makeWorkspaceOps(host, git, commonDir, paths, nodeSyncIo);
 	}));
 };
 //#endregion
@@ -21494,7 +22097,7 @@ const bigintToNumber = (value, field) => {
 	if (!Number.isSafeInteger(number)) throw new RangeError(`${field} exceeds the safe integer range: ${value}`);
 	return number;
 };
-const bigintToNumberOption = (value) => flatMap$3(fromNullishOr(value), toNumber);
+const bigintToNumberOption = (value) => flatMap$4(fromNullishOr(value), toNumber);
 const toUint64 = (value) => BigInt.asUintN(64, value);
 const toUint64Option = (value) => map$6(fromNullishOr(value), toUint64);
 const positionToNumber = (position, method) => try_({
@@ -21848,7 +22451,7 @@ const watchNode = (path, info, options) => callback((queue) => acquireRelease(sy
 	});
 	return watcher;
 }), (watcher) => sync(() => watcher.close())).pipe(tap(() => sync(() => options?.onReady?.()))));
-const watch = (backend, path, options) => all([stat(path), serviceOption(WatchBackend)]).pipe(map(([stat, callerBackend]) => orElse(callerBackend, () => backend).pipe(flatMap$3((_) => _.register(path, stat, options)), getOrElse(() => watchNode(path, stat, options)))), unwrap$2);
+const watch = (backend, path, options) => all([stat(path), serviceOption(WatchBackend)]).pipe(map(([stat, callerBackend]) => orElse(callerBackend, () => backend).pipe(flatMap$4((_) => _.register(path, stat, options)), getOrElse(() => watchNode(path, stat, options)))), unwrap$2);
 const writeFile = (path, data, options) => callback$1((resume, signal) => {
 	try {
 		NFS.writeFile(path, data, {
@@ -21956,11 +22559,12 @@ const GITDIR_POINTER = /^gitdir:\s*(.+)$/m;
 */
 const worktreeGitDir = gen(function* () {
 	const { root } = yield* Host;
+	const path = yield* Path$1;
 	const content = yield* (yield* Workspace).read(".git").pipe(catch_(() => succeed$1(void 0)));
 	const pointer = content === void 0 ? null : GITDIR_POINTER.exec(content);
 	if (pointer === null) return ".git";
 	const gitdir = pointer[1].trim();
-	return isAbsolute(gitdir) ? gitdir : join(root, gitdir);
+	return path.isAbsolute(gitdir) ? gitdir : path.join(root, gitdir);
 });
 /**
 * The per-worktree loop log path `gtd next --json` reports as `log`.
@@ -21973,11 +22577,16 @@ const worktreeGitDir = gen(function* () {
 */
 const loopLogPath = gen(function* () {
 	const { root, env } = yield* Host;
+	const path = yield* Path$1;
 	const override = env.GTD_LOOP_LOG;
 	if (override !== void 0 && override !== "") return override;
 	const gitDirEnv = env.GIT_DIR;
-	if (gitDirEnv !== void 0 && gitDirEnv !== "") return join(isAbsolute(gitDirEnv) ? gitDirEnv : join(root, gitDirEnv), "gtd-loop.log");
-	return join(yield* worktreeGitDir, "gtd-loop.log");
+	if (gitDirEnv !== void 0 && gitDirEnv !== "") {
+		const gitDir = path.isAbsolute(gitDirEnv) ? gitDirEnv : path.join(root, gitDirEnv);
+		return path.join(gitDir, "gtd-loop.log");
+	}
+	const gitDir = yield* worktreeGitDir;
+	return path.join(gitDir, "gtd-loop.log");
 });
 //#endregion
 //#region src/platform/RetainedHistory.ts
@@ -22001,6 +22610,73 @@ const restorability = (git, headHash, tipHash) => gen(function* () {
 		reason: "HEAD has advanced past the retained tip — restoring would discard commits built on top of it"
 	};
 });
+Uint32Array.from([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+new TextEncoder();
 //#endregion
 //#region src/flags/index.ts
 const FLAGS$1 = [];
@@ -22032,19 +22708,21 @@ const resolveFlags = (env, registry = FLAGS$1) => {
 const flagSettings = (flags) => Object.fromEntries(Object.entries(flags).map(([name, on]) => [`flag_${name}`, on ? "1" : "0"]));
 //#endregion
 //#region src/install/Version.ts
-const _require = createRequire(import.meta.url);
-const findPackageJson = (fromUrl) => {
-	let dir = dirname(fileURLToPath(fromUrl));
+const readPackageJson = (fromUrl) => {
+	let dir = new URL(".", fromUrl);
 	for (let i = 0; i < 5; i++) {
-		const candidate = join(dir, "package.json");
-		if (existsSync(candidate)) return candidate;
-		dir = dirname(dir);
+		const candidate = new URL("package.json", dir);
+		try {
+			const source = nodeSyncIo.readText(fileURLToPath(candidate));
+			if (source !== void 0) return source;
+		} catch {}
+		dir = new URL("..", dir);
 	}
 	throw new Error(`package.json not found by walking up from ${fromUrl}`);
 };
 /** The global a pin's workflow registers itself under, ahead of the engine in the same file. */
 const PIN_KEY = Symbol.for("@pmelab/gtd/pin");
-const GTD_VERSION = globalThis[PIN_KEY]?.version ?? _require(findPackageJson(import.meta.url)).version;
+const GTD_VERSION = globalThis[PIN_KEY]?.version ?? JSON.parse(readPackageJson(import.meta.url)).version;
 //#endregion
 //#region src/install/Install.ts
 const WORKFLOWS_REPO = "https://github.com/pmelab/gtd-workflows";
@@ -22810,9 +23488,9 @@ const withoutPath = (tree, hidden) => {
 const OLDEST_READABLE_FORMAT = 1;
 const short$1 = (hash) => hash.slice(0, 7);
 const formatFault = (commits) => {
-	const foreign = commits.find((c) => c.format < OLDEST_READABLE_FORMAT || c.format > 3);
+	const foreign = commits.find((c) => c.format < OLDEST_READABLE_FORMAT || c.format > 4);
 	if (foreign === void 0) return void 0;
-	return `gtd: commit ${short$1(foreign.hash)} is written in history format ${foreign.format}, but this gtd reads formats ${OLDEST_READABLE_FORMAT} to 3 — run a gtd release that reads format ${foreign.format} to continue this process`;
+	return `gtd: commit ${short$1(foreign.hash)} is written in history format ${foreign.format}, but this gtd reads formats ${OLDEST_READABLE_FORMAT} to 4 — run a gtd release that reads format ${foreign.format} to continue this process`;
 };
 //#endregion
 //#region src/replay/Trailers.ts
@@ -22849,11 +23527,21 @@ const parseStepId = (raw) => {
 		occurrence: Number(match[2])
 	};
 };
+/** Step names a workflow may not take: gtd's own beats live under it. */
+const ENGINE_PREFIX = "gtd:";
 /** What a pin and an unpin beat rest at, and their commits name — neither is a step of the workflow. */
 const PIN_STATES = {
+	add: `${ENGINE_PREFIX}pin`,
+	remove: `${ENGINE_PREFIX}unpin`
+};
+/** The names formats 2 and 3 gave the pin beats, before `gtd:` reserved them. */
+const LEGACY_PIN_STATES = {
 	add: "pin",
 	remove: "unpin"
 };
+const SCOPED_PIN_FORMAT = 4;
+/** The name a commit in `format` gives a pin beat; format 1 has none. */
+const pinStateIn = (format, change) => format >= SCOPED_PIN_FORMAT ? PIN_STATES[change] : format >= 2 ? LEGACY_PIN_STATES[change] : void 0;
 const isVerdict$1 = (value) => {
 	if (typeof value !== "object" || value === null) return false;
 	const v = value;
@@ -23002,13 +23690,16 @@ const formatCommitMessage = (spec) => {
 		...trailer("Anchor", spec.anchor),
 		...trailer("Branch", spec.branch),
 		...trailer("Version", spec.version),
-		`Gtd-Format: 3`
+		`Gtd-Format: 4`
 	];
 	return `${formatSubject(spec.actor, spec.to, spec.from)}\n\n${lines.join("\n")}`;
 };
 //#endregion
 //#region src/replay/Replay.ts
-const UNPIN_STATE = PIN_STATES.remove;
+const namesUnpin = (commit) => {
+	const unpin = pinStateIn(commit.parsed.format, "remove");
+	return unpin !== void 0 && commit.parsed.parsed?.to === unpin;
+};
 const actorOfKind = (kind) => kind === "run" ? "check" : kind === "agent" ? "agent" : kind === "human" ? "human" : "judge";
 const memoryScopeOf = (name) => {
 	const dot = name.lastIndexOf(".");
@@ -23213,7 +23904,7 @@ const replay = async (raw) => {
 			if (!isAnchor(commit)) continue;
 			position = commit;
 			const to = commit.parsed.parsed?.to;
-			expectedNext = to === void 0 || to === UNPIN_STATE ? void 0 : {
+			expectedNext = to === void 0 || namesUnpin(commit) ? void 0 : {
 				name: to,
 				hash: commit.hash
 			};
@@ -23407,7 +24098,7 @@ const replay = async (raw) => {
 	};
 	const expectNextOf = (commit) => {
 		const to = commit.parsed.parsed?.to;
-		if (to !== void 0 && to !== UNPIN_STATE) expectedNext = {
+		if (to !== void 0 && !namesUnpin(commit)) expectedNext = {
 			name: to,
 			hash: commit.hash
 		};
@@ -23453,7 +24144,7 @@ const replay = async (raw) => {
 		return landPending(step, input.pending);
 	};
 	const requestFault = (request) => {
-		if (Object.values(PIN_STATES).includes(scoped(request.name))) return `gtd: step "${scoped(request.name)}": the name is reserved for the pin and unpin beats — rename the step`;
+		if (scoped(request.name).startsWith("gtd:")) return `gtd: step "${scoped(request.name)}": the "${ENGINE_PREFIX}" prefix is reserved for gtd's own beats — rename the step`;
 		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);
@@ -23598,6 +24289,8 @@ const replay = async (raw) => {
 const seededValidateCommand = (mode) => `gtd check ${mode} "$GTD_FILE"`;
 /** True when `command` is exactly `mode`'s seeded template (compared literally, not rendered) — distinguishes gtd's own seeding from a user override. */
 const isSeededValidateCommand = (mode, command) => command === seededValidateCommand(mode);
+/** The `validate:` command for a declared format: its spec travels on the command line, so `gtd check` loads no workflow to find it. */
+const declaredValidateCommand = (mode, spec) => `gtd check ${mode} "$GTD_FILE" --spec '${spec.replace(/'/g, "'\\''")}'`;
 //#endregion
 //#region src/workflow/compile.ts
 /**
@@ -23715,17 +24408,17 @@ const LEGACY_RC_FILES = [
 	"gtd.config.yaml"
 ];
 /** The directories searched for a leftover rc file: the walk, plus `home` when the walk misses it. */
-const legacyRcDirs = (root, home) => {
-	const chain = walkUp(root, home);
+const legacyRcDirs = (path, root, home) => {
+	const chain = walkUp(path, root, home);
 	return chain.includes(home) ? chain : [...chain, home];
 };
-const legacyRcFileAt = (path) => {
+const legacyRcFileAt = (io, path, uid) => {
 	try {
-		const stat = statSync(path);
-		if (!stat.isFile()) return void 0;
+		const stat = io.stat(path);
+		if (stat?.type !== "file") return void 0;
 		return {
 			path,
-			owned: process.getuid === void 0 || stat.uid === process.getuid()
+			owned: uid === void 0 || stat.uid === uid
 		};
 	} catch {
 		return;
@@ -23739,30 +24432,33 @@ const legacyRcFileAt = (path) => {
 * shared implementation, not a second copy in `src/twins/Layers.ts` that
 * could silently diverge.
 */
-const walkUp = (from, home) => {
+const walkUp = (path, from, home) => {
 	const chain = [];
 	let dir = from;
 	while (true) {
 		chain.push(dir);
 		if (dir === home) break;
-		const parent = dirname(dir);
+		const parent = path.dirname(dir);
 		if (parent === dir) break;
 		dir = parent;
 	}
 	return chain;
 };
-const legacyRcFiles = (root, home) => sync(() => legacyRcDirs(root, home).flatMap((dir) => LEGACY_RC_FILES.flatMap((name) => legacyRcFileAt(join(dir, name)) ?? [])));
-const workflowModule = (root, home) => try_({
-	try: () => {
-		for (const dir of walkUp(root, home)) {
-			const filepath = join(dir, WORKFLOW_MODULE);
-			if (existsSync(filepath)) return {
-				filepath,
-				source: readFileSync(filepath, "utf8")
-			};
-		}
-	},
-	catch: (e) => e instanceof Error ? e : new Error(String(e))
+const liveDiscovery = (io, path, uid) => ({
+	legacyRcFiles: (root, home) => sync(() => legacyRcDirs(path, root, home).flatMap((dir) => LEGACY_RC_FILES.flatMap((name) => legacyRcFileAt(io, path.join(dir, name), uid) ?? []))),
+	workflowModule: (root, home) => try_({
+		try: () => {
+			for (const dir of walkUp(path, root, home)) {
+				const filepath = path.join(dir, WORKFLOW_MODULE);
+				const source = io.readText(filepath);
+				if (source !== void 0) return {
+					filepath,
+					source
+				};
+			}
+		},
+		catch: (e) => e instanceof Error ? e : new Error(String(e))
+	})
 });
 /**
 * The discovery seam — a `Context.Service`, not part of `WorkflowFiles` (that
@@ -23775,31 +24471,29 @@ const workflowModule = (root, home) => try_({
 * each have a production and a fake layer behind one service.
 */
 var ConfigDiscovery = class ConfigDiscovery extends Service()("ConfigDiscovery") {
-	static Live = succeed$2(ConfigDiscovery, {
-		legacyRcFiles,
-		workflowModule
-	});
+	static Live = effect(ConfigDiscovery, gen(function* () {
+		return liveDiscovery(nodeSyncIo, yield* Path$1, (yield* Host).uid);
+	}));
 };
 //#endregion
 //#region src/workflow/fingerprint.ts
 const HASH_LENGTH = 16;
 const CONTROL_CHARACTER = /[\x00-\x1f\x7f-\x9f]/;
-const contentHash = (content) => createHash("sha256").update(content).digest("hex").slice(0, HASH_LENGTH);
-const realOr = (path) => {
+const realOr = (io, path) => {
 	try {
-		return realpathSync(path);
+		return io.realPath(path);
 	} catch {
 		return path;
 	}
 };
-const configFingerprint = (files, root, read) => {
+const configFingerprint = (io, paths, files, root, read) => {
 	const fingerprint = {};
-	const realRoot = realOr(root);
+	const realRoot = realOr(io, root);
 	for (const file of files) {
-		const path = relative(realRoot, realOr(file)).split(sep).join("/");
+		const path = paths.relative(realRoot, realOr(io, file)).split(paths.sep).join("/");
 		if (CONTROL_CHARACTER.test(path)) continue;
 		const content = read(file);
-		if (content !== void 0) fingerprint[path] = contentHash(content);
+		if (content !== void 0) fingerprint[path] = io.hash("sha256", content).slice(0, HASH_LENGTH);
 	}
 	return fingerprint;
 };
@@ -23893,19 +24587,20 @@ const configModule = gen(function* () {
 */
 const load = gen(function* () {
 	const host = yield* Host;
+	const paths = yield* Path$1;
 	yield* refuseLegacyRc;
 	const pinned = pinnedWorkflow();
 	const module = pinned === void 0 ? yield* configModule : {
-		filepath: resolve(host.root, pinned.origin),
+		filepath: paths.resolve(host.root, pinned.origin),
 		source: ""
 	};
 	yield* (yield* Narrator).narrate(`config: ${pinned === void 0 ? "module" : "pinned module"} ${module.filepath}`);
 	const shipped = pinned === void 0 ? yield* tryPromise({
-		try: shippedModules,
+		try: () => shippedModules(paths),
 		catch: (e) => new GtdError(`gtd: ${e instanceof Error ? e.message : String(e)}`)
 	}) : void 0;
 	const loaded = yield* tryPromise({
-		try: async () => loadWorkflows(module.filepath, shipped === void 0 ? runPinned(pinned, module.filepath, host.root) : await evaluate(module, shipped)),
+		try: async () => loadWorkflows(module.filepath, shipped === void 0 ? runPinned(paths, pinned, module.filepath, host.root) : await evaluate(paths, module, shipped)),
 		catch: (e) => new GtdError(`gtd: config:\n  - ${module.filepath}: ${e instanceof Error ? e.message : String(e)}`)
 	});
 	const compiled = loaded.config;
@@ -23927,13 +24622,13 @@ const load = gen(function* () {
 		initial
 	});
 	const names = [...loaded.catalogue.keys()].sort();
-	const resolve$3 = (name, entry) => ({
+	const resolve = (name, entry) => ({
 		name,
 		def: define(entry),
 		vars: { ...entry.defaults },
 		env: { ...entry.envDefaults }
 	});
-	const defaultWorkflow = resolve$3(loaded.default.name, loaded.default);
+	const defaultWorkflow = resolve(loaded.default.name, loaded.default);
 	return {
 		workflow: defaultWorkflow.def,
 		defaultWorkflow,
@@ -23941,41 +24636,41 @@ const load = gen(function* () {
 		doors: loaded.doors,
 		workflowNamed: (name) => {
 			const entry = loaded.catalogue.get(name);
-			return entry === void 0 ? void 0 : resolve$3(name, entry);
+			return entry === void 0 ? void 0 : resolve(name, entry);
 		},
 		...compiled.ui !== void 0 ? { ui: compiled.ui } : {},
 		warnings: diagnostics.filter((d) => d.severity === "warning"),
-		fingerprint: pinned?.fingerprint ?? configFingerprint(loaded.file.dependencyFiles, host.root, module.read ?? readFromDisk),
-		drift: pinned === void 0 ? [] : changedConfigFiles(pinned.fingerprint, configFingerprint(Object.keys(pinned.fingerprint).map((file) => resolve(host.root, file)), host.root, readFromDisk))
+		fingerprint: pinned?.fingerprint ?? configFingerprint(nodeSyncIo, paths, loaded.file.dependencyFiles, host.root, module.read ?? readFromDisk),
+		drift: pinned === void 0 ? [] : changedConfigFiles(pinned.fingerprint, configFingerprint(nodeSyncIo, paths, Object.keys(pinned.fingerprint).map((file) => paths.resolve(host.root, file)), host.root, readFromDisk))
 	};
 });
 const readFromDisk = (path) => {
 	try {
-		return readFileSync(path, "utf8");
+		return nodeSyncIo.readText(path);
 	} catch {
 		return;
 	}
 };
 const PACKAGE = "@pmelab/gtd";
 const FLOWS = `${PACKAGE}/flows`;
-const ownPackage = () => {
-	const start = dirname(fileURLToPath(import.meta.url));
-	for (let dir = start;; dir = dirname(dir)) {
-		const file = join(dir, "package.json");
-		if (existsSync(file)) {
-			const pkg = JSON.parse(readFileSync(file, "utf8"));
+const ownPackage = (paths) => {
+	const start = paths.dirname(runSync$1(paths.fromFileUrl(new URL(import.meta.url))));
+	for (let dir = start;; dir = paths.dirname(dir)) {
+		const source = readFromDisk(paths.join(dir, "package.json"));
+		if (source !== void 0) {
+			const pkg = JSON.parse(source);
 			if (pkg.name === PACKAGE) return {
 				root: dir,
 				pkg
 			};
 		}
-		if (dirname(dir) === dir) throw new Error(`no ${PACKAGE} package.json above ${start}`);
+		if (paths.dirname(dir) === dir) throw new Error(`no ${PACKAGE} package.json above ${start}`);
 	}
 };
 let shippedMemo;
-const shippedModules = () => shippedMemo ??= (async () => {
+const shippedModules = (paths) => shippedMemo ??= (async () => {
 	const fromSource = import.meta.url.endsWith(".ts");
-	const files = subpathFiles(fromSource ? "source" : "default");
+	const files = subpathFiles(paths, fromSource ? "source" : "default");
 	const modules = { [FLOWS]: flows_exports };
 	const missing = {};
 	if (process.features.require_module && !fromSource) return {
@@ -23983,7 +24678,7 @@ const shippedModules = () => shippedMemo ??= (async () => {
 		missing
 	};
 	for (const [id, path] of files) try {
-		modules[id] = await import(pathToFileURL(path).href);
+		modules[id] = await import(fileUrl(paths, path));
 	} catch {
 		missing[id] = path;
 	}
@@ -23993,13 +24688,13 @@ const shippedModules = () => shippedMemo ??= (async () => {
 	};
 })();
 /** The file each subpath a config may import serves: all but `flows`, the engine's own, and the testkit's. */
-const subpathFiles = (condition) => {
-	const { root, pkg } = ownPackage();
+const subpathFiles = (paths, condition) => {
+	const { root, pkg } = ownPackage(paths);
 	const files = /* @__PURE__ */ new Map();
 	for (const [subpath, target] of Object.entries(pkg.exports)) {
 		const file = typeof target === "string" ? target : target[condition];
 		if (subpath === "./flows" || subpath.startsWith("./testkit") || file === void 0) continue;
-		files.set(`${PACKAGE}/${subpath.replace(/^\.\//, "")}`, join(root, file));
+		files.set(`${PACKAGE}/${subpath.replace(/^\.\//, "")}`, paths.join(root, file));
 	}
 	return files;
 };
@@ -24193,16 +24888,16 @@ const shadowingDoors = (doors, catalogue, origin) => [...doors].filter(([name, d
 	path: ["doors", name],
 	origin
 }));
-const moduleCandidates = (path) => [
+const moduleCandidates = (paths, path) => [
 	path,
 	path.replace(/\.js$/, ".ts"),
 	path.replace(/\.mjs$/, ".mts"),
 	`${path}.ts`,
-	join(path, "index.ts")
+	paths.join(path, "index.ts")
 ];
-const execute = (chunk, filepath, require) => {
+const execute = (paths, chunk, filepath, require) => {
 	const cjs = { exports: {} };
-	chunk(cjs.exports, require, cjs, filepath, dirname(filepath));
+	chunk(cjs.exports, require, cjs, filepath, paths.dirname(filepath));
 	return cjs.exports;
 };
 /**
@@ -24214,40 +24909,40 @@ const execute = (chunk, filepath, require) => {
 * it, as Node would. `@pmelab/gtd/*` is the running gtd's own copy, and
 * `files` leaves out every package file.
 */
-const evaluate = async (module, shipped) => {
-	const { code, files } = await bundleConfig(module, {
+const evaluate = async (paths, module, shipped) => {
+	const { code, files } = await bundleConfig(paths, module, {
 		kind: "evaluate",
 		shipped
 	});
 	const fromConfig = createRequire(module.filepath);
 	const require = Object.assign((id) => id in shipped.modules ? shipped.modules[id] : fromConfig(id in shipped.missing ? shipped.missing[id] : id), { resolve: fromConfig.resolve });
-	const chunk = runInThisContext(`(function (exports, require, module, __filename, __dirname) {${code}\n})`, { filename: module.filepath });
+	const chunk = compileScript(`(function (exports, require, module, __filename, __dirname) {${code}\n})`, module.filepath);
 	return {
-		exports: execute(chunk, module.filepath, require),
+		exports: execute(paths, chunk, module.filepath, require),
 		files
 	};
 };
 const pinnedWorkflow = () => globalThis[PIN_KEY];
-const runPinned = (pinned, filepath, root) => ({
-	exports: execute(pinned.run, filepath, (id) => id === FLOWS ? flows_exports : createRequire(import.meta.url)(id)),
-	files: Object.keys(pinned.fingerprint).map((file) => resolve(root, file))
+const runPinned = (paths, pinned, filepath, root) => ({
+	exports: execute(paths, pinned.run, filepath, (id) => id === FLOWS ? flows_exports : createRequire(import.meta.url)(id)),
+	files: Object.keys(pinned.fingerprint).map((file) => paths.resolve(root, file))
 });
 /**
 * The statement that registers `module`'s workflow for a pin: the config and
 * everything it imports — npm packages and gtd's own subpaths included — in
 * one function, so the engine runs it without a config, a package or rolldown.
 */
-const pinnedWorkflowSource = async (module, root, version) => {
-	const gtd = realpathSync(ownPackage().root) + sep;
-	const { code, files } = await bundleConfig(module, {
+const pinnedWorkflowSource = async (paths, module, root, version) => {
+	const gtd = nodeSyncIo.realPath(ownPackage(paths).root) + paths.sep;
+	const { code, files } = await bundleConfig(paths, module, {
 		kind: "pin",
-		shipped: subpathFiles(import.meta.url.endsWith(".ts") ? "source" : "default")
+		shipped: subpathFiles(paths, import.meta.url.endsWith(".ts") ? "source" : "default")
 	});
 	const own = (file) => file.startsWith(gtd) && !module.filepath.startsWith(gtd);
 	const registered = {
 		version,
-		origin: relative(root, module.filepath),
-		fingerprint: configFingerprint(files.filter((file) => !own(file)), root, module.read ?? readFromDisk)
+		origin: paths.relative(root, module.filepath),
+		fingerprint: configFingerprint(nodeSyncIo, paths, files.filter((file) => !own(file)), root, module.read ?? readFromDisk)
 	};
 	return `globalThis[Symbol.for(${JSON.stringify(PIN_KEY.description)})] = { ...${JSON.stringify(registered)}, run: function (exports, require, module, __filename, __dirname) {\n${code}\n} };\n`;
 };
@@ -24261,11 +24956,11 @@ const shippedImport = (source, mode) => {
 		external: true
 	} : void 0;
 };
-const bundleConfig = async (module, mode) => {
+const bundleConfig = async (paths, module, mode) => {
 	const { read } = module;
 	const served = /* @__PURE__ */ new Set();
 	const fromRead = (path) => {
-		const hit = moduleCandidates(path).find((candidate) => read?.(candidate) !== void 0);
+		const hit = moduleCandidates(paths, path).find((candidate) => read?.(candidate) !== void 0);
 		if (hit === void 0) return null;
 		served.add(hit);
 		return hit;
@@ -24279,18 +24974,18 @@ const bundleConfig = async (module, mode) => {
 				if (importer === void 0) return source === module.filepath ? source : null;
 				const shipped = shippedImport(source, mode);
 				if (shipped !== void 0) return shipped;
-				if (/^\.\.?(\/|$)/.test(source)) return fromRead(join(dirname(importer), source));
-				if (!isPackage(source)) return null;
+				if (/^\.\.?(\/|$)/.test(source)) return fromRead(paths.join(paths.dirname(importer), source));
+				if (!isPackage(paths, source)) return null;
 				const resolved = await this.resolve(source, importer, { skipSelf: true });
-				return mode.kind === "pin" ? resolved : packageImport(source, resolved);
+				return mode.kind === "pin" ? resolved : packageImport(paths, source, resolved);
 			},
 			load(id) {
-				if (mode.kind === "pin" && isNativeAddon(id)) throw new Error(nativeAddon(id));
+				if (mode.kind === "pin" && isNativeAddon(paths, id)) throw new Error(nativeAddon(paths, id));
 				if (id === module.filepath) return module.source;
 				return served.has(id) ? read(id) : null;
 			},
 			transform(code, id) {
-				return code.replace(/\bimport\.meta\.(url|filename|dirname)\b/g, (_, key) => JSON.stringify(key === "url" ? pathToFileURL(id).href : key === "filename" ? id : dirname(id)));
+				return code.replace(/\bimport\.meta\.(url|filename|dirname)\b/g, (_, key) => JSON.stringify(key === "url" ? fileUrl(paths, id) : key === "filename" ? id : paths.dirname(id)));
 			}
 		}],
 		external: (id) => isBuiltin(id),
@@ -24320,34 +25015,42 @@ const bundleConfig = async (module, mode) => {
 		await bundle.close();
 	}
 };
-const isNativeAddon = (id) => {
+const isNativeAddon = (paths, id) => {
 	if (id.endsWith(".node")) return true;
+	const { sep } = paths;
 	const at = id.lastIndexOf(`node_modules${sep}`);
 	if (at < 0) return false;
 	const rest = id.slice(at + `node_modules${sep}`.length).split(sep);
-	return existsSync(join(id.slice(0, at) + ["node_modules", ...rest.slice(0, rest[0].startsWith("@") ? 2 : 1)].join(sep), "binding.gyp"));
+	const root = id.slice(0, at) + ["node_modules", ...rest.slice(0, rest[0].startsWith("@") ? 2 : 1)].join(sep);
+	try {
+		return nodeSyncIo.stat(paths.join(root, "binding.gyp")) !== void 0;
+	} catch {
+		return false;
+	}
 };
-const nativeAddon = (path) => {
+const nativeAddon = (paths, path) => {
+	const { sep } = paths;
 	const at = path.lastIndexOf(`node_modules${sep}`);
 	const rest = at < 0 ? [] : path.slice(at + `node_modules${sep}`.length).split(sep);
 	const name = rest[0]?.startsWith("@") ? rest.slice(0, 2).join("/") : rest[0];
 	return `${name === void 0 ? path : `package "${name}"`} loads a native addon (${path}), which a pin cannot carry`;
 };
-const packageImport = (source, resolved) => resolved !== null && isEsModule(resolved.id) ? resolved.id : {
+const packageImport = (paths, source, resolved) => resolved !== null && isEsModule(paths, resolved.id) ? resolved.id : {
 	id: resolved?.id ?? source,
 	external: true
 };
-const isEsModule = (path) => {
+const isEsModule = (paths, path) => {
 	if (/\.(mjs|[cm]?tsx?)$/.test(path)) return true;
 	if (!/\.jsx?$/.test(path)) return false;
-	for (let dir = dirname(path); dirname(dir) !== dir; dir = dirname(dir)) {
-		const file = join(dir, "package.json");
-		if (existsSync(file)) return JSON.parse(readFileSync(file, "utf8")).type === "module";
+	for (let dir = paths.dirname(path); paths.dirname(dir) !== dir; dir = paths.dirname(dir)) {
+		const source = readFromDisk(paths.join(dir, "package.json"));
+		if (source !== void 0) return JSON.parse(source).type === "module";
 	}
 	return false;
 };
 const inPackage = (path) => /[\\/]node_modules[\\/]/.test(path);
-const isPackage = (specifier) => !isAbsolute(specifier) && !isBuiltin(specifier);
+const isPackage = (paths, specifier) => !paths.isAbsolute(specifier) && !isBuiltin(specifier);
+const fileUrl = (paths, path) => runSync$1(paths.toFileUrl(path)).href;
 const bundleError = (e) => {
 	const errors = e?.errors;
 	if (errors === void 0) return e;
@@ -24604,11 +25307,15 @@ var EngineCore = class EngineCore extends Service()("EngineCore") {
 	static layer = (path) => succeed$2(EngineCore, { source: suspend$2(() => {
 		const file = path();
 		return try_({
-			try: () => readFileSync(file, "utf8"),
+			try: () => {
+				const source = nodeSyncIo.readText(file);
+				if (source === void 0) throw new Error("absent");
+				return source;
+			},
 			catch: () => new GtdError(`gtd bundle: no engine at ${file} — build gtd first`)
 		});
 	}) });
-	static Live = EngineCore.layer(() => join(ownPackage().root, "dist", "gtd.core.mjs"));
+	static Live = unwrap$6(map(Path$1, (path) => EngineCore.layer(() => path.join(ownPackage(path).root, "dist", "gtd.core.mjs"))));
 };
 /**
 * A pin: one plain-text header line a launcher reads without unpacking, then
@@ -24617,11 +25324,12 @@ var EngineCore = class EngineCore extends Service()("EngineCore") {
 */
 const pin = (module, root, version) => gen(function* () {
 	const core = yield* (yield* EngineCore).source;
+	const path = yield* Path$1;
 	const source = (yield* tryPromise({
-		try: () => pinnedWorkflowSource(module, root, version),
+		try: () => pinnedWorkflowSource(path, module, root, version),
 		catch: (e) => new GtdError(`gtd bundle: ${module.filepath}: ${e instanceof Error ? e.message : String(e)}`)
 	})) + core.replace(/^#!.*\n/, "");
-	return Buffer.concat([Buffer.from(`gtdpin 1 gtd ${version}\n`), gzipSync(source, { level: 9 })]);
+	return Buffer.concat([Buffer.from(`gtdpin 1 gtd ${version}\n`), gzip(source)]);
 });
 //#endregion
 //#region src/emit/GitScript.ts
@@ -25017,8 +25725,27 @@ const capabilitiesFor = (mode, format, validate) => {
 * The `"unknown"` arm carries the whole refusal message, naming what IS known
 * when `def` is given — this is the one place that message is built, so it
 * can never drift from what actually resolved.
+*
+* `spec` is a declared format's: it alone decides, validating through
+* `gtd check --spec` with no `format:` half.
 */
-const resolveMode = (def, state, mode) => {
+const resolveMode = (def, state, mode, spec) => {
+	if (spec !== void 0) {
+		const format = formatFromSpec(spec);
+		return {
+			kind: "resolved",
+			mode,
+			format,
+			validate: {
+				kind: "command",
+				command: declaredValidateCommand(mode, spec)
+			},
+			capabilities: {
+				format,
+				liveValidate: format.validate
+			}
+		};
+	}
 	const declared = def?.modes?.[mode];
 	const format = steeringFormatFor(mode);
 	if (declared === void 0 && format === void 0) return {
@@ -25076,7 +25803,7 @@ const modeCommandSteps = (resolved, file) => {
 	return steps;
 };
 /** `<Host.scratchDir>/gtd-mode-sample-<mode>-<pid>.md` — an absolute literal baked in at emit time, never a shell variable. `<pid>` avoids collisions between concurrent `gtd` processes. Never a `/tmp` literal or `mktemp` (`tests/tooling/no-tmp-assumption.test.ts` scans for both). */
-const scratchSamplePath = (scratchDir, mode) => join(scratchDir, `gtd-mode-sample-${mode}-${process.pid}.md`);
+const scratchSamplePath = (path, { scratchDir, pid }, mode) => path.join(scratchDir, `gtd-mode-sample-${mode}-${pid}.md`);
 /**
 * The contradiction round-trip/skip-notice steps for `resolved`'s `mode:`.
 * No `formatCommand` means nothing to round-trip: empty. Otherwise: a live
@@ -25089,8 +25816,7 @@ const modeContradictionSteps = (resolved) => gen(function* () {
 	if (resolved.formatCommand === void 0) return [];
 	const { capabilities } = resolved;
 	if (capabilities.format !== void 0 && capabilities.liveValidate !== void 0) {
-		const { scratchDir } = yield* Host;
-		const samplePath = scratchSamplePath(scratchDir, resolved.mode);
+		const samplePath = scratchSamplePath(yield* Path$1, yield* Host, resolved.mode);
 		const formatCommand = withFileVar(resolved.formatCommand, samplePath);
 		return [{
 			kind: "command",
@@ -25490,7 +26216,7 @@ const subjectIsBoundary = (def, subject) => {
 	const parsed = parseCommitMessage(subject).parsed;
 	if (parsed === void 0 || !ACTORS.has(parsed.actor)) return true;
 	if (parsed.actor === "human" && parsed.from === void 0) return false;
-	if (parsed.actor === "check" && parsed.from === PIN_STATES.add) return false;
+	if (parsed.actor === "check" && (parsed.from === PIN_STATES.add || parsed.from === LEGACY_PIN_STATES.add)) return false;
 	return parsed.to === def.initial;
 };
 /** The last page index (walking newest→oldest, same direction as `locateEpisode`) whose subject is a boundary, or `undefined` if none in `page`. */
@@ -25687,7 +26413,10 @@ const commonOf = (step) => {
 		actor: step.actor,
 		...optional("label", options.label),
 		...optional("file", options.file),
-		...optional("mode", options.mode)
+		...typeof options.mode === "object" ? {
+			mode: options.mode.name,
+			modeSpec: options.mode.spec
+		} : optional("mode", options.mode)
 	};
 };
 const promptDef = (common, request, skills, access) => ({
@@ -25763,6 +26492,13 @@ const hintsOf = (def) => ({
 	...optional("skills", def.skills),
 	...optional("access", def.access)
 });
+/** A step's mode is a name the workflow knows, or a declared format named apart from all of them. */
+const modeFaultOf = (def, stepName, stepDef) => {
+	if (stepDef.mode === void 0) return void 0;
+	const known = def.modes[stepDef.mode] !== void 0;
+	if (stepDef.modeSpec !== void 0) return known ? `gtd: config: step "${stepName}": declared format "${stepDef.mode}" has the name of a mode this workflow already knows — rename the format` : void 0;
+	return known ? void 0 : `gtd: config: step "${stepName}": mode "${stepDef.mode}" is not a mode this workflow knows (${knownModes(def).join(", ")})`;
+};
 const normalizeStatus = (raw) => raw === "A" ? "A" : raw === "D" ? "D" : "M";
 /** Per-model token totals, highest-cost first (ties broken by model name). */
 const costByModel = (entries) => {
@@ -25854,7 +26590,8 @@ const restAt = (ref, startOverrides = {}) => gen(function* () {
 	const { reached, step } = resting;
 	const { stepDef, state, memory } = restFacts(pin, step, reached.trace, run);
 	yield* (yield* Narrator).narrate(`rest resolved: ${state} (awaits ${stepDef.actor})`);
-	if (stepDef.mode !== void 0 && def.modes[stepDef.mode] === void 0) return yield* fail$4(/* @__PURE__ */ new Error(`gtd: config: step "${step.name}": mode "${stepDef.mode}" is not a mode this workflow knows (${knownModes(def).join(", ")})`));
+	const modeFault = modeFaultOf(def, step.name, stepDef);
+	if (modeFault !== void 0) return yield* fail$4(new Error(modeFault));
 	const changes = ref === void 0 ? (yield* pendingChanges(git, stepDef.approve === true)).map((e) => ({
 		status: normalizeStatus(e.status),
 		path: e.path
@@ -26249,15 +26986,16 @@ const summaryFor = (run) => gen(function* () {
 * repository cannot be read at a ref, so it is left out. A file only the old
 * config read needs no check: whichever file imported it differs too.
 */
-const inRepoConfigPaths = (root, files) => {
-	const paths = /* @__PURE__ */ new Set();
-	for (const file of files) paths.add(relative(root, resolve(root, file)).split(sep).join("/"));
-	return [...paths].filter((p) => p !== "" && !p.startsWith("..") && !isAbsolute(p)).sort();
+const inRepoConfigPaths = (path, root, files) => {
+	const found = /* @__PURE__ */ new Set();
+	for (const file of files) found.add(path.relative(root, path.resolve(root, file)).split(path.sep).join("/"));
+	return [...found].filter((p) => p !== "" && !p.startsWith("..") && !path.isAbsolute(p)).sort();
 };
 const configRefusal = (command, tip, paths, reason = "A history ref replays under today's config, so it is unreadable after the config changes") => /* @__PURE__ */ new Error(`${command}: refused — config differs at ${tip.slice(0, 7)}: ${paths.join(", ")}. ${reason}`);
 const differingConfigPaths = (git, workspace, root, config, hash) => gen(function* () {
 	const differing = [];
-	for (const path of inRepoConfigPaths(root, Object.keys(config.fingerprint))) if ((yield* orElseSucceed(git.readFileAtRef(hash, path), () => void 0)) !== workspace.readSync(path)) differing.push(path);
+	const configPaths = inRepoConfigPaths(yield* Path$1, root, Object.keys(config.fingerprint));
+	for (const path of configPaths) if ((yield* orElseSucceed(git.readFileAtRef(hash, path), () => void 0)) !== workspace.readSync(path)) differing.push(path);
 	return differing;
 });
 const notClosedError = (hash, outcome) => outcome.kind === "rest" ? /* @__PURE__ */ new Error(`gtd history: ${hash.slice(0, 7)} does not close a process under today's config`) : replayError(outcome) ?? /* @__PURE__ */ new Error("gtd history: replay failed");
@@ -27037,12 +27775,11 @@ const runHistoryJudgesCommand = (refs, vars, jsonl, json, out) => gen(function*
 });
 //#endregion
 //#region src/cli/Program.ts
-const selfGtd = () => {
-	const script = process.argv[1];
-	return script === void 0 ? ["gtd"] : [process.execPath, script];
-};
 /** `needs: "none"` skips the repo-root guard — the server is keyed on file name, not workflow state. */
-const runLspCommand = () => flatMap(ToolCommands, (tools) => tools.lsp(selfGtd()));
+const runLspCommand = () => gen(function* () {
+	const { self } = yield* Host;
+	return yield* (yield* ToolCommands).lsp(self);
+});
 /**
 * Prints the briefing, emitted by the binary itself so it's always current.
 * gtd ships no workflow, so where no `gtd.config.ts` governs it says where to
@@ -27150,19 +27887,6 @@ const parseJudgeDocument = (rendered) => try_({
 	try: () => JSON.parse(rendered),
 	catch: () => /* @__PURE__ */ new Error("gtd judge answer: the resolved rest's \"judge:\" template did not render valid JSON")
 });
-/**
-* The first stdin-consuming command outside `src/lsp/Lsp.ts` (which reads LSP's
-* own length-prefixed frames off `process.stdin`, not a one-shot read) —
-* reads stdin to completion and decodes it as UTF-8 text, no framing.
-*/
-const readStdin = () => tryPromise({
-	try: async () => {
-		const chunks = [];
-		for await (const chunk of process.stdin) chunks.push(chunk);
-		return Buffer.concat(chunks).toString("utf8");
-	},
-	catch: (e) => e instanceof Error ? e : new Error(String(e))
-});
 /** A stdin that is no judgment is the caller's mistake, a usage error like `gtd judge answer`'s. */
 const judgmentShape = (input) => {
 	let doc;
@@ -27179,7 +27903,7 @@ const runJudgeRunCommand = (command, out) => gen(function* () {
 	const host = yield* Host;
 	const tools = yield* ToolCommands;
 	yield* refuseLegacyRc;
-	const input = yield* readStdin();
+	const input = yield* host.stdin;
 	yield* judgmentShape(input);
 	const verdict = yield* tryPromise({
 		try: () => tools.judge({
@@ -27227,7 +27951,7 @@ const runJudgeAnswerCommand = (json, out) => gen(function* () {
 	const rendered = yield* renderRest(rest);
 	if (rendered.judge === void 0) return yield* fail$4(/* @__PURE__ */ new Error(`gtd judge answer: refused — the resolved rest ("${rest.state}") declares no "judge:"`));
 	const ids = (yield* parseJudgeDocument(rendered.judge)).questions.map((q) => q.id);
-	const raw = yield* readStdin();
+	const raw = yield* (yield* Host).stdin;
 	const parsed = yield* try_({
 		try: () => JSON.parse(raw),
 		catch: () => new SelectorUsageError("gtd judge answer: stdin is not valid JSON")
@@ -27476,8 +28200,8 @@ const runRepinCommand = (json, out) => gen(function* () {
 * `gtd check <mode>` invocation instead, so there's always something concrete
 * to name.
 */
-const selfValidateCommand = (def, state, mode, file) => {
-	const resolved = resolveMode(def, state, mode);
+const selfValidateCommand = (def, state, mode, file, spec) => {
+	const resolved = resolveMode(def, state, mode, spec);
 	const validate = resolved.kind === "resolved" ? resolved.validate : void 0;
 	return commandForFile(validate?.kind === "command" ? validate.command : seededValidateCommand(mode), file);
 };
@@ -27495,7 +28219,7 @@ const resolveValidateScript = (rest) => gen(function* () {
 	const file = rest.hints.file;
 	const mode = rest.stepDef.mode;
 	if (file === void 0 || mode === void 0) return void 0;
-	const resolved = resolveMode(rest.def, rest.state, mode);
+	const resolved = resolveMode(rest.def, rest.state, mode, rest.stepDef.modeSpec);
 	if (resolved.kind === "unknown") return yield* fail$4(new Error(resolved.message));
 	const { script } = yield* validateScriptFor(resolved, file);
 	return {
@@ -27526,7 +28250,7 @@ const runNextCommand = (json, out) => gen(function* () {
 	if (json.kind === "document") out.write(renderBeatJson(fields));
 	else if (json.kind === "select") yield* writeSelection(out, fields, json.path);
 	else {
-		const validateCommand = emitsValidatablePrompt(rendered) ? selfValidateCommand(rest.def, rest.state, rendered.mode, rendered.file) : void 0;
+		const validateCommand = emitsValidatablePrompt(rendered) ? selfValidateCommand(rest.def, rest.state, rendered.mode, rendered.file, rest.stepDef.modeSpec) : void 0;
 		if (DEMAND_BRIEFING[fields.kind].suppressHeader) {
 			const shown = renderBeatPlain({
 				...fields,
@@ -27553,8 +28277,8 @@ const runValidateCommand = (json, out) => gen(function* () {
 * Findings ride the failing Effect's message, so the shared refusal path
 * reports them on stderr.
 */
-const runCheckCommand = (mode, file, openQuestions, openThreadsFlag) => gen(function* () {
-	const format = steeringFormatFor(mode);
+const runCheckCommand = (mode, file, openQuestions, openThreadsFlag, spec) => gen(function* () {
+	const format = spec !== void 0 ? yield* declaredFormat(spec) : steeringFormatFor(mode);
 	if (format === void 0) return yield* fail$4(new GtdUsageError(`gtd check: unknown mode "${mode}" — known modes: ${BUILT_IN_MODE_NAMES.join(", ")}`));
 	if (openThreadsFlag) {
 		if (openQuestions) return yield* fail$4(/* @__PURE__ */ new Error("gtd check: --open-threads and --open-questions are mutually exclusive"));
@@ -27573,6 +28297,10 @@ const runCheckCommand = (mode, file, openQuestions, openThreadsFlag) => gen(func
 	if (errors.length === 0) return;
 	return yield* fail$4(/* @__PURE__ */ new Error(`gtd check: ${file} is not valid under mode "${mode}" (${errors.length} finding(s)):\n` + errors.join("\n")));
 });
+const declaredFormat = (spec) => try_({
+	try: () => formatFromSpec(spec),
+	catch: (error) => new GtdUsageError(`gtd check: --spec is not a declared format: ${error.message}`)
+});
 const existingFile = (file) => flatMap(Workspace, (workspace) => {
 	const content = workspace.atPath(file);
 	return content === void 0 ? fail$4(/* @__PURE__ */ new Error(`gtd check: no such file: ${file}`)) : succeed$1(content);
@@ -27742,7 +28470,7 @@ const dispatchVoidCommand = (command, json, out) => {
 		case "validate": return runValidateCommand(json, out);
 		case "check":
 			if (command.mode === void 0 || command.file === void 0) return runCodeThreadsCheckCommand();
-			return runCheckCommand(command.mode, command.file, command.openQuestions ?? false, command.openThreads ?? false);
+			return runCheckCommand(command.mode, command.file, command.openQuestions ?? false, command.openThreads ?? false, command.spec);
 		case "uncheck": return runUncheckCommand(command.file);
 		case "guide": return runGuideCommand(out);
 		case "bundle": return runBundleCommand(out);
@@ -28037,6 +28765,16 @@ const FLAGS = [
 		valueHint: "",
 		help: "Instead of <mode>'s findings, list the open threads in <file>; exits 1 when any are open. Alone, lists the open code-comment threads in the files the current process changed"
 	},
+	{
+		name: "--spec",
+		arity: 1,
+		repeatable: false,
+		scope: (kind) => kind === "check",
+		decode: ([raw]) => succeed$5(raw ?? ""),
+		scopeError: "gtd: --spec is only valid for `gtd check`",
+		valueHint: "<json>",
+		help: "Check against the declared format this spec describes, named <mode>, instead of a built-in one; validation scripts pass it for a step whose mode is a declared format"
+	},
 	{
 		name: "--verbose",
 		arity: 0,
@@ -28282,7 +29020,7 @@ The fixed answerer reads --answers and leaves out the questions it does not cove
 		arity: { names: ["mode", "file"] },
 		group: "Driver plumbing",
 		summary: "Check a steering file's format",
-		details: `Run the steering format <mode> (qa, review or findings) over <file> and print each finding on a line of its own; exits 1 when there are any, or when <file> does not exist. An unknown <mode> is a usage error (exit 2). Reads no workflow and runs from any directory — emitted validation scripts call it.`
+		details: `Run the steering format <mode> (qa, review or findings, or the declared format --spec describes) over <file> and print each finding on a line of its own; exits 1 when there are any, or when <file> does not exist. An unknown <mode> is a usage error (exit 2). Reads no workflow and runs from any directory — emitted validation scripts call it.`
 	},
 	{
 		token: "uncheck",
@@ -28656,7 +29394,8 @@ const parseArgv = (argv) => {
 			...restPositionals[0] !== void 0 ? { mode: restPositionals[0] } : {},
 			...restPositionals[1] !== void 0 ? { file: restPositionals[1] } : {},
 			...bag["--open-questions"] !== void 0 ? { openQuestions: bag["--open-questions"] } : {},
-			...bag["--open-threads"] !== void 0 ? { openThreads: bag["--open-threads"] } : {}
+			...bag["--open-threads"] !== void 0 ? { openThreads: bag["--open-threads"] } : {},
+			...bag["--spec"] !== void 0 ? { spec: bag["--spec"] } : {}
 		},
 		json,
 		verbose
@@ -29413,6 +30152,7 @@ const toError = (e) => e instanceof Error ? e : new Error(String(e));
 * one). Mirrors the guard the deleted `makeInMemoryFileSystem` carried.
 */
 const isGitDirKey = (key) => key.startsWith(".git/");
+const paths = runSync$1(provide(Path$1, layer$4));
 /**
 * `Workspace` for the in-memory tier. `readSync`/`read`/`write`/`committed`
 * take a repo-relative key ONLY (mirroring the live adapter's
@@ -29428,12 +30168,12 @@ const isGitDirKey = (key) => key.startsWith(".git/");
 */
 const makeInMemoryWorkspaceOps = (repo, root) => {
 	const toKey = (path) => {
-		if (!isAbsolute(path)) return path;
+		if (!paths.isAbsolute(path)) return path;
 		const prefix = `${root}/`;
 		return path === root ? "" : path.startsWith(prefix) ? path.slice(prefix.length) : path;
 	};
 	const assertRepoRelative = (path) => {
-		if (isAbsolute(path)) throw new Error(`Workspace: "${path}" is an absolute path — this member takes repo-relative paths only (use "atPath" to read outside the repo)`);
+		if (paths.isAbsolute(path)) throw new Error(`Workspace: "${path}" is an absolute path — this member takes repo-relative paths only (use "atPath" to read outside the repo)`);
 		return path;
 	};
 	const readAt = (key) => isGitDirKey(key) ? void 0 : repo.readFile(key);
@@ -29480,7 +30220,7 @@ const makeInMemoryConfigDiscovery = (repo, root) => {
 	const workspace = makeInMemoryWorkspaceOps(repo, root);
 	return succeed$2(ConfigDiscovery, {
 		legacyRcFiles: (levelRoot, levelHome) => try_({
-			try: () => legacyRcDirs(levelRoot, levelHome).flatMap((dir) => LEGACY_RC_FILES.map((name) => join(dir, name)).filter((filepath) => workspace.atPath(filepath) !== void 0).map((path) => ({
+			try: () => legacyRcDirs(paths, levelRoot, levelHome).flatMap((dir) => LEGACY_RC_FILES.map((name) => paths.join(dir, name)).filter((filepath) => workspace.atPath(filepath) !== void 0).map((path) => ({
 				path,
 				owned: true
 			}))),
@@ -29488,8 +30228,8 @@ const makeInMemoryConfigDiscovery = (repo, root) => {
 		}),
 		workflowModule: (levelRoot, levelHome) => try_({
 			try: () => {
-				for (const dir of walkUp(levelRoot, levelHome)) {
-					const filepath = join(dir, WORKFLOW_MODULE);
+				for (const dir of walkUp(paths, levelRoot, levelHome)) {
+					const filepath = paths.join(dir, WORKFLOW_MODULE);
 					const source = workspace.atPath(filepath);
 					if (source !== void 0) return {
 						filepath,
@@ -29521,26 +30261,41 @@ const gitTestLayer = (repo, root = "/repo") => succeed$2(GitService, fakeGitOper
 * itself; explicit env wins.
 */
 const ambientFlagEnv = (env = process.env) => Object.fromEntries(Object.entries(env).filter((e) => e[0].startsWith("GTD_FLAG_") && e[1] !== void 0));
+/** Where the in-memory host's scratch files go when `TMPDIR` is unset. */
+const IN_MEMORY_SCRATCH = "/scratch";
+const IN_MEMORY_PID = 4242;
+/**
+* The in-memory `Host`: nothing read off the real process or `node:os`.
+* `realPath` is a no-op (there is no real filesystem to resolve symlinks
+* against), so both sides of `assertRunningFromRepoRoot`'s comparison
+* collapse to `root`.
+*/
+const inMemoryHost = (root, home, env, stdin = "") => ({
+	root,
+	home,
+	env,
+	scratchDir: scratchDirOf(env, IN_MEMORY_SCRATCH),
+	realPath: () => succeed$1(root),
+	pid: IN_MEMORY_PID,
+	uid: void 0,
+	self: ["gtd"],
+	stdin: succeed$1(stdin)
+});
 /** Every layer `makeProgram` needs — `CommandRequirements`'s return type here IS the guarantee: a new port added there fails this function's typecheck instead of silently under-providing. */
 function testLayers(repo, opts = {}) {
 	const root = opts.root ?? "/repo";
 	const home = opts.home ?? root;
-	return mergeAll(gitTestLayer(repo, root), succeed$2(Workspace, makeInMemoryWorkspaceOps(repo, root)), Host.layer({
-		root,
-		home,
-		env: {
-			...ambientFlagEnv(),
-			...opts.env
-		},
-		realPath: () => succeed$1(root)
-	}), ConfigService.Live, makeInMemoryConfigDiscovery(repo, root), succeed$2(EngineCore, { source: succeed$1(IN_MEMORY_ENGINE) }), Narrator.layer(opts.narrate ?? (() => {}), opts.verbose ?? true), succeed$2(ToolCommands, {
+	return mergeAll(gitTestLayer(repo, root), succeed$2(Workspace, makeInMemoryWorkspaceOps(repo, root)), succeed$2(Host, inMemoryHost(root, home, {
+		...ambientFlagEnv(),
+		...opts.env
+	}, opts.stdin)), ConfigService.Live, makeInMemoryConfigDiscovery(repo, root), succeed$2(EngineCore, { source: succeed$1(IN_MEMORY_ENGINE) }), Narrator.layer(opts.narrate ?? (() => {}), opts.verbose ?? true), layer$4, succeed$2(ToolCommands, {
 		...missingToolCommands,
 		...opts.tools
 	}), CommandRunner.layer(() => fail$4(/* @__PURE__ */ new Error("gtd ui: CommandRunner has no test double wired into testLayers()"))));
 }
 //#endregion
 //#region src/twins/cliIo.ts
-const makeCapturingCliIo = (repo, env = {}, tools = {}) => {
+const makeCapturingCliIo = (repo, env = {}, tools = {}, stdin = "") => {
 	let stdout = Buffer.alloc(0);
 	let stderr = "";
 	let exitCode = 0;
@@ -29559,7 +30314,8 @@ const makeCapturingCliIo = (repo, env = {}, tools = {}) => {
 				env,
 				narrate: (line) => stderr += line,
 				verbose,
-				tools
+				tools,
+				stdin
 			})
 		},
 		result: () => ({
@@ -30262,13 +31018,13 @@ const recognizeModeContradictionCheck = (repo, commands, block) => {
 	return parsed === void 0 ? void 0 : simulateModeContradictionCheck(repo, commands, parsed);
 };
 const GTD_CHECK_RE = /^gtd check (\S+) (.+)$/;
-/** `gtd check <mode> <file>` — a non-empty findings array fails the script, mirroring a real invocation's non-zero exit under `set -e`. */
+/** `gtd check <mode> <file> [--spec <json>]` — a non-empty findings array fails the script, mirroring a real invocation's non-zero exit under `set -e`. */
 const recognizeGtdCheck = (repo, block) => {
 	const match = GTD_CHECK_RE.exec(block);
 	if (!match) return void 0;
 	const mode = match[1];
-	const [file] = extractQuotedTokens(match[2]);
-	const format = steeringFormatFor(mode);
+	const [file, spec] = extractQuotedTokens(match[2]);
+	const format = / --spec '/.test(match[2]) && spec !== void 0 ? formatFromSpec(spec) : steeringFormatFor(mode);
 	if (format === void 0 || file === void 0) return {
 		kind: "failed",
 		error: `gtd check: unknown mode "${mode}" — known modes: ${BUILT_IN_MODE_NAMES.join(", ")}`
@@ -30495,6 +31251,8 @@ const unrecognized = (block, output = "") => ({
 	error: `${UNRECOGNIZED_PREFIX}${block.split("\n")[0]}`
 });
 Narrator.layer(() => {}, false);
+new TextEncoder();
+new TextDecoder("utf-8", { ignoreBOM: true });
 //#endregion
 //#region src/testkit/imports.ts
 const IDENTIFIER$1 = /^[A-Za-z_$][\w$]*$/;
@@ -30720,8 +31478,8 @@ const testRepo = (options) => {
 		...Object.fromEntries(Object.keys(process.env).filter((name) => name.startsWith("GTD_FLAG_")).map((name) => [name, void 0])),
 		...env
 	} : env;
-	const gtd = async (...args) => {
-		const { io, result } = makeCapturingCliIo(repo, seenEnv());
+	const gtdWithStdin = async (stdin, ...args) => {
+		const { io, result } = makeCapturingCliIo(repo, seenEnv(), {}, stdin);
 		if (typeof workflow !== "string") registry().set(id, workflow);
 		for (const [specifier, module] of modules) registry().set(moduleKey(specifier), module);
 		try {
@@ -30736,20 +31494,7 @@ const testRepo = (options) => {
 		}
 		return result();
 	};
-	const withStdin = async (stdin, fn) => {
-		const saved = Object.getOwnPropertyDescriptor(process, "stdin");
-		const fake = new PassThrough();
-		Object.defineProperty(process, "stdin", {
-			value: fake,
-			configurable: true
-		});
-		fake.end(stdin);
-		try {
-			return await fn();
-		} finally {
-			if (saved) Object.defineProperty(process, "stdin", saved);
-		}
-	};
+	const gtd = (...args) => gtdWithStdin("", ...args);
 	const apply = (what, script) => {
 		if (script.length === 0) return;
 		const applied = applyEmittedScript(repo, commands, script);
@@ -30757,7 +31502,7 @@ const testRepo = (options) => {
 	};
 	/** Runs a write command, then the script its `--json=script` twin prints. */
 	const runWrite = async (args, stdin, refused = (error) => error) => {
-		const call = (...extra) => stdin === void 0 ? gtd(...args, ...extra) : withStdin(stdin, () => gtd(...args, ...extra));
+		const call = (...extra) => gtdWithStdin(stdin ?? "", ...args, ...extra);
 		const reported = await call();
 		if (reported.exitCode !== 0) throw refused(failed(`gtd ${args.join(" ")}`, reported));
 		const script = await call("--json=script");