@pmelab/gtd 62.1.0 → 64.0.0

package/dist/chunks/{testkit-CPzWnl3P.mjs → testkit-zGjNeQNL.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 { 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-DkA51qDa.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 > 2);
+	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 2 — 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;
@@ -22943,6 +23631,9 @@ const TRAILER_READERS = {
 	"Gtd-Pin": (value, into) => {
 		if (value === "add" || value === "remove") into.pin ??= value;
 	},
+	"Gtd-Anchor": (value, into) => {
+		if (HASH_RE.test(value)) into.anchor ??= value;
+	},
 	"Gtd-Format": (value, into) => {
 		if (FORMAT_RE.test(value)) into.format ??= Number(value);
 	},
@@ -22966,6 +23657,7 @@ const parseCommitMessage = (message) => {
 		kept: void 0,
 		approved: void 0,
 		pin: void 0,
+		anchor: void 0,
 		judge: [],
 		marks: [],
 		vars: {},
@@ -22995,15 +23687,19 @@ const formatCommitMessage = (spec) => {
 		...(spec.marks ?? []).map((m) => `Gtd-Mark: ${m.name}=${m.value}`),
 		...trailer("Approved", spec.approved && encodeApproval(spec.approved)),
 		...trailer("Pin", spec.pin),
+		...trailer("Anchor", spec.anchor),
 		...trailer("Branch", spec.branch),
 		...trailer("Version", spec.version),
-		`Gtd-Format: 2`
+		`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(".");
@@ -23091,6 +23787,27 @@ const budgeted = (evidence, budgetBytes) => {
 };
 const sameSkills = (a, b) => (a?.length ?? 0) === (b?.length ?? 0) && (a ?? []).every((skill, i) => skill === b?.[i]);
 const samePersona = (a, b) => a.model === b.model && a.system === b.system && sameSkills(a.skills, b.skills) && sameAccess(a.access, b.access);
+const anchorOf = (parsed) => parsed.pin === "add" ? parsed.anchor : void 0;
+const isAnchor = (commit) => anchorOf(commit.parsed) !== void 0;
+/**
+* The commits every anchor sets aside — those between the commit it names and
+* itself — or a fault for an anchor naming no commit still read.
+*/
+const setAsideBy = (base, all) => {
+	const setAside = /* @__PURE__ */ new Set();
+	if (all.every((c) => anchorOf(c.parsed) === void 0)) return { setAside };
+	let kept = [];
+	for (const commit of all) {
+		const anchor = anchorOf(commit.parsed);
+		if (anchor !== void 0) {
+			const at = anchor === base ? -1 : kept.indexOf(anchor);
+			if (anchor !== base && at === -1) return { fault: `gtd: commit ${short(commit.hash)} anchors the process at ${short(anchor)}, which is no commit replay reads in this episode` };
+			for (const hash of kept.splice(at + 1)) setAside.add(hash);
+		}
+		kept.push(commit.hash);
+	}
+	return { setAside };
+};
 /**
 * Replay one episode: run its entry flow, answering each step from the
 * episode's commits in order, until a step has no commit left — the rest.
@@ -23164,19 +23881,39 @@ const withoutPin = (input) => {
 };
 const replay = async (raw) => {
 	const input = withoutPin(raw);
-	const commits = input.episode.commits.map((c) => ({
+	const all = input.episode.commits.map((c) => ({
 		...c,
 		parsed: parseCommitMessage(c.message)
 	}));
+	const resolved = setAsideBy(input.episode.base.hash, all);
+	if ("fault" in resolved) return {
+		kind: "failed",
+		message: resolved.fault
+	};
+	const setAside = resolved.setAside;
+	const commits = all.filter((c) => !setAside.has(c.hash));
+	const pinned = (raw.episode.commits.at(-1)?.tree ?? raw.episode.base.tree).paths().includes(PIN_PATH);
 	const treeAt = (hash) => hash === input.episode.base.hash ? input.episode.base.tree : commits.find((c) => c.hash === hash)?.tree ?? (hash === input.start ? input.startTree : void 0);
 	let cursor = 0;
 	let pendingUsed = false;
 	let position = input.episode.base;
 	const skipPins = () => {
-		while (cursor < commits.length && commits[cursor].parsed.pin !== void 0) cursor++;
+		while (cursor < commits.length && commits[cursor].parsed.pin !== void 0) {
+			const commit = commits[cursor];
+			cursor++;
+			if (!isAnchor(commit)) continue;
+			position = commit;
+			const to = commit.parsed.parsed?.to;
+			expectedNext = to === void 0 || namesUnpin(commit) ? void 0 : {
+				name: to,
+				hash: commit.hash
+			};
+			anchorPending = expectedNext !== void 0;
+		}
 	};
 	let previousPosition = input.episode.base;
 	let expectedNext;
+	let anchorPending = false;
 	const occurrences = /* @__PURE__ */ new Map();
 	const personas = /* @__PURE__ */ new Map();
 	const scopes = [];
@@ -23319,14 +24056,18 @@ const replay = async (raw) => {
 		}
 		return samePersona(seen, identity) ? void 0 : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in its conversation in memory scope "${step.memoryScope || "root"}" — a conversation has one identity`;
 	};
-	const DIVERGED = "the workflow changed under this process; run `gtd abandon` to start over";
+	const DIVERGED = pinned ? "the workflow changed under this process; run `gtd repin` to continue under it from there, or `gtd abandon` to start over" : "the workflow changed under this process; run `gtd abandon` to start over";
+	const diverged = (message, reached) => ({
+		kind: "divergence",
+		message: `${message} — ${DIVERGED}`,
+		at: position.hash,
+		reached: reached?.name
+	});
 	const blockerAt = (step) => {
 		const expected = expectedNext;
 		expectedNext = void 0;
-		if (expected !== void 0 && expected.name !== step.name) return {
-			kind: "divergence",
-			message: `gtd: commit ${short(expected.hash)} names "${expected.name}" as the next step, but replay reached "${step.name}" — ${DIVERGED}`
-		};
+		anchorPending = false;
+		if (expected !== void 0 && expected.name !== step.name) return diverged(`gtd: commit ${short(expected.hash)} names "${expected.name}" as the next step, but replay reached "${step.name}"`, step);
 		const error = unknownOptions(step) ?? approveConflict(step) ?? modeWithoutFile(step) ?? checkIdentity(step);
 		return error === void 0 ? void 0 : {
 			kind: "failed",
@@ -23337,33 +24078,30 @@ const replay = async (raw) => {
 		if (step.request.kind !== "human" || step.request.options.approve !== true) return void 0;
 		const approved = commit.parsed.approved;
 		if (approved !== void 0 && formatStepId(approved.step) === expected) return void 0;
-		return {
-			kind: "divergence",
-			message: `gtd: commit ${short(commit.hash)} completes approval gate "${expected}" but records no Gtd-Approved for it — ${DIVERGED}`
-		};
+		return diverged(`gtd: commit ${short(commit.hash)} completes approval gate "${expected}" but records no Gtd-Approved for it`, step);
 	};
 	const consumeCommit = (step, commit) => {
 		const recorded = commit.parsed.step;
 		const expected = formatStepId(step.id);
 		if (recorded === void 0 || formatStepId(recorded) !== expected) {
 			const what = recorded === void 0 ? "records no step" : `records step "${formatStepId(recorded)}"`;
-			return finish({
-				kind: "divergence",
-				message: `gtd: commit ${short(commit.hash)} ${what}, but replay expected "${expected}" — ${DIVERGED}`
-			});
+			return finish(diverged(`gtd: commit ${short(commit.hash)} ${what}, but replay expected "${expected}"`, step));
 		}
 		const unapproved = missingApproval(step, commit, expected);
 		if (unapproved !== void 0) return finish(unapproved);
 		cursor++;
 		advance(commit);
+		expectNextOf(commit);
 		skipPins();
 		noteKept(step, commit);
+		return replyFor(step.request, commit.parsed.judge);
+	};
+	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
 		};
-		return replyFor(step.request, commit.parsed.judge);
 	};
 	const noteKept = (step, commit) => {
 		if (commit.parsed.kept === void 0) return;
@@ -23406,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);
@@ -23435,10 +24173,8 @@ const replay = async (raw) => {
 	};
 	const endOfFlow = (via) => {
 		skipPins();
-		return cursor < commits.length ? {
-			kind: "divergence",
-			message: `gtd: the flow ended, but commit ${short(commits[cursor].hash)} continues the episode — ${DIVERGED}`
-		} : {
+		if (anchorPending && cursor === commits.length) return diverged(`gtd: the flow ended, but commit ${short(expectedNext.hash)} continues the process at "${expectedNext.name}"`, void 0);
+		return cursor < commits.length ? diverged(`gtd: the flow ended, but commit ${short(commits[cursor].hash)} continues the episode`, void 0) : {
 			kind: "ended",
 			via,
 			trace,
@@ -23448,6 +24184,7 @@ const replay = async (raw) => {
 	};
 	const changesSince = (hash) => {
 		const tree = treeAt(hash);
+		if (setAside.has(hash)) throw new Error(`gtd: changesSince(${hash}): a repin set ${short(hash)} aside — pass a hash this run read from head() or start()`);
 		if (tree === void 0) throw new Error(`gtd: changesSince(${hash}): ${hash} is not the episode base or one of its commits — pass a hash this run read from head() or start(), not one captured earlier, read from state, or from another branch`);
 		return changesBetween(tree, position.tree);
 	};
@@ -23669,17 +24406,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;
@@ -23693,30 +24430,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
@@ -23729,31 +24469,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;
 };
@@ -23847,19 +24585,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;
@@ -23881,13 +24620,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,
@@ -23895,41 +24634,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 {
@@ -23937,7 +24676,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;
 	}
@@ -23947,13 +24686,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;
 };
@@ -24147,16 +24886,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;
 };
 /**
@@ -24168,40 +24907,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`;
 };
@@ -24215,11 +24954,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;
@@ -24233,18 +24972,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),
@@ -24274,34 +25013,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;
@@ -24558,11 +25305,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
@@ -24571,11 +25322,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
@@ -25030,7 +25782,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
@@ -25043,8 +25795,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",
@@ -25378,11 +26129,21 @@ const approvalEntryOf = (hash, message) => message.approved === void 0 ? [] : [{
 	email: message.approved.email,
 	commit: hash
 }];
+const setAsideIn = (history, location) => {
+	const anchored = setAsideBy(hashAt(history, location.baseIndex) ?? EMPTY_TREE$1, history.slice(location.baseIndex + 1).map((c) => ({
+		hash: c.hash,
+		parsed: parseCommitMessage(c.message)
+	})));
+	return "setAside" in anchored ? anchored.setAside : /* @__PURE__ */ new Set();
+};
 const buildRun = (history, location, closingHash) => {
 	const allProcessCommits = history.slice(location.processStart);
 	const allParsed = allProcessCommits.map((c) => parseCommitMessage(c.message));
 	const processCommits = allProcessCommits.filter((_, i) => allParsed[i].pin !== "add");
 	const parsed = allParsed.filter((m) => m.pin !== "add");
+	const setAside = setAsideIn(history, location);
+	const answering = parsed.filter((_, i) => !setAside.has(processCommits[i].hash));
+	const answeringCommits = processCommits.filter((c) => !setAside.has(c.hash));
 	const first = parsed[0];
 	const startParentHash = hashAt(history, location.processStart - 1) ?? EMPTY_TREE$1;
 	const head = history[history.length - 1];
@@ -25394,10 +26155,10 @@ const buildRun = (history, location, closingHash) => {
 		diffBase: first?.reviewBase ?? startParentHash,
 		trace: processCommits.map((c, i) => traceEntryOf(c.hash, parsed[i])),
 		costEntries: parsed.flatMap((m, i) => costEntriesOf(processCommits[i].hash, m)),
-		judgeVerdicts: parsed.flatMap((m) => m.judge),
+		judgeVerdicts: answering.flatMap((m) => m.judge),
 		pinCommitted: allParsed.some((m) => m.pin === "add"),
-		marks: parsed.flatMap((m) => m.marks),
-		approvals: processCommits.flatMap((c, i) => approvalEntryOf(c.hash, parsed[i])),
+		marks: answering.flatMap((m) => m.marks),
+		approvals: answeringCommits.flatMap((c, i) => approvalEntryOf(c.hash, answering[i])),
 		pinnedVars: { ...first?.vars },
 		headTurn: headTurnOf(head),
 		closingHash,
@@ -25434,7 +26195,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`. */
@@ -25826,6 +26587,43 @@ const restAt = (ref, startOverrides = {}) => gen(function* () {
 	};
 });
 const currentRest = restAt(void 0);
+/**
+* Where `gtd repin` anchors a pinned process the live workflow no longer
+* replays: the commit replay last stood on, and the step the live workflow
+* reaches from there on HEAD's tree — the unpin when the flow ends instead.
+* `undefined` when there is nothing to anchor: no divergence, or no pin.
+*/
+const repinAnchor = gen(function* () {
+	const git = yield* GitService;
+	const config = yield* (yield* ConfigService).load;
+	const workspace = yield* Workspace;
+	const run = yield* computeProcessRun(git, config.workflow);
+	const { def, setup } = yield* setupFor(config, run, workspace, yield* Host);
+	const diverged = yield* promise(() => replayFor(setup));
+	if (diverged.kind !== "divergence" || !headHasPin(workspace, run)) return void 0;
+	const trial = {
+		hash: "",
+		message: formatCommitMessage({
+			actor: "check",
+			from: PIN_STATES.add,
+			to: PIN_STATES.add,
+			pin: "add",
+			anchor: diverged.at
+		}),
+		tree: setup.episode.at(-1)?.tree ?? setup.base.tree
+	};
+	const outcome = yield* promise(() => replayFor({
+		...setup,
+		episode: [...setup.episode, trial]
+	}));
+	if (outcome.kind !== "divergence") return yield* fail$4(replayError(outcome) ?? /* @__PURE__ */ new Error("gtd repin: replay found no step"));
+	const to = outcome.reached ?? PIN_STATES.remove;
+	if (run.workflow === void 0 && to === def.initial) return yield* fail$4(/* @__PURE__ */ new Error(`gtd repin: the live workflow continues this process at "${to}", the default workflow's first step, where a finished process waits — run \`gtd abandon\` to start over`));
+	return {
+		at: diverged.at,
+		to
+	};
+});
 /** The step the process rests at and the trace that reached it — at an unpin, the flow's last step. */
 const restingOn = (outcome, pin) => {
 	if (outcome.kind === "rest") return {
@@ -26156,15 +26954,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");
@@ -26944,12 +27743,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
@@ -27057,19 +27855,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;
@@ -27086,7 +27871,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({
@@ -27134,7 +27919,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")
@@ -27339,20 +28124,28 @@ const runRestoreCommand = (json, out) => gen(function* () {
 	]).required;
 	yield* writeScript(json, out, combinedScript(required, ""));
 });
-/**
-* `gtd repin`: the pin beat's script and landing, on demand. It runs live,
-* so reading the rest first refuses a live workflow that cannot replay the
-* process before any pin is written.
-*/
-const runRepinCommand = (json, out) => gen(function* () {
+/** The step an ordinary repin rests at — the one the process rests at now. */
+const repinTarget = gen(function* () {
 	const rest = yield* currentRest;
 	const refusal = rest.pin === "add" ? "the next beat pins the process already — run it (`gtd next --json=content`), then land" : rest.pin === "remove" ? "the flow has ended — its unpin beat is next, so there is nothing to repin" : noProcessUnderway(rest) ? "no gtd process is underway — nothing to repin" : void 0;
 	if (refusal !== void 0) return yield* fail$4(/* @__PURE__ */ new Error(`gtd repin: ${refusal}`));
+	return rest.step.name;
+});
+/**
+* `gtd repin`: the pin beat's script and landing, on demand. It runs live: a
+* pinned process the live workflow no longer replays is anchored where it
+* diverged, and any other failure to read the rest refuses before any pin is
+* written.
+*/
+const runRepinCommand = (json, out) => gen(function* () {
+	const anchor = yield* repinAnchor;
+	const to = anchor?.to ?? (yield* repinTarget);
 	const message = formatCommitMessage({
 		actor: "check",
 		from: PIN_STATES.add,
-		to: rest.step.name,
-		pin: "add"
+		to,
+		pin: "add",
+		...anchor !== void 0 ? { anchor: anchor.at } : {}
 	});
 	yield* writeScript(json, out, combinedScript(emitScripts([
 		{
@@ -27365,7 +28158,7 @@ const runRepinCommand = (json, out) => gen(function* () {
 		},
 		{
 			kind: "outcome",
-			command: transitionOutcome(PIN_STATES.add, rest.step.name)
+			command: transitionOutcome(PIN_STATES.add, to)
 		}
 	]).required, ""));
 });
@@ -28039,7 +28832,7 @@ With no <name>, list every workflow and door it can start. An unknown <name>, th
 		arity: "none",
 		group: "Start and stop",
 		summary: "Pin the process to the live gtd and workflow",
-		details: `Switch the process underway to the live engine and workflow, the way out when the workflow needs a fix mid-process: the printed script runs the pin beat again, writing \`gtd bundle\`'s output to .gtd/process.gtdpin and committing that file alone. Always runs on the gtd on PATH, never on the pin. Refuses when no process is underway, when the next beat is a pin or unpin beat already, or when the live workflow does not replay the process.
+		details: `Switch the process underway to the live engine and workflow, the way out when the workflow needs a fix mid-process: the printed script runs the pin beat again, writing \`gtd bundle\`'s output to .gtd/process.gtdpin and committing that file alone. Always runs on the gtd on PATH, never on the pin. When the live workflow no longer replays the process, the commit continues from the divergence: a Gtd-Anchor trailer names the last commit it replays, the later commits stay as files only, and the process rests at the step the live workflow reached there. Refuses when no process is underway, when the next beat is a pin or unpin beat already, when an unpinned process diverges, or when the live workflow would continue at the default workflow's first step.
 
   s=$(gtd repin --json=script) && sh -c "$s"`
 	},
@@ -29312,6 +30105,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
@@ -29327,12 +30121,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);
@@ -29379,7 +30173,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
 			}))),
@@ -29387,8 +30181,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,
@@ -29420,26 +30214,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;
@@ -29458,7 +30267,8 @@ const makeCapturingCliIo = (repo, env = {}, tools = {}) => {
 				env,
 				narrate: (line) => stderr += line,
 				verbose,
-				tools
+				tools,
+				stdin
 			})
 		},
 		result: () => ({
@@ -30394,6 +31204,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$]*$/;
@@ -30619,8 +31431,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 {
@@ -30635,20 +31447,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);
@@ -30656,7 +31455,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");