@yielded/agent-storage-memory 0.1.0-beta.173 → 0.1.0-beta.174

package/dist/MemorySubmissionLedger.mjs

@@ -272,1272 +272,1274 @@ function* threadRows(state, threadId, after = -1) {
 		if (stored !== void 0) yield stored;
 	}
 }
-/**
-* Reference in-memory SubmissionLedger. Admission, ordered selection and canonical settlement
-* share the Memory kernel's mutation gate. The kernel Scope owns local Run capabilities;
-* selecting work does not write execution ownership into the ledger.
-*
-* Joining retains the contiguous ready prefix and exact host linkage. Canonical settlement
-* authorizes finalization and child wake repair, while bound sessions reject late commands.
-* Child wake checks read the child rows directly, without a separate notification marker.
-* Admission resolution is strongly consistent; resolveAdmissionFault injects the
-* Indeterminate outcome for existing caller conformance workflows.
-*/
-const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
-	const journal = yield* MemoryThreadStoreKernel;
-	const crypto = yield* Crypto.Crypto;
-	const mintIdentity = (operation) => crypto.randomUUIDv4().pipe(Effect.flatMap(Schema.decodeEffect(MemoryIdentityNonce)), Effect.mapError((cause) => ledgerError(operation, "Cannot mint a Memory identity", cause)));
-	const state = yield* Ref.make({
-		byThread: /* @__PURE__ */ new Map(),
-		receipts: /* @__PURE__ */ new Map(),
-		joinsByHost: /* @__PURE__ */ new Map(),
-		childrenByParent: /* @__PURE__ */ new Map(),
-		submissions: /* @__PURE__ */ new Map(),
-		admissionIndex: /* @__PURE__ */ new Map(),
-		lanes: /* @__PURE__ */ new Map(),
-		childReservations: /* @__PURE__ */ new Map(),
-		freshAdmissionSequence: 0,
-		stoppedWorkers: /* @__PURE__ */ new Map(),
-		latestByThread: /* @__PURE__ */ new Map(),
-		activeByThread: /* @__PURE__ */ new Map()
-	});
-	yield* journal.registerWorkOwner("admissions", {
-		threads: (request) => Ref.get(state).pipe(Effect.map((current) => {
-			const candidates = boundedWorkSelection(request.limit, (id) => id, request.afterThreadId);
-			for (const [threadId, ids] of current.activeByThread) if (ids.size > 0) candidates.add(threadId);
-			const threadIds = candidates.values;
-			const afterThreadId = threadIds.length === request.limit ? threadIds.at(-1) : void 0;
-			return {
-				threadIds,
-				...afterThreadId === void 0 ? {} : { afterThreadId }
-			};
-		})),
-		page: (threadId, after, limit) => Effect.gen(function* () {
-			const current = yield* Ref.get(state);
-			const candidates = boundedWorkSelection(limit + 1, (id) => id, after);
-			for (const id of current.activeByThread.get(threadId) ?? []) candidates.add(id);
-			const ids = candidates.values;
-			const entries = [];
-			for (const id of ids.slice(0, limit)) {
-				const stored = current.submissions.get(id);
-				if (stored === void 0 || stored.row.threadId !== threadId || stored.row.state === "settled") return yield* ThreadStoreError.make({
-					operation: "admission work",
-					message: "Active admission index is incomplete or corrupt"
-				});
-				const entry = admissionWork(stored.row);
-				entries.push(stored.suspension === void 0 ? entry : {
-					...entry,
-					wait: stored.suspension.reason._tag === "WaitingForChild" ? "child" : "approval"
-				});
-			}
-			const next = ids.length > limit ? ids[limit - 1] : void 0;
-			return {
-				entries,
-				...next === void 0 ? {} : { after: next }
-			};
-		})
-	});
-	const admissionFence = yield* SubmissionAdmissionFence;
-	const capabilities = Effect.succeed(LedgerCapabilities.make({ durability: "non-durable" }));
-	const admit = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(AdmissionRequest, "admit", unvalidated);
-		const workerAdmissionJson = request.workerAdmission === void 0 ? void 0 : yield* Schema.encodeEffect(Schema.fromJsonString(WorkerAdmission))(request.workerAdmission).pipe(Effect.mapError(() => ledgerError("admit", "Invalid worker admission metadata")));
-		const messageAdmissionJson = request.messageAdmission === void 0 ? void 0 : yield* Schema.encodeEffect(Schema.fromJsonString(InputMessage))(request.messageAdmission).pipe(Effect.mapError(() => ledgerError("admit", "Invalid message admission metadata")));
-		yield* journal.checkThreadCapacity(request.threadId).pipe(Effect.mapError((cause) => ledgerError("admit", cause.message, cause)));
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const identity = (yield* Ref.get(state)).admissionIndex.has(admissionKey(request.threadId, request.principal, request.idempotencyKey)) ? Result.fail(ledgerError("admit", "Retained admission disappeared")) : yield* Effect.result(mintIdentity("admit"));
-		const services = yield* Effect.context();
-		const decision = yield* Ref.modify(state, (current) => {
-			const key = admissionKey(request.threadId, request.principal, request.idempotencyKey);
-			const existingId = current.admissionIndex.get(key);
-			if (existingId !== void 0) {
-				const existing = current.submissions.get(existingId);
-				if (existing === void 0) return [failure(ledgerError("admit", "Admission index references a missing Submission")), current];
-				if (existing.row.inputDigest !== request.inputDigest || !sameParentLinkage(existing.row.parentLinkage, request.parentLinkage) || existing.row.admissionGroup !== request.admissionGroup || !Schema.toEquivalence(Schema.optional(WorkerAdmission))(existing.row.workerAdmissionJson === void 0 ? void 0 : Schema.decodeSync(Schema.fromJsonString(WorkerAdmission))(existing.row.workerAdmissionJson), request.workerAdmission) || !Schema.toEquivalence(Schema.optional(InputMessage))(existing.row.messageAdmissionJson === void 0 ? void 0 : Schema.decodeSync(Schema.fromJsonString(InputMessage))(existing.row.messageAdmissionJson), request.messageAdmission) || !Schema.toEquivalence(Schema.optional(Schema.Json))(existing.row.admissionFence, request.admissionFence)) return [failure(AdmissionConflict.make({
+const makeSubmissionLedger = Effect.fnUntraced(
+	/**
+	* Reference in-memory SubmissionLedger. Admission, ordered selection and canonical settlement
+	* share the Memory kernel's mutation gate. The kernel Scope owns local Run capabilities;
+	* selecting work does not write execution ownership into the ledger.
+	*
+	* Joining retains the contiguous ready prefix and exact host linkage. Canonical settlement
+	* authorizes finalization and child wake repair, while bound sessions reject late commands.
+	* Child wake checks read the child rows directly, without a separate notification marker.
+	* Admission resolution is strongly consistent; resolveAdmissionFault injects the
+	* Indeterminate outcome for existing caller conformance workflows.
+	*/
+	function* (options = {}) {
+		const journal = yield* MemoryThreadStoreKernel;
+		const crypto = yield* Crypto.Crypto;
+		const mintIdentity = (operation) => crypto.randomUUIDv4().pipe(Effect.flatMap(Schema.decodeEffect(MemoryIdentityNonce)), Effect.mapError((cause) => ledgerError(operation, "Cannot mint a Memory identity", cause)));
+		const state = yield* Ref.make({
+			byThread: /* @__PURE__ */ new Map(),
+			receipts: /* @__PURE__ */ new Map(),
+			joinsByHost: /* @__PURE__ */ new Map(),
+			childrenByParent: /* @__PURE__ */ new Map(),
+			submissions: /* @__PURE__ */ new Map(),
+			admissionIndex: /* @__PURE__ */ new Map(),
+			lanes: /* @__PURE__ */ new Map(),
+			childReservations: /* @__PURE__ */ new Map(),
+			freshAdmissionSequence: 0,
+			stoppedWorkers: /* @__PURE__ */ new Map(),
+			latestByThread: /* @__PURE__ */ new Map(),
+			activeByThread: /* @__PURE__ */ new Map()
+		});
+		yield* journal.registerWorkOwner("admissions", {
+			threads: (request) => Ref.get(state).pipe(Effect.map((current) => {
+				const candidates = boundedWorkSelection(request.limit, (id) => id, request.afterThreadId);
+				for (const [threadId, ids] of current.activeByThread) if (ids.size > 0) candidates.add(threadId);
+				const threadIds = candidates.values;
+				const afterThreadId = threadIds.length === request.limit ? threadIds.at(-1) : void 0;
+				return {
+					threadIds,
+					...afterThreadId === void 0 ? {} : { afterThreadId }
+				};
+			})),
+			page: Effect.fnUntraced(function* (threadId, after, limit) {
+				const current = yield* Ref.get(state);
+				const candidates = boundedWorkSelection(limit + 1, (id) => id, after);
+				for (const id of current.activeByThread.get(threadId) ?? []) candidates.add(id);
+				const ids = candidates.values;
+				const entries = [];
+				for (const id of ids.slice(0, limit)) {
+					const stored = current.submissions.get(id);
+					if (stored === void 0 || stored.row.threadId !== threadId || stored.row.state === "settled") return yield* ThreadStoreError.make({
+						operation: "admission work",
+						message: "Active admission index is incomplete or corrupt"
+					});
+					const entry = admissionWork(stored.row);
+					entries.push(stored.suspension === void 0 ? entry : {
+						...entry,
+						wait: stored.suspension.reason._tag === "WaitingForChild" ? "child" : "approval"
+					});
+				}
+				const next = ids.length > limit ? ids[limit - 1] : void 0;
+				return {
+					entries,
+					...next === void 0 ? {} : { after: next }
+				};
+			})
+		});
+		const admissionFence = yield* SubmissionAdmissionFence;
+		const capabilities = Effect.succeed(LedgerCapabilities.make({ durability: "non-durable" }));
+		const admit = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(AdmissionRequest, "admit", unvalidated);
+			const workerAdmissionJson = request.workerAdmission === void 0 ? void 0 : yield* Schema.encodeEffect(Schema.fromJsonString(WorkerAdmission))(request.workerAdmission).pipe(Effect.mapError(() => ledgerError("admit", "Invalid worker admission metadata")));
+			const messageAdmissionJson = request.messageAdmission === void 0 ? void 0 : yield* Schema.encodeEffect(Schema.fromJsonString(InputMessage))(request.messageAdmission).pipe(Effect.mapError(() => ledgerError("admit", "Invalid message admission metadata")));
+			yield* journal.checkThreadCapacity(request.threadId).pipe(Effect.mapError((cause) => ledgerError("admit", cause.message, cause)));
+			const nowMillis = yield* Clock.currentTimeMillis;
+			const identity = (yield* Ref.get(state)).admissionIndex.has(admissionKey(request.threadId, request.principal, request.idempotencyKey)) ? Result.fail(ledgerError("admit", "Retained admission disappeared")) : yield* Effect.result(mintIdentity("admit"));
+			const services = yield* Effect.context();
+			const decision = yield* Ref.modify(state, (current) => {
+				const key = admissionKey(request.threadId, request.principal, request.idempotencyKey);
+				const existingId = current.admissionIndex.get(key);
+				if (existingId !== void 0) {
+					const existing = current.submissions.get(existingId);
+					if (existing === void 0) return [failure(ledgerError("admit", "Admission index references a missing Submission")), current];
+					if (existing.row.inputDigest !== request.inputDigest || !sameParentLinkage(existing.row.parentLinkage, request.parentLinkage) || existing.row.admissionGroup !== request.admissionGroup || !Schema.toEquivalence(Schema.optional(WorkerAdmission))(existing.row.workerAdmissionJson === void 0 ? void 0 : Schema.decodeSync(Schema.fromJsonString(WorkerAdmission))(existing.row.workerAdmissionJson), request.workerAdmission) || !Schema.toEquivalence(Schema.optional(InputMessage))(existing.row.messageAdmissionJson === void 0 ? void 0 : Schema.decodeSync(Schema.fromJsonString(InputMessage))(existing.row.messageAdmissionJson), request.messageAdmission) || !Schema.toEquivalence(Schema.optional(Schema.Json))(existing.row.admissionFence, request.admissionFence)) return [failure(AdmissionConflict.make({
+						threadId: request.threadId,
+						principal: request.principal,
+						idempotencyKey: request.idempotencyKey,
+						existingInputDigest: existing.row.inputDigest,
+						attemptedInputDigest: request.inputDigest
+					})), current];
+					return [success(AdmissionResult.make({
+						submissionId: existing.row.submissionId,
+						receiptId: existing.row.receiptId,
+						queueSequence: existing.row.queueSequence,
+						state: existing.row.state,
+						replayed: true
+					})), current];
+				}
+				if (current.stoppedWorkers.has(request.threadId)) return [failure(AdmissionPolicyError.make({
+					reason: "refused",
+					code: "worker-stopped"
+				})), current];
+				const first = threadRows(current, request.threadId).next().value;
+				if (first !== void 0) {
+					const previous = first.row.workerAdmissionJson === void 0 ? void 0 : Schema.decodeSync(Schema.fromJsonString(WorkerAdmission))(first.row.workerAdmissionJson);
+					if (!Schema.toEquivalence(Schema.optional(WorkerAdmission.fields.origin))(previous?.origin, request.workerAdmission?.origin)) return [failure(AdmissionPolicyError.make({
+						reason: "refused",
+						code: "worker-origin-conflict"
+					})), current];
+				}
+				const checked = Effect.runSyncExitWith(services)(admissionFence.check(request));
+				if (Exit.isFailure(checked)) return [{
+					_tag: "cause",
+					cause: checked.cause
+				}, current];
+				if (request.admissionGroup !== void 0 && Array.from(current.activeByThread.get(request.threadId) ?? []).some((id) => current.submissions.get(id)?.row.admissionGroup === request.admissionGroup)) return [failure(AdmissionPolicyError.make({
+					reason: "occupied",
+					code: "admission-group"
+				})), current];
+				if (Result.isFailure(identity)) return [failure(identity.failure), current];
+				const lane = current.lanes.get(request.threadId) ?? { nextQueueSequence: 1 };
+				const freshAdmissionSequence = current.freshAdmissionSequence + 1;
+				if (!Number.isSafeInteger(freshAdmissionSequence)) return [failure(ledgerError("admit", "Fresh admission sequence is exhausted")), current];
+				const orderedIdentity = `${String(freshAdmissionSequence).padStart(16, "0")}-${identity.success}`;
+				const submissionId = decodeSubmissionId(`submission-memory-${orderedIdentity}`);
+				const receiptId = decodeReceiptId(`receipt-memory-${orderedIdentity}`);
+				if (current.submissions.has(submissionId) || current.receipts.has(receiptId)) return [failure(ledgerError("admit", "Fresh admission identity already exists")), current];
+				const row = {
+					submissionId,
 					threadId: request.threadId,
+					queueSequence: decodeQueueSequence(lane.nextQueueSequence),
 					principal: request.principal,
 					idempotencyKey: request.idempotencyKey,
-					existingInputDigest: existing.row.inputDigest,
-					attemptedInputDigest: request.inputDigest
-				})), current];
+					agentId: request.agentId,
+					agentDigests: request.agentDigests,
+					deploymentId: request.deploymentId,
+					inputPayload: request.inputPayload,
+					inputDigest: request.inputDigest,
+					receiptId,
+					state: "admitted",
+					settledOutcome: void 0,
+					createdAtMillis: nowMillis,
+					readyAtMillis: void 0,
+					parentLinkage: request.parentLinkage,
+					...workerAdmissionJson === void 0 ? {} : { workerAdmissionJson },
+					...messageAdmissionJson === void 0 ? {} : { messageAdmissionJson },
+					...request.admissionGroup === void 0 ? {} : { admissionGroup: request.admissionGroup },
+					...request.admissionFence === void 0 ? {} : { admissionFence: request.admissionFence }
+				};
+				const stored = {
+					row,
+					inputApplied: void 0,
+					finalization: void 0,
+					abortIntent: void 0,
+					joinedHostSubmissionId: void 0,
+					suspension: void 0,
+					unknownMark: void 0,
+					approvalDecisions: /* @__PURE__ */ new Map(),
+					unknownResolutions: /* @__PURE__ */ new Map()
+				};
+				if (!admissionFitsTransfer(request.threadId, toAdmission(row))) return [failure(transferCapacityError("admit")), current];
+				journal.initializeWork(request.threadId);
+				const admissionIndex = current.admissionIndex;
+				const lanes = current.lanes.set(request.threadId, { nextQueueSequence: lane.nextQueueSequence + 1 });
 				return [success(AdmissionResult.make({
-					submissionId: existing.row.submissionId,
-					receiptId: existing.row.receiptId,
-					queueSequence: existing.row.queueSequence,
-					state: existing.row.state,
-					replayed: true
-				})), current];
+					submissionId: row.submissionId,
+					receiptId: row.receiptId,
+					queueSequence: row.queueSequence,
+					state: row.state,
+					replayed: false
+				})), {
+					...withSubmission(current, stored),
+					admissionIndex,
+					lanes,
+					freshAdmissionSequence
+				}];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
+			if (decision._tag === "cause") {
+				for (const reason of decision.cause.reasons) if (Cause.isDieReason(reason) && Cause.isAsyncFiberError(reason.defect)) {
+					yield* Fiber.interrupt(reason.defect.fiber);
+					return yield* AdmissionPolicyError.make({
+						reason: "unavailable",
+						code: "synchronous-memory-policy-required"
+					});
+				}
+				return yield* Effect.failCause(decision.cause);
 			}
-			if (current.stoppedWorkers.has(request.threadId)) return [failure(AdmissionPolicyError.make({
-				reason: "refused",
-				code: "worker-stopped"
-			})), current];
-			const first = threadRows(current, request.threadId).next().value;
-			if (first !== void 0) {
-				const previous = first.row.workerAdmissionJson === void 0 ? void 0 : Schema.decodeSync(Schema.fromJsonString(WorkerAdmission))(first.row.workerAdmissionJson);
-				if (!Schema.toEquivalence(Schema.optional(WorkerAdmission.fields.origin))(previous?.origin, request.workerAdmission?.origin)) return [failure(AdmissionPolicyError.make({
-					reason: "refused",
-					code: "worker-origin-conflict"
-				})), current];
+			return decision.value;
+		}, Effect.uninterruptible);
+		const markReady = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(MarkReadyRequest, "markReady", unvalidated);
+			const nowMillis = yield* Clock.currentTimeMillis;
+			const decision = yield* Ref.modify(state, (current) => {
+				const stored = current.submissions.get(request.submissionId);
+				if (stored === void 0) return [failure(ledgerError("markReady", `Unknown Submission ${request.submissionId}`)), current];
+				if (stored.row.state !== "admitted") return [success(void 0), current];
+				return [success(void 0), withSubmission(current, {
+					...stored,
+					row: {
+						...stored.row,
+						state: "ready",
+						readyAtMillis: nowMillis
+					}
+				})];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
+		});
+		const lookup = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(SubmissionLookup, "lookup", unvalidated);
+			const current = yield* Ref.get(state);
+			const submissionId = request._tag === "SubmissionLookupById" ? request.submissionId : current.admissionIndex.get(admissionKey(request.threadId, request.principal, request.idempotencyKey));
+			const stored = submissionId === void 0 ? void 0 : current.submissions.get(submissionId);
+			return stored === void 0 ? Option.none() : Option.some(toSnapshot(stored.row));
+		});
+		const resolveAdmission = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(SubmissionLookupByKey, "resolveAdmission", unvalidated);
+			if (options.resolveAdmissionFault !== void 0) {
+				const fault = yield* options.resolveAdmissionFault;
+				if (Option.isSome(fault)) return AdmissionIndeterminate.make({ reason: fault.value });
 			}
-			const checked = Effect.runSyncExitWith(services)(admissionFence.check(request));
-			if (Exit.isFailure(checked)) return [{
-				_tag: "cause",
-				cause: checked.cause
-			}, current];
-			if (request.admissionGroup !== void 0 && Array.from(current.activeByThread.get(request.threadId) ?? []).some((id) => current.submissions.get(id)?.row.admissionGroup === request.admissionGroup)) return [failure(AdmissionPolicyError.make({
-				reason: "occupied",
-				code: "admission-group"
-			})), current];
-			if (Result.isFailure(identity)) return [failure(identity.failure), current];
-			const lane = current.lanes.get(request.threadId) ?? { nextQueueSequence: 1 };
-			const freshAdmissionSequence = current.freshAdmissionSequence + 1;
-			if (!Number.isSafeInteger(freshAdmissionSequence)) return [failure(ledgerError("admit", "Fresh admission sequence is exhausted")), current];
-			const orderedIdentity = `${String(freshAdmissionSequence).padStart(16, "0")}-${identity.success}`;
-			const submissionId = decodeSubmissionId(`submission-memory-${orderedIdentity}`);
-			const receiptId = decodeReceiptId(`receipt-memory-${orderedIdentity}`);
-			if (current.submissions.has(submissionId) || current.receipts.has(receiptId)) return [failure(ledgerError("admit", "Fresh admission identity already exists")), current];
-			const row = {
-				submissionId,
-				threadId: request.threadId,
-				queueSequence: decodeQueueSequence(lane.nextQueueSequence),
-				principal: request.principal,
-				idempotencyKey: request.idempotencyKey,
-				agentId: request.agentId,
-				agentDigests: request.agentDigests,
-				deploymentId: request.deploymentId,
-				inputPayload: request.inputPayload,
-				inputDigest: request.inputDigest,
-				receiptId,
-				state: "admitted",
-				settledOutcome: void 0,
-				createdAtMillis: nowMillis,
-				readyAtMillis: void 0,
-				parentLinkage: request.parentLinkage,
-				...workerAdmissionJson === void 0 ? {} : { workerAdmissionJson },
-				...messageAdmissionJson === void 0 ? {} : { messageAdmissionJson },
-				...request.admissionGroup === void 0 ? {} : { admissionGroup: request.admissionGroup },
-				...request.admissionFence === void 0 ? {} : { admissionFence: request.admissionFence }
-			};
-			const stored = {
-				row,
-				inputApplied: void 0,
-				finalization: void 0,
-				abortIntent: void 0,
-				joinedHostSubmissionId: void 0,
-				suspension: void 0,
-				unknownMark: void 0,
-				approvalDecisions: /* @__PURE__ */ new Map(),
-				unknownResolutions: /* @__PURE__ */ new Map()
-			};
-			if (!admissionFitsTransfer(request.threadId, toAdmission(row))) return [failure(transferCapacityError("admit")), current];
-			journal.initializeWork(request.threadId);
-			const admissionIndex = current.admissionIndex;
-			const lanes = current.lanes.set(request.threadId, { nextQueueSequence: lane.nextQueueSequence + 1 });
-			return [success(AdmissionResult.make({
-				submissionId: row.submissionId,
-				receiptId: row.receiptId,
-				queueSequence: row.queueSequence,
-				state: row.state,
-				replayed: false
-			})), {
-				...withSubmission(current, stored),
-				admissionIndex,
-				lanes,
-				freshAdmissionSequence
-			}];
+			const current = yield* Ref.get(state);
+			const submissionId = current.admissionIndex.get(admissionKey(request.threadId, request.principal, request.idempotencyKey));
+			const stored = submissionId === void 0 ? void 0 : current.submissions.get(submissionId);
+			return stored === void 0 ? AdmissionNotAdmitted.make() : AdmissionAdmitted.make({ submission: toSnapshot(stored.row) });
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-		if (decision._tag === "cause") {
-			for (const reason of decision.cause.reasons) if (Cause.isDieReason(reason) && Cause.isAsyncFiberError(reason.defect)) {
-				yield* Fiber.interrupt(reason.defect.fiber);
-				return yield* AdmissionPolicyError.make({
-					reason: "unavailable",
-					code: "synchronous-memory-policy-required"
+		const selectHead = Effect.fn("MemorySubmissionLedger.selectHead")((unvalidated) => Effect.gen(function* () {
+			const request = yield* validate(ClaimRequest, "claim", unvalidated);
+			const identity = yield* mintIdentity("claim");
+			const decision = yield* Ref.modify(state, (current) => {
+				if (journal.owner.hasOwner(request.threadId)) return [success(Option.none()), current];
+				let head = findHead(current, request.threadId);
+				if (request.handoff !== void 0) {
+					const handoff = request.handoff;
+					const candidates = Array.from(current.activeByThread.get(request.threadId) ?? [], (id) => current.submissions.get(id)).filter((entry) => entry !== void 0 && !(entry.row.state === "unknown" && entry.abortIntent === void 0)).sort((a, b) => a.row.queueSequence - b.row.queueSequence);
+					for (const candidate of candidates) {
+						if (candidate.row.submissionId === handoff.submissionId) {
+							head = candidate;
+							break;
+						}
+						if (!handoff.deferredSubmissionIds.includes(candidate.row.submissionId) || candidate.row.state !== "input-applied" || candidate.abortIntent !== void 0) return [success(Option.none()), current];
+					}
+					if (head?.row.submissionId !== handoff.submissionId || head.row.state !== "ready" && head.row.state !== "input-applied") return [success(Option.none()), current];
+				}
+				if (head === void 0) return [success(Option.none()), current];
+				if (BLOCKED_HEAD_STATES.has(head.row.state)) return [success(Option.none()), current];
+				return [success(Option.some(Claim.make({
+					submissionId: head.row.submissionId,
+					attemptId: decodeAttemptId(`attempt-memory-${identity}`),
+					inputPayload: head.row.inputPayload
+				}))), current];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
+			return decision.value;
+		}));
+		const markInputApplied = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(MarkInputAppliedRequest, "markInputApplied", unvalidated);
+			const decision = yield* Ref.modify(state, (current) => {
+				const stored = current.submissions.get(request.submissionId);
+				if (stored === void 0) return [failure(ledgerError("markInputApplied", `Unknown Submission ${request.submissionId}`)), current];
+				if (!journal.owner.hasOwner(stored.row.threadId, stored.row.submissionId)) return [failure(ownershipLost(stored)), current];
+				if (stored.inputApplied !== void 0) {
+					if (stored.inputApplied.recordId === request.recordId && stored.inputApplied.sequence === request.sequence) return [success(void 0), current];
+					return [failure(ledgerError("markInputApplied", `A different canonical input marker is already recorded for Submission ${request.submissionId}`)), current];
+				}
+				const marker = InputAppliedMarker.make({
+					recordId: request.recordId,
+					sequence: request.sequence
 				});
-			}
-			return yield* Effect.failCause(decision.cause);
-		}
-		return decision.value;
-	}, Effect.uninterruptible);
-	const markReady = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(MarkReadyRequest, "markReady", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("markReady", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.row.state !== "admitted") return [success(void 0), current];
-			return [success(void 0), withSubmission(current, {
-				...stored,
-				row: {
+				const row = STATE_RANK[stored.row.state] < STATE_RANK["input-applied"] ? {
 					...stored.row,
-					state: "ready",
-					readyAtMillis: nowMillis
-				}
-			})];
+					state: "input-applied"
+				} : stored.row;
+				return [success(void 0), withSubmission(current, {
+					...stored,
+					row,
+					inputApplied: marker
+				})];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-	});
-	const lookup = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(SubmissionLookup, "lookup", unvalidated);
-		const current = yield* Ref.get(state);
-		const submissionId = request._tag === "SubmissionLookupById" ? request.submissionId : current.admissionIndex.get(admissionKey(request.threadId, request.principal, request.idempotencyKey));
-		const stored = submissionId === void 0 ? void 0 : current.submissions.get(submissionId);
-		return stored === void 0 ? Option.none() : Option.some(toSnapshot(stored.row));
-	});
-	const resolveAdmission = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(SubmissionLookupByKey, "resolveAdmission", unvalidated);
-		if (options.resolveAdmissionFault !== void 0) {
-			const fault = yield* options.resolveAdmissionFault;
-			if (Option.isSome(fault)) return AdmissionIndeterminate.make({ reason: fault.value });
-		}
-		const current = yield* Ref.get(state);
-		const submissionId = current.admissionIndex.get(admissionKey(request.threadId, request.principal, request.idempotencyKey));
-		const stored = submissionId === void 0 ? void 0 : current.submissions.get(submissionId);
-		return stored === void 0 ? AdmissionNotAdmitted.make() : AdmissionAdmitted.make({ submission: toSnapshot(stored.row) });
-	});
-	const selectHead = Effect.fn("MemorySubmissionLedger.selectHead")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(ClaimRequest, "claim", unvalidated);
-		const identity = yield* mintIdentity("claim");
-		const decision = yield* Ref.modify(state, (current) => {
-			if (journal.owner.hasOwner(request.threadId)) return [success(Option.none()), current];
-			let head = findHead(current, request.threadId);
-			if (request.handoff !== void 0) {
-				const handoff = request.handoff;
-				const candidates = Array.from(current.activeByThread.get(request.threadId) ?? [], (id) => current.submissions.get(id)).filter((entry) => entry !== void 0 && !(entry.row.state === "unknown" && entry.abortIntent === void 0)).sort((a, b) => a.row.queueSequence - b.row.queueSequence);
-				for (const candidate of candidates) {
-					if (candidate.row.submissionId === handoff.submissionId) {
-						head = candidate;
+		const canonicalSettlement = Effect.fnUntraced(function* (submission) {
+			const record = yield* journal.record(submission.threadId, submissionSettlementRecordId(submission.submissionId));
+			if (record === void 0) return void 0;
+			return {
+				record,
+				settlement: yield* validateCanonicalSettlement(record, submission)
+			};
+		});
+		const publish = Effect.fn("MemorySettlementPublisher.publish")(function* (input) {
+			const { request, record, settlement } = yield* validatePublication(input);
+			const prepared = yield* journal.prepareAppend(request.append);
+			return yield* journal.owner.withProgress(request.append.threadId, journal.withMutation(Effect.gen(function* () {
+				const current = yield* Ref.get(state);
+				const stored = current.submissions.get(request.submissionId);
+				if (stored === void 0) return yield* ledgerError("publish settlement", "Unknown Submission");
+				if (stored.row.threadId !== prepared.request.threadId) return yield* ledgerError("publish settlement", "Publication targets another Thread");
+				yield* validateCanonicalSettlement(record, stored.row);
+				const existing = yield* canonicalSettlement(stored.row);
+				const tail = yield* journal.tail(stored.row.threadId);
+				switch (request.authority._tag) {
+					case "Owned":
+						if (!journal.owner.hasOwner(stored.row.threadId, stored.row.submissionId)) return yield* ownershipLost(stored);
+						yield* validateCanonicalSettlement(record, {
+							submissionId: request.submissionId,
+							receiptId: stored.row.receiptId,
+							...settlement.outcome === "aborted" && settlement.runId === void 0 ? {} : { runId: runIdForSubmission(request.submissionId) }
+						});
+						break;
+					case "Joined": {
+						if (stored.row.state !== "joined" && !(stored.row.state === "settled" && existing !== void 0) || stored.joinedHostSubmissionId !== request.authority.hostSubmissionId) return yield* ledgerError("publish settlement", "Submission is not joined to this host");
+						const host = current.submissions.get(request.authority.hostSubmissionId);
+						const canonicalHost = host === void 0 || host.row.threadId !== stored.row.threadId ? void 0 : yield* canonicalSettlement(host.row);
+						if (canonicalHost === void 0) return yield* ledgerError("publish settlement", "Joined host has no canonical settlement");
+						yield* validateJoinedSettlement(settlement, canonicalHost.settlement);
 						break;
 					}
-					if (!handoff.deferredSubmissionIds.includes(candidate.row.submissionId) || candidate.row.state !== "input-applied" || candidate.abortIntent !== void 0) return [success(Option.none()), current];
+					case "QueuedAbort":
+						if (stored.row.state !== "ready" && !(stored.row.state === "settled" && existing !== void 0) || stored.abortIntent === void 0 || journal.owner.hasOwner(stored.row.threadId, stored.row.submissionId) || settlement.outcome !== "aborted") return yield* ledgerError("publish settlement", "Submission is not an unclaimed queued abort");
+						yield* validateCanonicalSettlement(record, {
+							submissionId: request.submissionId,
+							receiptId: stored.row.receiptId,
+							runId: void 0
+						});
 				}
-				if (head?.row.submissionId !== handoff.submissionId || head.row.state !== "ready" && head.row.state !== "input-applied") return [success(Option.none()), current];
-			}
-			if (head === void 0) return [success(Option.none()), current];
-			if (BLOCKED_HEAD_STATES.has(head.row.state)) return [success(Option.none()), current];
-			return [success(Option.some(Claim.make({
-				submissionId: head.row.submissionId,
-				attemptId: decodeAttemptId(`attempt-memory-${identity}`),
-				inputPayload: head.row.inputPayload
-			}))), current];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const markInputApplied = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(MarkInputAppliedRequest, "markInputApplied", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("markInputApplied", `Unknown Submission ${request.submissionId}`)), current];
-			if (!journal.owner.hasOwner(stored.row.threadId, stored.row.submissionId)) return [failure(ownershipLost(stored)), current];
-			if (stored.inputApplied !== void 0) {
-				if (stored.inputApplied.recordId === request.recordId && stored.inputApplied.sequence === request.sequence) return [success(void 0), current];
-				return [failure(ledgerError("markInputApplied", `A different canonical input marker is already recorded for Submission ${request.submissionId}`)), current];
-			}
-			const marker = InputAppliedMarker.make({
-				recordId: request.recordId,
-				sequence: request.sequence
-			});
-			const row = STATE_RANK[stored.row.state] < STATE_RANK["input-applied"] ? {
-				...stored.row,
-				state: "input-applied"
-			} : stored.row;
-			return [success(void 0), withSubmission(current, {
-				...stored,
-				row,
-				inputApplied: marker
-			})];
+				if (existing !== void 0) return SettlementPublicationResult.make({
+					record: existing.record,
+					tailSequence: tail.tailSequence,
+					replayed: true
+				});
+				if (stored.row.state === "settled") return yield* ledgerError("publish settlement", "Finalized Submission has no canonical settlement");
+				const appended = yield* journal.appendPrepared(prepared);
+				return SettlementPublicationResult.make({
+					record,
+					tailSequence: appended.lastSequence,
+					replayed: false
+				});
+			})));
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-	});
-	const canonicalSettlement = Effect.fnUntraced(function* (submission) {
-		const record = yield* journal.record(submission.threadId, submissionSettlementRecordId(submission.submissionId));
-		if (record === void 0) return void 0;
-		return {
-			record,
-			settlement: yield* validateCanonicalSettlement(record, submission)
-		};
-	});
-	const publish = Effect.fn("MemorySettlementPublisher.publish")(function* (input) {
-		const { request, record, settlement } = yield* validatePublication(input);
-		const prepared = yield* journal.prepareAppend(request.append);
-		return yield* journal.owner.withProgress(request.append.threadId, journal.withMutation(Effect.gen(function* () {
-			const current = yield* Ref.get(state);
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return yield* ledgerError("publish settlement", "Unknown Submission");
-			if (stored.row.threadId !== prepared.request.threadId) return yield* ledgerError("publish settlement", "Publication targets another Thread");
-			yield* validateCanonicalSettlement(record, stored.row);
-			const existing = yield* canonicalSettlement(stored.row);
-			const tail = yield* journal.tail(stored.row.threadId);
-			switch (request.authority._tag) {
-				case "Owned":
-					if (!journal.owner.hasOwner(stored.row.threadId, stored.row.submissionId)) return yield* ownershipLost(stored);
-					yield* validateCanonicalSettlement(record, {
-						submissionId: request.submissionId,
+		const finalizeSettlement = Effect.fn("MemorySubmissionLedger.finalizeSettlement")((unvalidated) => Effect.gen(function* () {
+			const request = yield* validate(SettlementFinalization, "finalizeSettlement", unvalidated);
+			const before = (yield* Ref.get(state)).submissions.get(request.submissionId);
+			const canonical = before === void 0 ? void 0 : yield* canonicalSettlement(before.row);
+			if (canonical === void 0) return yield* ledgerError("finalizeSettlement", "Submission has no canonical settlement");
+			const { record, settlement } = canonical;
+			const nowMillis = yield* Clock.currentTimeMillis;
+			const decision = yield* Ref.modify(state, (current) => {
+				const stored = current.submissions.get(request.submissionId);
+				if (stored === void 0) return [failure(ledgerError("finalizeSettlement", `Unknown Submission ${request.submissionId}`)), current];
+				const settlementFailure = settlementFailureFromRecord(record);
+				if (settlement.settlementId !== request.settlementId) return [failure(SettlementConflict.make({
+					submissionId: request.submissionId,
+					existingOutcome: settlement.outcome
+				})), current];
+				if (stored.finalization !== void 0) {
+					if (stored.row.state !== "settled" || stored.row.settledOutcome !== settlement.outcome || stored.finalization.settlementId !== request.settlementId || stored.finalization.recordId !== record.recordId) return [failure(ledgerError("finalizeSettlement", "Finalized identity disagrees with canonical settlement")), current];
+					return [success(Settlement.make({
+						submissionId: stored.row.submissionId,
+						settlementId: settlement.settlementId,
 						receiptId: stored.row.receiptId,
-						...settlement.outcome === "aborted" && settlement.runId === void 0 ? {} : { runId: runIdForSubmission(request.submissionId) }
-					});
-					break;
-				case "Joined": {
-					if (stored.row.state !== "joined" && !(stored.row.state === "settled" && existing !== void 0) || stored.joinedHostSubmissionId !== request.authority.hostSubmissionId) return yield* ledgerError("publish settlement", "Submission is not joined to this host");
-					const host = current.submissions.get(request.authority.hostSubmissionId);
-					const canonicalHost = host === void 0 || host.row.threadId !== stored.row.threadId ? void 0 : yield* canonicalSettlement(host.row);
-					if (canonicalHost === void 0) return yield* ledgerError("publish settlement", "Joined host has no canonical settlement");
-					yield* validateJoinedSettlement(settlement, canonicalHost.settlement);
-					break;
+						outcome: settlement.outcome,
+						...settlementFailure === void 0 ? {} : { failure: settlementFailure },
+						settledAt: utc(stored.finalization.finalizedAtMillis)
+					})), current];
 				}
-				case "QueuedAbort":
-					if (stored.row.state !== "ready" && !(stored.row.state === "settled" && existing !== void 0) || stored.abortIntent === void 0 || journal.owner.hasOwner(stored.row.threadId, stored.row.submissionId) || settlement.outcome !== "aborted") return yield* ledgerError("publish settlement", "Submission is not an unclaimed queued abort");
-					yield* validateCanonicalSettlement(record, {
-						submissionId: request.submissionId,
-						receiptId: stored.row.receiptId,
-						runId: void 0
-					});
-			}
-			if (existing !== void 0) return SettlementPublicationResult.make({
-				record: existing.record,
-				tailSequence: tail.tailSequence,
-				replayed: true
-			});
-			if (stored.row.state === "settled") return yield* ledgerError("publish settlement", "Finalized Submission has no canonical settlement");
-			const appended = yield* journal.appendPrepared(prepared);
-			return SettlementPublicationResult.make({
-				record,
-				tailSequence: appended.lastSequence,
-				replayed: false
-			});
-		})));
-	});
-	const finalizeSettlement = Effect.fn("MemorySubmissionLedger.finalizeSettlement")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(SettlementFinalization, "finalizeSettlement", unvalidated);
-		const before = (yield* Ref.get(state)).submissions.get(request.submissionId);
-		const canonical = before === void 0 ? void 0 : yield* canonicalSettlement(before.row);
-		if (canonical === void 0) return yield* ledgerError("finalizeSettlement", "Submission has no canonical settlement");
-		const { record, settlement } = canonical;
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("finalizeSettlement", `Unknown Submission ${request.submissionId}`)), current];
-			const settlementFailure = settlementFailureFromRecord(record);
-			if (settlement.settlementId !== request.settlementId) return [failure(SettlementConflict.make({
-				submissionId: request.submissionId,
-				existingOutcome: settlement.outcome
-			})), current];
-			if (stored.finalization !== void 0) {
-				if (stored.row.state !== "settled" || stored.row.settledOutcome !== settlement.outcome || stored.finalization.settlementId !== request.settlementId || stored.finalization.recordId !== record.recordId) return [failure(ledgerError("finalizeSettlement", "Finalized identity disagrees with canonical settlement")), current];
+				if (stored.row.state === "settled") return [failure(ledgerError("finalizeSettlement", "Finalized timestamp is missing")), current];
+				const terminal = stored.row.workerAdmissionJson === void 0 ? void 0 : workerTerminalFromRecord(toSnapshot(stored.row), record);
+				const latestId = current.latestByThread.get(stored.row.threadId);
+				const latest = latestId === void 0 ? void 0 : current.submissions.get(latestId);
+				const pendingNewer = terminal === "completed" && latest !== void 0 && latest.row.queueSequence > stored.row.queueSequence && !(latest.joinedHostSubmissionId === stored.row.submissionId && latest.inputApplied !== void 0);
+				let sealed = current;
+				if (terminal !== void 0 && !pendingNewer && !current.stoppedWorkers.has(stored.row.threadId)) {
+					const submissions = current.submissions;
+					if (!transferPageFits(stored.row.threadId)) return [failure(transferCapacityError("finalizeSettlement")), current];
+					for (const apply of [false, true]) for (const id of current.activeByThread.get(stored.row.threadId) ?? []) {
+						const other = submissions.get(id);
+						if (other === void 0) continue;
+						if (id !== stored.row.submissionId && !(other.joinedHostSubmissionId === stored.row.submissionId && other.inputApplied !== void 0) && other.abortIntent === void 0) {
+							const abortIntent = AbortIntent.make({
+								submissionId: id,
+								author: stored.row.principal,
+								reason: `Worker assignment ${terminal}`,
+								requestedAt: utc(nowMillis)
+							});
+							if (!apply && !abortFitsTransfer(other.row.threadId, abortIntent)) return [failure(transferCapacityError("finalizeSettlement")), current];
+							if (apply) withSubmission(current, {
+								...other,
+								abortIntent
+							});
+						}
+					}
+					sealed = {
+						...current,
+						submissions,
+						stoppedWorkers: current.stoppedWorkers.set(stored.row.threadId, terminal)
+					};
+				}
+				const next = withSubmission(sealed, {
+					...stored,
+					row: {
+						...stored.row,
+						state: "settled",
+						settledOutcome: settlement.outcome
+					},
+					finalization: {
+						settlementId: settlement.settlementId,
+						recordId: record.recordId,
+						finalizedAtMillis: nowMillis
+					}
+				});
 				return [success(Settlement.make({
 					submissionId: stored.row.submissionId,
 					settlementId: settlement.settlementId,
 					receiptId: stored.row.receiptId,
 					outcome: settlement.outcome,
 					...settlementFailure === void 0 ? {} : { failure: settlementFailure },
-					settledAt: utc(stored.finalization.finalizedAtMillis)
-				})), current];
-			}
-			if (stored.row.state === "settled") return [failure(ledgerError("finalizeSettlement", "Finalized timestamp is missing")), current];
-			const terminal = stored.row.workerAdmissionJson === void 0 ? void 0 : workerTerminalFromRecord(toSnapshot(stored.row), record);
-			const latestId = current.latestByThread.get(stored.row.threadId);
+					settledAt: utc(nowMillis)
+				})), next];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
+			if (before !== void 0) journal.owner.closeSubmission(before.row.threadId, request.submissionId);
+			return decision.value;
+		}));
+		const inspectWorker = Effect.fnUntraced(function* (threadId) {
+			const current = yield* Ref.get(state);
+			const latestId = current.latestByThread.get(threadId);
 			const latest = latestId === void 0 ? void 0 : current.submissions.get(latestId);
-			const pendingNewer = terminal === "completed" && latest !== void 0 && latest.row.queueSequence > stored.row.queueSequence && !(latest.joinedHostSubmissionId === stored.row.submissionId && latest.inputApplied !== void 0);
-			let sealed = current;
-			if (terminal !== void 0 && !pendingNewer && !current.stoppedWorkers.has(stored.row.threadId)) {
+			const active = [...current.activeByThread.get(threadId) ?? []].flatMap((id) => {
+				const row = current.submissions.get(id);
+				return row === void 0 ? [] : [row];
+			}).sort((a, b) => a.row.queueSequence - b.row.queueSequence)[0];
+			const terminal = current.stoppedWorkers.get(threadId);
+			return WorkerLedgerState.make({
+				latest: latest === void 0 ? null : toSnapshot(latest.row),
+				active: active === void 0 ? null : toSnapshot(active.row),
+				stopped: current.stoppedWorkers.has(threadId),
+				...terminal === void 0 ? {} : { terminal }
+			});
+		});
+		const stopWorker = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(WorkerStopCommand, "stopWorker", unvalidated);
+			const now = yield* Clock.currentTimeMillis;
+			const decision = yield* Ref.modify(state, (current) => {
 				const submissions = current.submissions;
-				if (!transferPageFits(stored.row.threadId)) return [failure(transferCapacityError("finalizeSettlement")), current];
-				for (const apply of [false, true]) for (const id of current.activeByThread.get(stored.row.threadId) ?? []) {
-					const other = submissions.get(id);
-					if (other === void 0) continue;
-					if (id !== stored.row.submissionId && !(other.joinedHostSubmissionId === stored.row.submissionId && other.inputApplied !== void 0) && other.abortIntent === void 0) {
+				let owned = 0;
+				if (!current.stoppedWorkers.has(request.threadId) && !transferPageFits(request.threadId)) return [failure(transferCapacityError("stopWorker")), current];
+				for (const apply of [false, true]) for (const id of current.activeByThread.get(request.threadId) ?? []) {
+					const stored = submissions.get(id);
+					if (stored === void 0) continue;
+					if (!apply && journal.owner.hasOwner(stored.row.threadId, stored.row.submissionId)) owned++;
+					if (stored.abortIntent === void 0) {
 						const abortIntent = AbortIntent.make({
 							submissionId: id,
-							author: stored.row.principal,
-							reason: `Worker assignment ${terminal}`,
-							requestedAt: utc(nowMillis)
+							author: request.author,
+							reason: "Worker owner stopped the worker",
+							requestedAt: utc(now)
 						});
-						if (!apply && !abortFitsTransfer(other.row.threadId, abortIntent)) return [failure(transferCapacityError("finalizeSettlement")), current];
+						if (!apply && !abortFitsTransfer(stored.row.threadId, abortIntent)) return [failure(transferCapacityError("stopWorker")), current];
 						if (apply) withSubmission(current, {
-							...other,
+							...stored,
 							abortIntent
 						});
 					}
 				}
-				sealed = {
+				return [success(owned), {
 					...current,
 					submissions,
-					stoppedWorkers: current.stoppedWorkers.set(stored.row.threadId, terminal)
-				};
-			}
-			const next = withSubmission(sealed, {
-				...stored,
-				row: {
-					...stored.row,
-					state: "settled",
-					settledOutcome: settlement.outcome
-				},
-				finalization: {
-					settlementId: settlement.settlementId,
-					recordId: record.recordId,
-					finalizedAtMillis: nowMillis
-				}
+					stoppedWorkers: current.stoppedWorkers.has(request.threadId) ? current.stoppedWorkers : current.stoppedWorkers.set(request.threadId, void 0)
+				}];
 			});
-			return [success(Settlement.make({
-				submissionId: stored.row.submissionId,
-				settlementId: settlement.settlementId,
-				receiptId: stored.row.receiptId,
-				outcome: settlement.outcome,
-				...settlementFailure === void 0 ? {} : { failure: settlementFailure },
-				settledAt: utc(nowMillis)
-			})), next];
+			if (decision._tag === "failure") return yield* decision.error;
+			return decision.value;
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-		if (before !== void 0) journal.owner.closeSubmission(before.row.threadId, request.submissionId);
-		return decision.value;
-	}));
-	const inspectWorker = Effect.fnUntraced(function* (threadId) {
-		const current = yield* Ref.get(state);
-		const latestId = current.latestByThread.get(threadId);
-		const latest = latestId === void 0 ? void 0 : current.submissions.get(latestId);
-		const active = [...current.activeByThread.get(threadId) ?? []].flatMap((id) => {
-			const row = current.submissions.get(id);
-			return row === void 0 ? [] : [row];
-		}).sort((a, b) => a.row.queueSequence - b.row.queueSequence)[0];
-		const terminal = current.stoppedWorkers.get(threadId);
-		return WorkerLedgerState.make({
-			latest: latest === void 0 ? null : toSnapshot(latest.row),
-			active: active === void 0 ? null : toSnapshot(active.row),
-			stopped: current.stoppedWorkers.has(threadId),
-			...terminal === void 0 ? {} : { terminal }
+		const requestAbort = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(AbortCommand, "requestAbort", unvalidated);
+			const nowMillis = yield* Clock.currentTimeMillis;
+			const decision = yield* Ref.modify(state, (current) => {
+				const stored = current.submissions.get(request.submissionId);
+				if (stored === void 0) return [failure(ledgerError("requestAbort", `Unknown Submission ${request.submissionId}`)), current];
+				if (stored.row.state === "joined") {
+					if (stored.joinedHostSubmissionId === void 0) return [failure(ledgerError("requestAbort", `Joined Submission ${request.submissionId} is missing its host linkage`)), current];
+					return [failure(JoinedToHost.make({
+						submissionId: request.submissionId,
+						hostSubmissionId: stored.joinedHostSubmissionId
+					})), current];
+				}
+				if (stored.row.state === "settled") {
+					if (stored.row.settledOutcome === void 0) return [failure(ledgerError("requestAbort", `Settled Submission ${request.submissionId} is missing its outcome`)), current];
+					return [failure(SettlementConflict.make({
+						submissionId: request.submissionId,
+						existingOutcome: stored.row.settledOutcome
+					})), current];
+				}
+				if (stored.abortIntent !== void 0) return [success(stored.abortIntent), current];
+				const intent = AbortIntent.make({
+					submissionId: request.submissionId,
+					author: request.author,
+					reason: request.reason,
+					requestedAt: utc(nowMillis)
+				});
+				if (!abortFitsTransfer(stored.row.threadId, intent)) return [failure(transferCapacityError("requestAbort")), current];
+				return [success(intent), withSubmission(current, {
+					...stored,
+					abortIntent: intent
+				})];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
+			return decision.value;
 		});
-	});
-	const stopWorker = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(WorkerStopCommand, "stopWorker", unvalidated);
-		const now = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const submissions = current.submissions;
-			let owned = 0;
-			if (!current.stoppedWorkers.has(request.threadId) && !transferPageFits(request.threadId)) return [failure(transferCapacityError("stopWorker")), current];
-			for (const apply of [false, true]) for (const id of current.activeByThread.get(request.threadId) ?? []) {
-				const stored = submissions.get(id);
-				if (stored === void 0) continue;
-				if (!apply && journal.owner.hasOwner(stored.row.threadId, stored.row.submissionId)) owned++;
-				if (stored.abortIntent === void 0) {
-					const abortIntent = AbortIntent.make({
-						submissionId: id,
-						author: request.author,
-						reason: "Worker owner stopped the worker",
-						requestedAt: utc(now)
-					});
-					if (!apply && !abortFitsTransfer(stored.row.threadId, abortIntent)) return [failure(transferCapacityError("stopWorker")), current];
-					if (apply) withSubmission(current, {
+		const claimJoining = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(ClaimJoiningRequest, "claimJoining", unvalidated);
+			const published = /* @__PURE__ */ new Map();
+			const before = yield* Ref.get(state);
+			for (const id of before.activeByThread.get(request.threadId) ?? []) {
+				const stored = before.submissions.get(id);
+				if (stored === void 0 || stored.row.state !== "ready") continue;
+				const canonical = yield* canonicalSettlement(stored.row);
+				if (canonical !== void 0) published.set(stored.row.submissionId, canonical.settlement.outcome);
+			}
+			const decision = yield* Ref.modify(state, (current) => {
+				if (current.stoppedWorkers.has(request.threadId)) return [success([]), current];
+				const host = current.submissions.get(request.hostSubmissionId);
+				if (host === void 0) return [failure(ledgerError("claimJoining", `Unknown Submission ${request.hostSubmissionId}`)), current];
+				if (host.row.threadId !== request.threadId) return [failure(ledgerError("claimJoining", `Host Submission ${request.hostSubmissionId} does not belong to Thread ${request.threadId}`)), current];
+				if (!journal.owner.hasOwner(host.row.threadId, host.row.submissionId)) return [failure(ownershipLost(host)), current];
+				const later = threadRows(current, request.threadId, host.row.queueSequence);
+				const claims = [];
+				const submissions = current.submissions;
+				for (const stored of later) {
+					if (claims.length >= request.maxCount) break;
+					if ((stored.row.state === "joining" || stored.row.state === "joined") && stored.joinedHostSubmissionId === request.hostSubmissionId) continue;
+					if (stored.row.state === "settled" && stored.row.settledOutcome === "aborted") continue;
+					if (stored.row.state !== "ready") break;
+					const terminal = published.get(stored.row.submissionId);
+					if (terminal === "aborted") continue;
+					if (terminal !== void 0) break;
+					withSubmission(current, {
 						...stored,
-						abortIntent
+						row: {
+							...stored.row,
+							state: "joining"
+						},
+						joinedHostSubmissionId: request.hostSubmissionId
 					});
+					claims.push(JoiningClaim.make({
+						submissionId: stored.row.submissionId,
+						queueSequence: stored.row.queueSequence,
+						inputPayload: stored.row.inputPayload
+					}));
 				}
-			}
-			return [success(owned), {
-				...current,
-				submissions,
-				stoppedWorkers: current.stoppedWorkers.has(request.threadId) ? current.stoppedWorkers : current.stoppedWorkers.set(request.threadId, void 0)
-			}];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	});
-	const requestAbort = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(AbortCommand, "requestAbort", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("requestAbort", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.row.state === "joined") {
-				if (stored.joinedHostSubmissionId === void 0) return [failure(ledgerError("requestAbort", `Joined Submission ${request.submissionId} is missing its host linkage`)), current];
-				return [failure(JoinedToHost.make({
-					submissionId: request.submissionId,
-					hostSubmissionId: stored.joinedHostSubmissionId
-				})), current];
-			}
-			if (stored.row.state === "settled") {
-				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("requestAbort", `Settled Submission ${request.submissionId} is missing its outcome`)), current];
-				return [failure(SettlementConflict.make({
-					submissionId: request.submissionId,
-					existingOutcome: stored.row.settledOutcome
-				})), current];
-			}
-			if (stored.abortIntent !== void 0) return [success(stored.abortIntent), current];
-			const intent = AbortIntent.make({
-				submissionId: request.submissionId,
-				author: request.author,
-				reason: request.reason,
-				requestedAt: utc(nowMillis)
+				return [success(claims), {
+					...current,
+					submissions
+				}];
 			});
-			if (!abortFitsTransfer(stored.row.threadId, intent)) return [failure(transferCapacityError("requestAbort")), current];
-			return [success(intent), withSubmission(current, {
-				...stored,
-				abortIntent: intent
-			})];
+			if (decision._tag === "failure") return yield* decision.error;
+			return decision.value;
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	});
-	const claimJoining = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(ClaimJoiningRequest, "claimJoining", unvalidated);
-		const published = /* @__PURE__ */ new Map();
-		const before = yield* Ref.get(state);
-		for (const id of before.activeByThread.get(request.threadId) ?? []) {
-			const stored = before.submissions.get(id);
-			if (stored === void 0 || stored.row.state !== "ready") continue;
-			const canonical = yield* canonicalSettlement(stored.row);
-			if (canonical !== void 0) published.set(stored.row.submissionId, canonical.settlement.outcome);
-		}
-		const decision = yield* Ref.modify(state, (current) => {
-			if (current.stoppedWorkers.has(request.threadId)) return [success([]), current];
-			const host = current.submissions.get(request.hostSubmissionId);
-			if (host === void 0) return [failure(ledgerError("claimJoining", `Unknown Submission ${request.hostSubmissionId}`)), current];
-			if (host.row.threadId !== request.threadId) return [failure(ledgerError("claimJoining", `Host Submission ${request.hostSubmissionId} does not belong to Thread ${request.threadId}`)), current];
-			if (!journal.owner.hasOwner(host.row.threadId, host.row.submissionId)) return [failure(ownershipLost(host)), current];
-			const later = threadRows(current, request.threadId, host.row.queueSequence);
-			const claims = [];
-			const submissions = current.submissions;
-			for (const stored of later) {
-				if (claims.length >= request.maxCount) break;
-				if ((stored.row.state === "joining" || stored.row.state === "joined") && stored.joinedHostSubmissionId === request.hostSubmissionId) continue;
-				if (stored.row.state === "settled" && stored.row.settledOutcome === "aborted") continue;
-				if (stored.row.state !== "ready") break;
-				const terminal = published.get(stored.row.submissionId);
-				if (terminal === "aborted") continue;
-				if (terminal !== void 0) break;
-				withSubmission(current, {
+		const markJoined = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(MarkJoinedRequest, "markJoined", unvalidated);
+			const decision = yield* Ref.modify(state, (current) => {
+				const stored = current.submissions.get(request.submissionId);
+				if (stored === void 0) return [failure(ledgerError("markJoined", `Unknown Submission ${request.submissionId}`)), current];
+				if (stored.joinedHostSubmissionId === void 0) return [failure(ledgerError("markJoined", `Submission ${request.submissionId} was never claimed for joining`)), current];
+				const host = current.submissions.get(stored.joinedHostSubmissionId);
+				if (host === void 0) return [failure(ledgerError("markJoined", `Host Submission ${stored.joinedHostSubmissionId} is missing`)), current];
+				if (!journal.owner.hasOwner(host.row.threadId, host.row.submissionId)) return [failure(ownershipLost(host)), current];
+				if (stored.inputApplied !== void 0) {
+					if (stored.inputApplied.recordId === request.recordId && stored.inputApplied.sequence === request.sequence) return [success(void 0), current];
+					return [failure(ledgerError("markJoined", `A different join marker is already recorded for Submission ${request.submissionId}`)), current];
+				}
+				if (stored.row.state !== "joining" && stored.row.state !== "joined") return [failure(ledgerError("markJoined", `Cannot mark Submission ${request.submissionId} joined from state ${stored.row.state}`)), current];
+				const marker = InputAppliedMarker.make({
+					recordId: request.recordId,
+					sequence: request.sequence
+				});
+				return [success(void 0), withSubmission(current, {
 					...stored,
 					row: {
 						...stored.row,
-						state: "joining"
+						state: "joined"
 					},
-					joinedHostSubmissionId: request.hostSubmissionId
-				});
-				claims.push(JoiningClaim.make({
-					submissionId: stored.row.submissionId,
-					queueSequence: stored.row.queueSequence,
-					inputPayload: stored.row.inputPayload
-				}));
-			}
-			return [success(claims), {
-				...current,
-				submissions
-			}];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	});
-	const markJoined = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(MarkJoinedRequest, "markJoined", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("markJoined", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.joinedHostSubmissionId === void 0) return [failure(ledgerError("markJoined", `Submission ${request.submissionId} was never claimed for joining`)), current];
-			const host = current.submissions.get(stored.joinedHostSubmissionId);
-			if (host === void 0) return [failure(ledgerError("markJoined", `Host Submission ${stored.joinedHostSubmissionId} is missing`)), current];
-			if (!journal.owner.hasOwner(host.row.threadId, host.row.submissionId)) return [failure(ownershipLost(host)), current];
-			if (stored.inputApplied !== void 0) {
-				if (stored.inputApplied.recordId === request.recordId && stored.inputApplied.sequence === request.sequence) return [success(void 0), current];
-				return [failure(ledgerError("markJoined", `A different join marker is already recorded for Submission ${request.submissionId}`)), current];
-			}
-			if (stored.row.state !== "joining" && stored.row.state !== "joined") return [failure(ledgerError("markJoined", `Cannot mark Submission ${request.submissionId} joined from state ${stored.row.state}`)), current];
-			const marker = InputAppliedMarker.make({
-				recordId: request.recordId,
-				sequence: request.sequence
+					inputApplied: marker
+				})];
 			});
-			return [success(void 0), withSubmission(current, {
-				...stored,
-				row: {
-					...stored.row,
-					state: "joined"
-				},
-				inputApplied: marker
-			})];
+			if (decision._tag === "failure") return yield* decision.error;
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-	});
-	const revertJoining = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(RevertJoiningRequest, "revertJoining", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("revertJoining", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.row.state !== "joining") return [success(void 0), current];
-			const guard = request.guard;
-			if (guard !== void 0) {
-				if (stored.joinedHostSubmissionId !== guard.hostSubmissionId) return [success(void 0), current];
-				const host = current.submissions.get(guard.hostSubmissionId);
-				if (host === void 0 || host.row.threadId !== stored.row.threadId) return [failure(ledgerError("revertJoining", `Host Submission ${guard.hostSubmissionId} is missing or belongs to another Thread`)), current];
-				if (host.row.state !== "settled" && !journal.owner.hasOwner(host.row.threadId, host.row.submissionId)) return [failure(ledgerError("revertJoining", "The linked host has no active local session")), current];
-			}
-			return [success(void 0), withSubmission(current, {
-				...stored,
-				row: {
-					...stored.row,
-					state: "ready"
-				},
-				joinedHostSubmissionId: void 0
-			})];
+		const revertJoining = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(RevertJoiningRequest, "revertJoining", unvalidated);
+			const decision = yield* Ref.modify(state, (current) => {
+				const stored = current.submissions.get(request.submissionId);
+				if (stored === void 0) return [failure(ledgerError("revertJoining", `Unknown Submission ${request.submissionId}`)), current];
+				if (stored.row.state !== "joining") return [success(void 0), current];
+				const guard = request.guard;
+				if (guard !== void 0) {
+					if (stored.joinedHostSubmissionId !== guard.hostSubmissionId) return [success(void 0), current];
+					const host = current.submissions.get(guard.hostSubmissionId);
+					if (host === void 0 || host.row.threadId !== stored.row.threadId) return [failure(ledgerError("revertJoining", `Host Submission ${guard.hostSubmissionId} is missing or belongs to another Thread`)), current];
+					if (host.row.state !== "settled" && !journal.owner.hasOwner(host.row.threadId, host.row.submissionId)) return [failure(ledgerError("revertJoining", "The linked host has no active local session")), current];
+				}
+				return [success(void 0), withSubmission(current, {
+					...stored,
+					row: {
+						...stored.row,
+						state: "ready"
+					},
+					joinedHostSubmissionId: void 0
+				})];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-	});
-	const suspend = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(SuspendRequest, "suspend", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const target = (yield* Ref.get(state)).submissions.get(request.submissionId);
-		const canonical = target === void 0 ? void 0 : yield* canonicalSettlement(target.row);
-		const announcedChildren = /* @__PURE__ */ new Set();
-		if (request.reason._tag === "WaitingForChild") {
-			const current = yield* Ref.get(state);
-			for (const { childSubmissionId } of request.reason.children) {
-				const child = current.submissions.get(childSubmissionId);
-				if (child !== void 0 && (yield* canonicalSettlement(child.row)) !== void 0) announcedChildren.add(childSubmissionId);
+		const suspend = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(SuspendRequest, "suspend", unvalidated);
+			const nowMillis = yield* Clock.currentTimeMillis;
+			const target = (yield* Ref.get(state)).submissions.get(request.submissionId);
+			const canonical = target === void 0 ? void 0 : yield* canonicalSettlement(target.row);
+			const announcedChildren = /* @__PURE__ */ new Set();
+			if (request.reason._tag === "WaitingForChild") {
+				const current = yield* Ref.get(state);
+				for (const { childSubmissionId } of request.reason.children) {
+					const child = current.submissions.get(childSubmissionId);
+					if (child !== void 0 && (yield* canonicalSettlement(child.row)) !== void 0) announcedChildren.add(childSubmissionId);
+				}
 			}
-		}
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("suspend", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.row.state === "settled") {
-				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("suspend", `Settled Submission ${request.submissionId} is missing its outcome`)), current];
-				return [failure(SettlementConflict.make({
+			const decision = yield* Ref.modify(state, (current) => {
+				const stored = current.submissions.get(request.submissionId);
+				if (stored === void 0) return [failure(ledgerError("suspend", `Unknown Submission ${request.submissionId}`)), current];
+				if (stored.row.state === "settled") {
+					if (stored.row.settledOutcome === void 0) return [failure(ledgerError("suspend", `Settled Submission ${request.submissionId} is missing its outcome`)), current];
+					return [failure(SettlementConflict.make({
+						submissionId: request.submissionId,
+						existingOutcome: stored.row.settledOutcome
+					})), current];
+				}
+				if (canonical !== void 0) return [failure(SettlementConflict.make({
 					submissionId: request.submissionId,
-					existingOutcome: stored.row.settledOutcome
+					existingOutcome: canonical.settlement.outcome
 				})), current];
-			}
-			if (canonical !== void 0) return [failure(SettlementConflict.make({
-				submissionId: request.submissionId,
-				existingOutcome: canonical.settlement.outcome
-			})), current];
-			if (!journal.owner.hasOwner(stored.row.threadId, stored.row.submissionId)) return [failure(ownershipLost(stored)), current];
-			if (request.reason._tag === "ApprovalPending" ? approvalDecisionsCover(request.reason.toolCallIds, (toolCallId) => stored.approvalDecisions.get(toolCallId)?.decision) : request.reason.children.every((child) => announcedChildren.has(child.childSubmissionId))) return [success("resume-immediately"), current];
-			return [success("suspended"), withSubmission(current, {
-				...stored,
-				row: {
-					...stored.row,
-					state: "suspended"
-				},
-				suspension: {
-					reason: request.reason,
-					suspendedAtMillis: nowMillis
-				}
-			})];
+				if (!journal.owner.hasOwner(stored.row.threadId, stored.row.submissionId)) return [failure(ownershipLost(stored)), current];
+				if (request.reason._tag === "ApprovalPending" ? approvalDecisionsCover(request.reason.toolCallIds, (toolCallId) => stored.approvalDecisions.get(toolCallId)?.decision) : request.reason.children.every((child) => announcedChildren.has(child.childSubmissionId))) return [success("resume-immediately"), current];
+				return [success("suspended"), withSubmission(current, {
+					...stored,
+					row: {
+						...stored.row,
+						state: "suspended"
+					},
+					suspension: {
+						reason: request.reason,
+						suspendedAtMillis: nowMillis
+					}
+				})];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
+			if (decision.value === "suspended" && target !== void 0) journal.owner.closeSubmission(target.row.threadId, request.submissionId);
+			return decision.value;
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-		if (decision.value === "suspended" && target !== void 0) journal.owner.closeSubmission(target.row.threadId, request.submissionId);
-		return decision.value;
-	});
-	const recordApprovalDecision = Effect.fnUntraced(function* (unvalidated) {
-		const command = yield* validate(ApprovalDecisionCommand, "recordApprovalDecision", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(command.submissionId);
-			if (stored === void 0) return [failure(ledgerError("recordApprovalDecision", `Unknown Submission ${command.submissionId}`)), current];
-			if (stored.row.state === "settled") {
-				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("recordApprovalDecision", `Settled Submission ${command.submissionId} is missing its outcome`)), current];
-				return [failure(SettlementConflict.make({
-					submissionId: command.submissionId,
-					existingOutcome: stored.row.settledOutcome
-				})), current];
-			}
-			const existing = stored.approvalDecisions.get(command.toolCallId);
-			if (existing !== void 0) {
-				if (existing.decision !== command.decision) return [failure(ApprovalConflict.make({
+		const recordApprovalDecision = Effect.fnUntraced(function* (unvalidated) {
+			const command = yield* validate(ApprovalDecisionCommand, "recordApprovalDecision", unvalidated);
+			const nowMillis = yield* Clock.currentTimeMillis;
+			const decision = yield* Ref.modify(state, (current) => {
+				const stored = current.submissions.get(command.submissionId);
+				if (stored === void 0) return [failure(ledgerError("recordApprovalDecision", `Unknown Submission ${command.submissionId}`)), current];
+				if (stored.row.state === "settled") {
+					if (stored.row.settledOutcome === void 0) return [failure(ledgerError("recordApprovalDecision", `Settled Submission ${command.submissionId} is missing its outcome`)), current];
+					return [failure(SettlementConflict.make({
+						submissionId: command.submissionId,
+						existingOutcome: stored.row.settledOutcome
+					})), current];
+				}
+				const existing = stored.approvalDecisions.get(command.toolCallId);
+				if (existing !== void 0) {
+					if (existing.decision !== command.decision) return [failure(ApprovalConflict.make({
+						submissionId: command.submissionId,
+						toolCallId: command.toolCallId,
+						existingDecision: existing.decision
+					})), current];
+					return [success(existing), current];
+				}
+				const intent = ApprovalDecisionIntent.make({
 					submissionId: command.submissionId,
 					toolCallId: command.toolCallId,
-					existingDecision: existing.decision
-				})), current];
-				return [success(existing), current];
-			}
-			const intent = ApprovalDecisionIntent.make({
-				submissionId: command.submissionId,
-				toolCallId: command.toolCallId,
-				decision: command.decision,
-				resolver: command.resolver,
-				reason: command.reason,
-				decidedAt: utc(nowMillis)
+					decision: command.decision,
+					resolver: command.resolver,
+					reason: command.reason,
+					decidedAt: utc(nowMillis)
+				});
+				if (!approvalFitsTransfer(stored.row.threadId, intent)) return [failure(transferCapacityError("recordApprovalDecision")), current];
+				const approvalDecisions = new Map(stored.approvalDecisions).set(command.toolCallId, intent);
+				const wakes = stored.row.state === "suspended" && stored.suspension !== void 0 && stored.suspension.reason._tag === "ApprovalPending" && approvalDecisionsCover(stored.suspension.reason.toolCallIds, (toolCallId) => approvalDecisions.get(toolCallId)?.decision);
+				return [success(intent), withSubmission(current, {
+					...stored,
+					row: wakes ? {
+						...stored.row,
+						state: "input-applied"
+					} : stored.row,
+					suspension: wakes ? void 0 : stored.suspension,
+					approvalDecisions
+				})];
 			});
-			if (!approvalFitsTransfer(stored.row.threadId, intent)) return [failure(transferCapacityError("recordApprovalDecision")), current];
-			const approvalDecisions = new Map(stored.approvalDecisions).set(command.toolCallId, intent);
-			const wakes = stored.row.state === "suspended" && stored.suspension !== void 0 && stored.suspension.reason._tag === "ApprovalPending" && approvalDecisionsCover(stored.suspension.reason.toolCallIds, (toolCallId) => approvalDecisions.get(toolCallId)?.decision);
-			return [success(intent), withSubmission(current, {
-				...stored,
-				row: wakes ? {
-					...stored.row,
-					state: "input-applied"
-				} : stored.row,
-				suspension: wakes ? void 0 : stored.suspension,
-				approvalDecisions
-			})];
+			if (decision._tag === "failure") return yield* decision.error;
+			return decision.value;
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	});
-	const markUnknown = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(MarkUnknownRequest, "markUnknown", unvalidated);
-		const target = (yield* Ref.get(state)).submissions.get(request.submissionId);
-		const canonical = target === void 0 ? void 0 : yield* canonicalSettlement(target.row);
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("markUnknown", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.row.state === "settled") {
-				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("markUnknown", `Settled Submission ${request.submissionId} is missing its outcome`)), current];
-				return [failure(SettlementConflict.make({
+		const markUnknown = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(MarkUnknownRequest, "markUnknown", unvalidated);
+			const target = (yield* Ref.get(state)).submissions.get(request.submissionId);
+			const canonical = target === void 0 ? void 0 : yield* canonicalSettlement(target.row);
+			const decision = yield* Ref.modify(state, (current) => {
+				const stored = current.submissions.get(request.submissionId);
+				if (stored === void 0) return [failure(ledgerError("markUnknown", `Unknown Submission ${request.submissionId}`)), current];
+				if (stored.row.state === "settled") {
+					if (stored.row.settledOutcome === void 0) return [failure(ledgerError("markUnknown", `Settled Submission ${request.submissionId} is missing its outcome`)), current];
+					return [failure(SettlementConflict.make({
+						submissionId: request.submissionId,
+						existingOutcome: stored.row.settledOutcome
+					})), current];
+				}
+				if (canonical !== void 0) return [failure(SettlementConflict.make({
 					submissionId: request.submissionId,
-					existingOutcome: stored.row.settledOutcome
+					existingOutcome: canonical.settlement.outcome
 				})), current];
+				const existing = stored.unknownMark;
+				const known = new Set(existing?.toolCallIds ?? []);
+				const merged = [...existing?.toolCallIds ?? [], ...request.toolCallIds.filter((toolCallId) => !known.has(toolCallId))];
+				return [success(void 0), withSubmission(current, {
+					...stored,
+					row: stored.row.state === "unknown" ? stored.row : {
+						...stored.row,
+						state: "unknown"
+					},
+					unknownMark: {
+						reason: existing?.reason ?? request.reason,
+						toolCallIds: merged
+					}
+				})];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
+		});
+		const recordUnknownResolution = Effect.fnUntraced(function* (unvalidated) {
+			const command = yield* validate(UnknownResolutionCommand, "recordUnknownResolution", unvalidated);
+			const nowMillis = yield* Clock.currentTimeMillis;
+			const before = (yield* Ref.get(state)).submissions.get(command.submissionId);
+			const kind = unknownResolutionKind(command.resolution);
+			if (before !== void 0 && kind === "factual" && !before.unknownResolutions.has(JSON.stringify([command.toolCallId, kind]))) {
+				const runId = runIdForSubmission(before.row.submissionId);
+				const outcomes = yield* journal.toolCallResults(before.row.threadId, runId, command.toolCallId);
+				const result = outcomes[0]?.payload;
+				if (outcomes.length > 1 || result !== void 0 && (result._tag !== "ToolCallSettled" || result.runId !== runId || result.toolCallId !== command.toolCallId)) return yield* ledgerError("recordUnknownResolution", "Canonical Tool result identity is inconsistent");
+				if (result?._tag === "ToolCallSettled" && !unknownResolutionMatchesResult(command.resolution, result)) return yield* UnknownResolutionConflict.make({
+					submissionId: command.submissionId,
+					toolCallId: command.toolCallId
+				});
 			}
-			if (canonical !== void 0) return [failure(SettlementConflict.make({
-				submissionId: request.submissionId,
-				existingOutcome: canonical.settlement.outcome
-			})), current];
-			const existing = stored.unknownMark;
-			const known = new Set(existing?.toolCallIds ?? []);
-			const merged = [...existing?.toolCallIds ?? [], ...request.toolCallIds.filter((toolCallId) => !known.has(toolCallId))];
-			return [success(void 0), withSubmission(current, {
-				...stored,
-				row: stored.row.state === "unknown" ? stored.row : {
-					...stored.row,
-					state: "unknown"
-				},
-				unknownMark: {
-					reason: existing?.reason ?? request.reason,
-					toolCallIds: merged
+			const decision = yield* Ref.modify(state, (current) => {
+				const stored = current.submissions.get(command.submissionId);
+				if (stored === void 0) return [failure(ledgerError("recordUnknownResolution", `Unknown Submission ${command.submissionId}`)), current];
+				if (stored.row.state === "settled") {
+					if (stored.row.settledOutcome === void 0) return [failure(ledgerError("recordUnknownResolution", `Settled Submission ${command.submissionId} is missing its outcome`)), current];
+					if (command.resolution._tag !== "CompletedWithResult" && command.resolution._tag !== "NeverHappened") return [failure(SettlementConflict.make({
+						submissionId: command.submissionId,
+						existingOutcome: stored.row.settledOutcome
+					})), current];
 				}
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-	});
-	const recordUnknownResolution = Effect.fnUntraced(function* (unvalidated) {
-		const command = yield* validate(UnknownResolutionCommand, "recordUnknownResolution", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const before = (yield* Ref.get(state)).submissions.get(command.submissionId);
-		const kind = unknownResolutionKind(command.resolution);
-		if (before !== void 0 && kind === "factual" && !before.unknownResolutions.has(JSON.stringify([command.toolCallId, kind]))) {
-			const runId = runIdForSubmission(before.row.submissionId);
-			const outcomes = yield* journal.toolCallResults(before.row.threadId, runId, command.toolCallId);
-			const result = outcomes[0]?.payload;
-			if (outcomes.length > 1 || result !== void 0 && (result._tag !== "ToolCallSettled" || result.runId !== runId || result.toolCallId !== command.toolCallId)) return yield* ledgerError("recordUnknownResolution", "Canonical Tool result identity is inconsistent");
-			if (result?._tag === "ToolCallSettled" && !unknownResolutionMatchesResult(command.resolution, result)) return yield* UnknownResolutionConflict.make({
-				submissionId: command.submissionId,
-				toolCallId: command.toolCallId
-			});
-		}
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(command.submissionId);
-			if (stored === void 0) return [failure(ledgerError("recordUnknownResolution", `Unknown Submission ${command.submissionId}`)), current];
-			if (stored.row.state === "settled") {
-				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("recordUnknownResolution", `Settled Submission ${command.submissionId} is missing its outcome`)), current];
-				if (command.resolution._tag !== "CompletedWithResult" && command.resolution._tag !== "NeverHappened") return [failure(SettlementConflict.make({
+				const key = JSON.stringify([command.toolCallId, kind]);
+				const existing = stored.unknownResolutions.get(key);
+				if (existing !== void 0 && !equivalentUnknownResolution(existing.intent.resolution, command.resolution) || existing === void 0 && kind === "execution" && stored.unknownResolutions.has(JSON.stringify([command.toolCallId, "factual"]))) return [failure(UnknownResolutionConflict.make({
 					submissionId: command.submissionId,
-					existingOutcome: stored.row.settledOutcome
+					toolCallId: command.toolCallId
 				})), current];
-			}
-			const key = JSON.stringify([command.toolCallId, kind]);
-			const existing = stored.unknownResolutions.get(key);
-			if (existing !== void 0 && !equivalentUnknownResolution(existing.intent.resolution, command.resolution) || existing === void 0 && kind === "execution" && stored.unknownResolutions.has(JSON.stringify([command.toolCallId, "factual"]))) return [failure(UnknownResolutionConflict.make({
-				submissionId: command.submissionId,
-				toolCallId: command.toolCallId
-			})), current];
-			const intent = existing?.intent ?? UnknownResolutionIntent.make({
-				submissionId: command.submissionId,
-				toolCallId: command.toolCallId,
-				author: command.author,
-				reason: command.reason,
-				resolution: command.resolution,
-				resolvedAt: utc(nowMillis)
+				const intent = existing?.intent ?? UnknownResolutionIntent.make({
+					submissionId: command.submissionId,
+					toolCallId: command.toolCallId,
+					author: command.author,
+					reason: command.reason,
+					resolution: command.resolution,
+					resolvedAt: utc(nowMillis)
+				});
+				if (existing === void 0 && !resolutionFitsTransfer(stored.row.threadId, intent)) return [failure(transferCapacityError("recordUnknownResolution")), current];
+				const unknownResolutions = existing !== void 0 ? stored.unknownResolutions : new Map(stored.unknownResolutions).set(key, { intent });
+				const wakes = stored.row.state === "unknown" && stored.unknownMark !== void 0 && stored.unknownMark.toolCallIds.every((toolCallId) => unknownResolutions.has(JSON.stringify([toolCallId, "execution"])) || unknownResolutions.has(JSON.stringify([toolCallId, "factual"])));
+				return [success(intent), withSubmission(current, {
+					...stored,
+					row: wakes ? {
+						...stored.row,
+						state: "input-applied"
+					} : stored.row,
+					unknownMark: wakes ? void 0 : stored.unknownMark,
+					unknownResolutions
+				})];
 			});
-			if (existing === void 0 && !resolutionFitsTransfer(stored.row.threadId, intent)) return [failure(transferCapacityError("recordUnknownResolution")), current];
-			const unknownResolutions = existing !== void 0 ? stored.unknownResolutions : new Map(stored.unknownResolutions).set(key, { intent });
-			const wakes = stored.row.state === "unknown" && stored.unknownMark !== void 0 && stored.unknownMark.toolCallIds.every((toolCallId) => unknownResolutions.has(JSON.stringify([toolCallId, "execution"])) || unknownResolutions.has(JSON.stringify([toolCallId, "factual"])));
-			return [success(intent), withSubmission(current, {
-				...stored,
-				row: wakes ? {
-					...stored.row,
-					state: "input-applied"
-				} : stored.row,
-				unknownMark: wakes ? void 0 : stored.unknownMark,
-				unknownResolutions
-			})];
+			if (decision._tag === "failure") return yield* decision.error;
+			return decision.value;
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	});
-	const recordChildSettled = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(ChildSettledNotification, "recordChildSettled", unvalidated);
-		const before = yield* Ref.get(state);
-		const waiting = before.submissions.get(request.parentSubmissionId)?.suspension?.reason;
-		const ids = /* @__PURE__ */ new Set([request.childSubmissionId, ...waiting?._tag === "WaitingForChild" ? waiting.children.map((child) => child.childSubmissionId) : []]);
-		const announcedChildren = /* @__PURE__ */ new Set();
-		for (const id of ids) {
-			const child = before.submissions.get(id);
-			if (child !== void 0 && (yield* canonicalSettlement(child.row)) !== void 0) announcedChildren.add(id);
-		}
-		const decision = yield* Ref.modify(state, (current) => {
-			const parent = current.submissions.get(request.parentSubmissionId);
-			if (parent === void 0) return [failure(ledgerError("recordChildSettled", `Unknown Submission ${request.parentSubmissionId}`)), current];
-			if (!announcedChildren.has(request.childSubmissionId)) return [failure(ledgerError("recordChildSettled", `Child Submission ${request.childSubmissionId} has no recorded settlement`)), current];
-			if (parent.row.state !== "suspended" || parent.suspension === void 0 || parent.suspension.reason._tag !== "WaitingForChild") return [success("not-waiting"), current];
-			const children = parent.suspension.reason.children;
-			if (!children.some((entry) => entry.childSubmissionId === request.childSubmissionId)) return [success("not-waiting"), current];
-			if (!children.every((entry) => announcedChildren.has(entry.childSubmissionId))) return [success("still-waiting"), current];
-			return [success("woken"), withSubmission(current, {
-				...parent,
-				row: {
-					...parent.row,
-					state: "input-applied"
-				},
-				suspension: void 0
-			})];
+		const recordChildSettled = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(ChildSettledNotification, "recordChildSettled", unvalidated);
+			const before = yield* Ref.get(state);
+			const waiting = before.submissions.get(request.parentSubmissionId)?.suspension?.reason;
+			const ids = /* @__PURE__ */ new Set([request.childSubmissionId, ...waiting?._tag === "WaitingForChild" ? waiting.children.map((child) => child.childSubmissionId) : []]);
+			const announcedChildren = /* @__PURE__ */ new Set();
+			for (const id of ids) {
+				const child = before.submissions.get(id);
+				if (child !== void 0 && (yield* canonicalSettlement(child.row)) !== void 0) announcedChildren.add(id);
+			}
+			const decision = yield* Ref.modify(state, (current) => {
+				const parent = current.submissions.get(request.parentSubmissionId);
+				if (parent === void 0) return [failure(ledgerError("recordChildSettled", `Unknown Submission ${request.parentSubmissionId}`)), current];
+				if (!announcedChildren.has(request.childSubmissionId)) return [failure(ledgerError("recordChildSettled", `Child Submission ${request.childSubmissionId} has no recorded settlement`)), current];
+				if (parent.row.state !== "suspended" || parent.suspension === void 0 || parent.suspension.reason._tag !== "WaitingForChild") return [success("not-waiting"), current];
+				const children = parent.suspension.reason.children;
+				if (!children.some((entry) => entry.childSubmissionId === request.childSubmissionId)) return [success("not-waiting"), current];
+				if (!children.every((entry) => announcedChildren.has(entry.childSubmissionId))) return [success("still-waiting"), current];
+				return [success("woken"), withSubmission(current, {
+					...parent,
+					row: {
+						...parent.row,
+						state: "input-applied"
+					},
+					suspension: void 0
+				})];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
+			return decision.value;
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	});
-	const reserveChildBudget = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(ChildBudgetReservationRequest, "reserveChildBudget", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const existing = current.childReservations.get(request.reservationId);
-			if (existing !== void 0) {
-				if (!(existing.parentSubmissionId === request.parentSubmissionId && existing.parentToolCallId === request.parentToolCallId && existing.allocationDigest === request.allocationDigest && equivalentPersistedJson(existing.allocation, request.allocation))) return [failure(ChildReservationConflict.make({
+		const reserveChildBudget = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(ChildBudgetReservationRequest, "reserveChildBudget", unvalidated);
+			const nowMillis = yield* Clock.currentTimeMillis;
+			const decision = yield* Ref.modify(state, (current) => {
+				const existing = current.childReservations.get(request.reservationId);
+				if (existing !== void 0) {
+					if (!(existing.parentSubmissionId === request.parentSubmissionId && existing.parentToolCallId === request.parentToolCallId && existing.allocationDigest === request.allocationDigest && equivalentPersistedJson(existing.allocation, request.allocation))) return [failure(ChildReservationConflict.make({
+						reservationId: request.reservationId,
+						status: existing.status,
+						message: "A reservation with this identity exists with a different parent Tool Call or allocation."
+					})), current];
+					return [success(ReservedChildBudget.make({
+						reservation: toReservationSnapshot(existing),
+						replayed: true
+					})), current];
+				}
+				for (const id of current.childrenByParent.get(request.parentSubmissionId) ?? []) {
+					const reservation = current.childReservations.get(id);
+					if (reservation === void 0) continue;
+					if (reservation.parentSubmissionId === request.parentSubmissionId && reservation.parentToolCallId === request.parentToolCallId) return [failure(ChildReservationConflict.make({
+						reservationId: request.reservationId,
+						status: reservation.status,
+						message: `Parent Tool Call ${request.parentToolCallId} already owns reservation ${reservation.reservationId}.`
+					})), current];
+				}
+				const parent = current.submissions.get(request.parentSubmissionId);
+				if (parent === void 0) return [failure(ledgerError("reserveChildBudget", `Unknown Submission ${request.parentSubmissionId}`)), current];
+				if (!journal.owner.hasOwner(parent.row.threadId, parent.row.submissionId)) return [failure(ownershipLost(parent)), current];
+				const reservation = {
 					reservationId: request.reservationId,
-					status: existing.status,
-					message: "A reservation with this identity exists with a different parent Tool Call or allocation."
-				})), current];
+					parentSubmissionId: request.parentSubmissionId,
+					parentToolCallId: request.parentToolCallId,
+					childSubmissionId: void 0,
+					status: "reserved",
+					allocation: request.allocation,
+					allocationDigest: request.allocationDigest,
+					accounting: void 0,
+					reservedAtMillis: nowMillis,
+					releaseBeganAtMillis: void 0,
+					releasedAtMillis: void 0
+				};
 				return [success(ReservedChildBudget.make({
-					reservation: toReservationSnapshot(existing),
-					replayed: true
-				})), current];
-			}
-			for (const id of current.childrenByParent.get(request.parentSubmissionId) ?? []) {
-				const reservation = current.childReservations.get(id);
-				if (reservation === void 0) continue;
-				if (reservation.parentSubmissionId === request.parentSubmissionId && reservation.parentToolCallId === request.parentToolCallId) return [failure(ChildReservationConflict.make({
+					reservation: toReservationSnapshot(reservation),
+					replayed: false
+				})), withChildReservation(current, reservation)];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
+			return decision.value;
+		});
+		const attachChildToReservation = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(AttachChildToReservationRequest, "attachChildToReservation", unvalidated);
+			const decision = yield* Ref.modify(state, (current) => {
+				const reservation = current.childReservations.get(request.reservationId);
+				if (reservation === void 0) return [failure(ledgerError("attachChildToReservation", `Unknown child reservation ${request.reservationId}`)), current];
+				if (reservation.childSubmissionId !== void 0) {
+					if (reservation.childSubmissionId === request.childSubmissionId) return [success(toReservationSnapshot(reservation)), current];
+					return [failure(ChildReservationConflict.make({
+						reservationId: request.reservationId,
+						status: reservation.status,
+						message: `Reservation ${request.reservationId} already records child ${reservation.childSubmissionId}.`
+					})), current];
+				}
+				const parent = current.submissions.get(reservation.parentSubmissionId);
+				if (parent === void 0) return [failure(ledgerError("attachChildToReservation", `Unknown Submission ${reservation.parentSubmissionId}`)), current];
+				if (!journal.owner.hasOwner(parent.row.threadId, parent.row.submissionId)) return [failure(ownershipLost(parent)), current];
+				if (reservation.status !== "reserved") return [failure(ChildReservationConflict.make({
 					reservationId: request.reservationId,
 					status: reservation.status,
-					message: `Parent Tool Call ${request.parentToolCallId} already owns reservation ${reservation.reservationId}.`
+					message: `Cannot attach a child to a ${reservation.status} reservation.`
 				})), current];
-			}
-			const parent = current.submissions.get(request.parentSubmissionId);
-			if (parent === void 0) return [failure(ledgerError("reserveChildBudget", `Unknown Submission ${request.parentSubmissionId}`)), current];
-			if (!journal.owner.hasOwner(parent.row.threadId, parent.row.submissionId)) return [failure(ownershipLost(parent)), current];
-			const reservation = {
-				reservationId: request.reservationId,
-				parentSubmissionId: request.parentSubmissionId,
-				parentToolCallId: request.parentToolCallId,
-				childSubmissionId: void 0,
-				status: "reserved",
-				allocation: request.allocation,
-				allocationDigest: request.allocationDigest,
-				accounting: void 0,
-				reservedAtMillis: nowMillis,
-				releaseBeganAtMillis: void 0,
-				releasedAtMillis: void 0
-			};
-			return [success(ReservedChildBudget.make({
-				reservation: toReservationSnapshot(reservation),
-				replayed: false
-			})), withChildReservation(current, reservation)];
+				if (!current.submissions.has(request.childSubmissionId)) return [failure(ledgerError("attachChildToReservation", `Unknown child Submission ${request.childSubmissionId}`)), current];
+				const attached = {
+					...reservation,
+					childSubmissionId: request.childSubmissionId
+				};
+				return [success(toReservationSnapshot(attached)), withChildReservation(current, attached)];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
+			return decision.value;
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	});
-	const attachChildToReservation = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(AttachChildToReservationRequest, "attachChildToReservation", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const reservation = current.childReservations.get(request.reservationId);
-			if (reservation === void 0) return [failure(ledgerError("attachChildToReservation", `Unknown child reservation ${request.reservationId}`)), current];
-			if (reservation.childSubmissionId !== void 0) {
-				if (reservation.childSubmissionId === request.childSubmissionId) return [success(toReservationSnapshot(reservation)), current];
-				return [failure(ChildReservationConflict.make({
+		const beginChildBudgetRelease = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(BeginChildBudgetReleaseRequest, "beginChildBudgetRelease", unvalidated);
+			const nowMillis = yield* Clock.currentTimeMillis;
+			const decision = yield* Ref.modify(state, (current) => {
+				const reservation = current.childReservations.get(request.reservationId);
+				if (reservation === void 0) return [failure(ledgerError("beginChildBudgetRelease", `Unknown child reservation ${request.reservationId}`)), current];
+				if (reservation.status !== "reserved") {
+					if (reservation.accounting !== void 0 && equivalentPersistedJson(reservation.accounting, request.accounting)) return [success(toReservationSnapshot(reservation)), current];
+					return [failure(ChildReservationConflict.make({
+						reservationId: request.reservationId,
+						status: reservation.status,
+						message: "A different accounting decision is already frozen for this reservation."
+					})), current];
+				}
+				const frozen = {
+					...reservation,
+					status: "releasePending",
+					accounting: request.accounting,
+					releaseBeganAtMillis: nowMillis
+				};
+				return [success(toReservationSnapshot(frozen)), withChildReservation(current, frozen)];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
+			return decision.value;
+		});
+		const releaseChildBudget = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(ReleaseChildBudgetRequest, "releaseChildBudget", unvalidated);
+			const nowMillis = yield* Clock.currentTimeMillis;
+			const decision = yield* Ref.modify(state, (current) => {
+				const reservation = current.childReservations.get(request.reservationId);
+				if (reservation === void 0) return [failure(ledgerError("releaseChildBudget", `Unknown child reservation ${request.reservationId}`)), current];
+				if (reservation.status === "released") return [success(toReservationSnapshot(reservation)), current];
+				if (reservation.status !== "releasePending") return [failure(ChildReservationConflict.make({
 					reservationId: request.reservationId,
 					status: reservation.status,
-					message: `Reservation ${request.reservationId} already records child ${reservation.childSubmissionId}.`
+					message: "Cannot release a reservation whose accounting decision is not frozen."
 				})), current];
+				const released = {
+					...reservation,
+					status: "released",
+					releasedAtMillis: nowMillis
+				};
+				return [success(toReservationSnapshot(released)), withChildReservation(current, released)];
+			});
+			if (decision._tag === "failure") return yield* decision.error;
+			return decision.value;
+		});
+		const scanNonterminal = Stream.paginate(void 0, (after) => Effect.sync(() => {
+			const current = MutableRef.get(state.ref);
+			const candidates = boundedWorkSelection(8, (stored) => `${stored.row.threadId}\u0000${String(stored.row.queueSequence).padStart(16, "0")}`, after);
+			for (const ids of current.activeByThread.values()) for (const id of ids) {
+				const stored = current.submissions.get(id);
+				if (stored !== void 0) candidates.add(stored);
 			}
-			const parent = current.submissions.get(reservation.parentSubmissionId);
-			if (parent === void 0) return [failure(ledgerError("attachChildToReservation", `Unknown Submission ${reservation.parentSubmissionId}`)), current];
-			if (!journal.owner.hasOwner(parent.row.threadId, parent.row.submissionId)) return [failure(ownershipLost(parent)), current];
-			if (reservation.status !== "reserved") return [failure(ChildReservationConflict.make({
-				reservationId: request.reservationId,
-				status: reservation.status,
-				message: `Cannot attach a child to a ${reservation.status} reservation.`
-			})), current];
-			if (!current.submissions.has(request.childSubmissionId)) return [failure(ledgerError("attachChildToReservation", `Unknown child Submission ${request.childSubmissionId}`)), current];
-			const attached = {
-				...reservation,
-				childSubmissionId: request.childSubmissionId
-			};
-			return [success(toReservationSnapshot(attached)), withChildReservation(current, attached)];
+			const items = candidates.values.map(({ row }) => SubmissionWorkItem.make(row));
+			const last = candidates.values.at(-1)?.row;
+			return [items, last === void 0 ? Option.none() : Option.some(`${last.threadId}\u0000${String(last.queueSequence).padStart(16, "0")}`)];
+		}));
+		const readAbortIntent = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(AbortIntentRequest, "readAbortIntent", unvalidated);
+			const stored = (yield* Ref.get(state)).submissions.get(request.submissionId);
+			if (stored === void 0) return yield* ledgerError("readAbortIntent", `Unknown Submission ${request.submissionId}`);
+			return stored.abortIntent;
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	});
-	const beginChildBudgetRelease = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(BeginChildBudgetReleaseRequest, "beginChildBudgetRelease", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const reservation = current.childReservations.get(request.reservationId);
-			if (reservation === void 0) return [failure(ledgerError("beginChildBudgetRelease", `Unknown child reservation ${request.reservationId}`)), current];
-			if (reservation.status !== "reserved") {
-				if (reservation.accounting !== void 0 && equivalentPersistedJson(reservation.accounting, request.accounting)) return [success(toReservationSnapshot(reservation)), current];
-				return [failure(ChildReservationConflict.make({
-					reservationId: request.reservationId,
-					status: reservation.status,
-					message: "A different accounting decision is already frozen for this reservation."
-				})), current];
+		const loadRecoverySnapshot = Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(RecoverySnapshotRequest, "loadRecoverySnapshot", unvalidated);
+			const current = yield* Ref.get(state);
+			const stored = current.submissions.get(request.submissionId);
+			if (stored === void 0) return yield* ledgerError("loadRecoverySnapshot", `Unknown Submission ${request.submissionId}`);
+			const joins = Array.from(current.joinsByHost.get(request.submissionId) ?? [], (id) => current.submissions.get(id)).filter((candidate) => candidate !== void 0).sort((left, right) => left.row.queueSequence - right.row.queueSequence).map((candidate) => JoinSnapshot.make({
+				submissionId: candidate.row.submissionId,
+				state: candidate.row.state,
+				hostSubmissionId: request.submissionId
+			}));
+			const byToolCallId = (left, right) => left.toolCallId < right.toolCallId ? -1 : left.toolCallId > right.toolCallId ? 1 : 0;
+			const childReservations = Array.from(current.childrenByParent.get(request.submissionId) ?? [], (id) => current.childReservations.get(id)).filter((reservation) => reservation !== void 0).sort((left, right) => left.parentToolCallId < right.parentToolCallId ? -1 : left.parentToolCallId > right.parentToolCallId ? 1 : 0);
+			const childAttachments = [];
+			for (const reservation of childReservations) {
+				if (reservation.childSubmissionId === void 0) continue;
+				const child = current.submissions.get(reservation.childSubmissionId);
+				if (child === void 0) continue;
+				childAttachments.push(ChildAttachmentSnapshot.make({
+					toolCallId: reservation.parentToolCallId,
+					childSubmissionId: reservation.childSubmissionId,
+					childState: child.row.state,
+					...child.row.settledOutcome === void 0 ? {} : { childOutcome: child.row.settledOutcome }
+				}));
 			}
-			const frozen = {
-				...reservation,
-				status: "releasePending",
-				accounting: request.accounting,
-				releaseBeganAtMillis: nowMillis
-			};
-			return [success(toReservationSnapshot(frozen)), withChildReservation(current, frozen)];
+			return RecoverySnapshot.make({
+				submission: toSnapshot(stored.row),
+				joins,
+				approvalDecisions: [...stored.approvalDecisions.values()].sort(byToolCallId),
+				unknownResolutions: [...stored.unknownResolutions.values()].map((resolution) => resolution.intent).sort(byToolCallId),
+				childReservations: childReservations.map(toReservationSnapshot),
+				childAttachments,
+				...stored.row.parentLinkage === void 0 ? {} : { parentLinkage: stored.row.parentLinkage },
+				...stored.joinedHostSubmissionId === void 0 ? {} : { hostSubmissionId: stored.joinedHostSubmissionId },
+				...stored.suspension === void 0 ? {} : { suspension: SuspensionSnapshot.make({
+					reason: stored.suspension.reason,
+					suspendedAt: utc(stored.suspension.suspendedAtMillis)
+				}) },
+				hasOwner: journal.owner.hasOwner(stored.row.threadId, stored.row.submissionId),
+				...stored.inputApplied === void 0 ? {} : { inputApplied: stored.inputApplied },
+				...stored.abortIntent === void 0 ? {} : { abortIntent: stored.abortIntent }
+			});
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	});
-	const releaseChildBudget = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(ReleaseChildBudgetRequest, "releaseChildBudget", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const reservation = current.childReservations.get(request.reservationId);
-			if (reservation === void 0) return [failure(ledgerError("releaseChildBudget", `Unknown child reservation ${request.reservationId}`)), current];
-			if (reservation.status === "released") return [success(toReservationSnapshot(reservation)), current];
-			if (reservation.status !== "releasePending") return [failure(ChildReservationConflict.make({
-				reservationId: request.reservationId,
-				status: reservation.status,
-				message: "Cannot release a reservation whose accounting decision is not frozen."
-			})), current];
-			const released = {
-				...reservation,
-				status: "released",
-				releasedAtMillis: nowMillis
-			};
-			return [success(toReservationSnapshot(released)), withChildReservation(current, released)];
+		const ledger = SubmissionLedger.of({
+			capabilities,
+			resolveFundingOwner: Effect.fnUntraced(function* (unvalidated) {
+				const request = yield* validate(FundingOwnerRequest, "funding owner", unvalidated);
+				const current = MutableRef.get(state.ref);
+				const selected = current.submissions.get(request.submissionId);
+				if (selected === void 0 || selected.row.threadId !== request.threadId) return yield* ledgerError("funding owner", "Selected admission belongs to another Thread or is missing");
+				if (selected.row.state === "joining" || selected.joinedHostSubmissionId !== void 0 && selected.inputApplied === void 0) return yield* ledgerError("funding owner", "Joining funding owner is not yet frozen by exact applied input evidence");
+				const owner = selected.joinedHostSubmissionId === void 0 ? selected : current.submissions.get(selected.joinedHostSubmissionId);
+				if (owner === void 0 || owner.row.threadId !== request.threadId || owner !== selected && owner.row.queueSequence >= selected.row.queueSequence) return yield* ledgerError("funding owner", "Exact joined funding owner is missing or inconsistent");
+				return FundingOwner.make({
+					selected: toSnapshot(selected.row),
+					owner: toSnapshot(owner.row)
+				});
+			}),
+			admit: (request) => journal.withMutation(admit(request)),
+			markReady: (request) => journal.withMutation(markReady(request)),
+			lookup,
+			resolveAdmission,
+			selectHead: (request) => journal.withMutation(selectHead(request)),
+			markInputApplied: (request) => journal.withMutation(markInputApplied(request)),
+			finalizeSettlement: (request) => journal.withMutation(finalizeSettlement(request)),
+			requestAbort: (request) => journal.withMutation(requestAbort(request)),
+			stopWorker: (request) => journal.withMutation(stopWorker(request)),
+			inspectWorker,
+			claimJoining: (request) => journal.withMutation(claimJoining(request)),
+			markJoined: (request) => journal.withMutation(markJoined(request)),
+			revertJoining: (request) => journal.withMutation(revertJoining(request)),
+			suspend: (request) => journal.withMutation(suspend(request)),
+			recordApprovalDecision: (request) => journal.withMutation(recordApprovalDecision(request)),
+			markUnknown: (request) => journal.withMutation(markUnknown(request)),
+			recordUnknownResolution: (request) => journal.withMutation(recordUnknownResolution(request)),
+			recordChildSettled: (request) => journal.withMutation(recordChildSettled(request)),
+			reserveChildBudget: (request) => journal.withMutation(reserveChildBudget(request)),
+			attachChildToReservation: (request) => journal.withMutation(attachChildToReservation(request)),
+			beginChildBudgetRelease: (request) => journal.withMutation(beginChildBudgetRelease(request)),
+			releaseChildBudget: (request) => journal.withMutation(releaseChildBudget(request)),
+			scanNonterminal,
+			loadRecoverySnapshot,
+			readAbortIntent
 		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	});
-	const scanNonterminal = Stream.paginate(void 0, (after) => Effect.sync(() => {
-		const current = MutableRef.get(state.ref);
-		const candidates = boundedWorkSelection(8, (stored) => `${stored.row.threadId}\u0000${String(stored.row.queueSequence).padStart(16, "0")}`, after);
-		for (const ids of current.activeByThread.values()) for (const id of ids) {
-			const stored = current.submissions.get(id);
-			if (stored !== void 0) candidates.add(stored);
-		}
-		const items = candidates.values.map(({ row }) => SubmissionWorkItem.make(row));
-		const last = candidates.values.at(-1)?.row;
-		return [items, last === void 0 ? Option.none() : Option.some(`${last.threadId}\u0000${String(last.queueSequence).padStart(16, "0")}`)];
-	}));
-	const readAbortIntent = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(AbortIntentRequest, "readAbortIntent", unvalidated);
-		const stored = (yield* Ref.get(state)).submissions.get(request.submissionId);
-		if (stored === void 0) return yield* ledgerError("readAbortIntent", `Unknown Submission ${request.submissionId}`);
-		return stored.abortIntent;
-	});
-	const loadRecoverySnapshot = Effect.fnUntraced(function* (unvalidated) {
-		const request = yield* validate(RecoverySnapshotRequest, "loadRecoverySnapshot", unvalidated);
-		const current = yield* Ref.get(state);
-		const stored = current.submissions.get(request.submissionId);
-		if (stored === void 0) return yield* ledgerError("loadRecoverySnapshot", `Unknown Submission ${request.submissionId}`);
-		const joins = Array.from(current.joinsByHost.get(request.submissionId) ?? [], (id) => current.submissions.get(id)).filter((candidate) => candidate !== void 0).sort((left, right) => left.row.queueSequence - right.row.queueSequence).map((candidate) => JoinSnapshot.make({
-			submissionId: candidate.row.submissionId,
-			state: candidate.row.state,
-			hostSubmissionId: request.submissionId
-		}));
-		const byToolCallId = (left, right) => left.toolCallId < right.toolCallId ? -1 : left.toolCallId > right.toolCallId ? 1 : 0;
-		const childReservations = Array.from(current.childrenByParent.get(request.submissionId) ?? [], (id) => current.childReservations.get(id)).filter((reservation) => reservation !== void 0).sort((left, right) => left.parentToolCallId < right.parentToolCallId ? -1 : left.parentToolCallId > right.parentToolCallId ? 1 : 0);
-		const childAttachments = [];
-		for (const reservation of childReservations) {
-			if (reservation.childSubmissionId === void 0) continue;
-			const child = current.submissions.get(reservation.childSubmissionId);
-			if (child === void 0) continue;
-			childAttachments.push(ChildAttachmentSnapshot.make({
-				toolCallId: reservation.parentToolCallId,
-				childSubmissionId: reservation.childSubmissionId,
-				childState: child.row.state,
-				...child.row.settledOutcome === void 0 ? {} : { childOutcome: child.row.settledOutcome }
-			}));
-		}
-		return RecoverySnapshot.make({
-			submission: toSnapshot(stored.row),
-			joins,
-			approvalDecisions: [...stored.approvalDecisions.values()].sort(byToolCallId),
-			unknownResolutions: [...stored.unknownResolutions.values()].map((resolution) => resolution.intent).sort(byToolCallId),
-			childReservations: childReservations.map(toReservationSnapshot),
-			childAttachments,
-			...stored.row.parentLinkage === void 0 ? {} : { parentLinkage: stored.row.parentLinkage },
-			...stored.joinedHostSubmissionId === void 0 ? {} : { hostSubmissionId: stored.joinedHostSubmissionId },
-			...stored.suspension === void 0 ? {} : { suspension: SuspensionSnapshot.make({
-				reason: stored.suspension.reason,
-				suspendedAt: utc(stored.suspension.suspendedAtMillis)
-			}) },
-			hasOwner: journal.owner.hasOwner(stored.row.threadId, stored.row.submissionId),
-			...stored.inputApplied === void 0 ? {} : { inputApplied: stored.inputApplied },
-			...stored.abortIntent === void 0 ? {} : { abortIntent: stored.abortIntent }
+		const toAdmission = (row, settledAtMillis) => ThreadAdmission.make({
+			...toSnapshot(row),
+			...settledAtMillis === void 0 ? {} : { settledAt: utc(settledAtMillis) }
 		});
-	});
-	const ledger = SubmissionLedger.of({
-		capabilities,
-		resolveFundingOwner: Effect.fnUntraced(function* (unvalidated) {
-			const request = yield* validate(FundingOwnerRequest, "funding owner", unvalidated);
-			const current = MutableRef.get(state.ref);
-			const selected = current.submissions.get(request.submissionId);
-			if (selected === void 0 || selected.row.threadId !== request.threadId) return yield* ledgerError("funding owner", "Selected admission belongs to another Thread or is missing");
-			if (selected.row.state === "joining" || selected.joinedHostSubmissionId !== void 0 && selected.inputApplied === void 0) return yield* ledgerError("funding owner", "Joining funding owner is not yet frozen by exact applied input evidence");
-			const owner = selected.joinedHostSubmissionId === void 0 ? selected : current.submissions.get(selected.joinedHostSubmissionId);
-			if (owner === void 0 || owner.row.threadId !== request.threadId || owner !== selected && owner.row.queueSequence >= selected.row.queueSequence) return yield* ledgerError("funding owner", "Exact joined funding owner is missing or inconsistent");
-			return FundingOwner.make({
-				selected: toSnapshot(selected.row),
-				owner: toSnapshot(owner.row)
-			});
-		}),
-		admit: (request) => journal.withMutation(admit(request)),
-		markReady: (request) => journal.withMutation(markReady(request)),
-		lookup,
-		resolveAdmission,
-		selectHead: (request) => journal.withMutation(selectHead(request)),
-		markInputApplied: (request) => journal.withMutation(markInputApplied(request)),
-		finalizeSettlement: (request) => journal.withMutation(finalizeSettlement(request)),
-		requestAbort: (request) => journal.withMutation(requestAbort(request)),
-		stopWorker: (request) => journal.withMutation(stopWorker(request)),
-		inspectWorker,
-		claimJoining: (request) => journal.withMutation(claimJoining(request)),
-		markJoined: (request) => journal.withMutation(markJoined(request)),
-		revertJoining: (request) => journal.withMutation(revertJoining(request)),
-		suspend: (request) => journal.withMutation(suspend(request)),
-		recordApprovalDecision: (request) => journal.withMutation(recordApprovalDecision(request)),
-		markUnknown: (request) => journal.withMutation(markUnknown(request)),
-		recordUnknownResolution: (request) => journal.withMutation(recordUnknownResolution(request)),
-		recordChildSettled: (request) => journal.withMutation(recordChildSettled(request)),
-		reserveChildBudget: (request) => journal.withMutation(reserveChildBudget(request)),
-		attachChildToReservation: (request) => journal.withMutation(attachChildToReservation(request)),
-		beginChildBudgetRelease: (request) => journal.withMutation(beginChildBudgetRelease(request)),
-		releaseChildBudget: (request) => journal.withMutation(releaseChildBudget(request)),
-		scanNonterminal,
-		loadRecoverySnapshot,
-		readAbortIntent
-	});
-	const toAdmission = (row, settledAtMillis) => ThreadAdmission.make({
-		...toSnapshot(row),
-		...settledAtMillis === void 0 ? {} : { settledAt: utc(settledAtMillis) }
-	});
-	const cleanCommand = (value) => {
-		const { canonicalRecordId: _, ...fact } = value;
-		return fact;
-	};
-	const commands = (stored) => {
-		return {
-			aborts: stored?.abortIntent === void 0 ? [] : [cleanCommand(stored.abortIntent)],
-			approvals: Array.from(stored?.approvalDecisions.values() ?? [], cleanCommand),
-			resolutions: Array.from(stored?.unknownResolutions.values() ?? [], ({ intent }) => cleanCommand(intent))
+		const cleanCommand = (value) => {
+			const { canonicalRecordId: _, ...fact } = value;
+			return fact;
 		};
-	};
-	const readCommands = Effect.fnUntraced(function* (stored) {
-		if ((stored?.approvalDecisions.size ?? 0) > MAX_RUN_EVIDENCE_RECORDS || (stored?.unknownResolutions.size ?? 0) > MAX_RUN_EVIDENCE_RECORDS) return yield* ThreadStoreError.make({
-			operation: "read commands",
-			message: "Accepted commands exceed Run record bounds"
-		});
-		let bytes = 0;
-		const add = (schema, value) => Schema.encodeEffect(Schema.toCodecJson(schema))(value).pipe(Effect.mapError(() => ThreadStoreError.make({
-			operation: "read commands",
-			message: "Invalid accepted command wire"
-		})), Effect.flatMap((wire) => {
-			bytes += utf8ByteLength(canonicalJson(wire));
-			return bytes > MAX_RUN_EVIDENCE_BYTES ? Effect.fail(ThreadStoreError.make({
-				operation: "read commands",
-				message: "Accepted commands exceed Run byte bounds"
-			})) : Effect.void;
-		}));
-		if (stored?.abortIntent !== void 0) yield* add(AbortIntent, stored.abortIntent);
-		for (const value of stored?.approvalDecisions.values() ?? []) yield* add(ApprovalDecisionIntent, value);
-		for (const { intent } of stored?.unknownResolutions.values() ?? []) yield* add(UnknownResolutionIntent, intent);
-		return commands(stored);
-	});
-	const lookupAdmission = (threadId, submissionId) => Effect.sync(() => {
-		const stored = MutableRef.get(state.ref).submissions.get(submissionId);
-		return stored?.row.threadId === threadId ? toAdmission(stored.row, stored.finalization?.finalizedAtMillis) : void 0;
-	});
-	yield* journal.registerLedgerTransfer({
-		admission: lookupAdmission,
-		commands: (id) => readCommands(MutableRef.get(state.ref).submissions.get(id)),
-		snapshot: (threadId) => Effect.sync(() => {
-			const current = MutableRef.get(state.ref);
-			const directory = current.byThread.get(threadId);
+		const commands = (stored) => {
 			return {
-				idle: (current.activeByThread.get(threadId)?.size ?? 0) === 0 && (directory?.reservations ?? 0) === 0,
-				admissions: directory?.ordered.length ?? 0,
-				aborts: directory?.commands.aborts.length ?? 0,
-				approvals: directory?.commands.approvals.length ?? 0,
-				resolutions: directory?.commands.resolutions.length ?? 0,
-				...current.stoppedWorkers.has(threadId) ? { workerSeal: current.stoppedWorkers.get(threadId) === void 0 ? {} : { terminal: current.stoppedWorkers.get(threadId) } } : {}
+				aborts: stored?.abortIntent === void 0 ? [] : [cleanCommand(stored.abortIntent)],
+				approvals: Array.from(stored?.approvalDecisions.values() ?? [], cleanCommand),
+				resolutions: Array.from(stored?.unknownResolutions.values() ?? [], ({ intent }) => cleanCommand(intent))
 			};
-		}),
-		facts: (threadId, section, after) => Effect.sync(() => {
-			const current = MutableRef.get(state.ref);
-			const facts = {
-				admissions: new Array(),
-				commands: commands(void 0),
-				deliveries: []
-			};
-			let next = after ?? "";
-			if (section === "admissions") {
-				const stored = threadRows(current, threadId, after === void 0 ? -1 : Number(after)).next().value;
-				if (stored !== void 0) {
-					facts.admissions.push(toAdmission(stored.row, stored.finalization?.finalizedAtMillis));
-					next = String(stored.row.queueSequence);
-				}
-			} else {
-				const entries = current.byThread.get(threadId)?.commands[section] ?? [];
-				const at = after === void 0 ? 0 : commandPosition(entries, after);
-				const choice = entries[at + Number(after !== void 0 && entries[at]?.key === after)];
-				if (choice !== void 0) {
-					next = choice.key;
-					const stored = current.submissions.get(choice.submissionId);
-					if (section === "aborts" && stored?.abortIntent !== void 0) facts.commands.aborts.push(cleanCommand(stored.abortIntent));
-					else if (section === "approvals" && choice.toolCallId !== void 0) {
-						const value = stored?.approvalDecisions.get(choice.toolCallId);
-						if (value !== void 0) facts.commands.approvals.push(cleanCommand(value));
-					} else if (section === "resolutions" && choice.resolutionKey !== void 0) {
-						const value = stored?.unknownResolutions.get(choice.resolutionKey);
-						if (value !== void 0) facts.commands.resolutions.push(cleanCommand(value.intent));
+		};
+		const readCommands = Effect.fnUntraced(function* (stored) {
+			if ((stored?.approvalDecisions.size ?? 0) > MAX_RUN_EVIDENCE_RECORDS || (stored?.unknownResolutions.size ?? 0) > MAX_RUN_EVIDENCE_RECORDS) return yield* ThreadStoreError.make({
+				operation: "read commands",
+				message: "Accepted commands exceed Run record bounds"
+			});
+			let bytes = 0;
+			const add = (schema, value) => Schema.encodeEffect(Schema.toCodecJson(schema))(value).pipe(Effect.mapError(() => ThreadStoreError.make({
+				operation: "read commands",
+				message: "Invalid accepted command wire"
+			})), Effect.flatMap((wire) => {
+				bytes += utf8ByteLength(canonicalJson(wire));
+				return bytes > MAX_RUN_EVIDENCE_BYTES ? Effect.fail(ThreadStoreError.make({
+					operation: "read commands",
+					message: "Accepted commands exceed Run byte bounds"
+				})) : Effect.void;
+			}));
+			if (stored?.abortIntent !== void 0) yield* add(AbortIntent, stored.abortIntent);
+			for (const value of stored?.approvalDecisions.values() ?? []) yield* add(ApprovalDecisionIntent, value);
+			for (const { intent } of stored?.unknownResolutions.values() ?? []) yield* add(UnknownResolutionIntent, intent);
+			return commands(stored);
+		});
+		const lookupAdmission = (threadId, submissionId) => Effect.sync(() => {
+			const stored = MutableRef.get(state.ref).submissions.get(submissionId);
+			return stored?.row.threadId === threadId ? toAdmission(stored.row, stored.finalization?.finalizedAtMillis) : void 0;
+		});
+		yield* journal.registerLedgerTransfer({
+			admission: lookupAdmission,
+			commands: (id) => readCommands(MutableRef.get(state.ref).submissions.get(id)),
+			snapshot: (threadId) => Effect.sync(() => {
+				const current = MutableRef.get(state.ref);
+				const directory = current.byThread.get(threadId);
+				return {
+					idle: (current.activeByThread.get(threadId)?.size ?? 0) === 0 && (directory?.reservations ?? 0) === 0,
+					admissions: directory?.ordered.length ?? 0,
+					aborts: directory?.commands.aborts.length ?? 0,
+					approvals: directory?.commands.approvals.length ?? 0,
+					resolutions: directory?.commands.resolutions.length ?? 0,
+					...current.stoppedWorkers.has(threadId) ? { workerSeal: current.stoppedWorkers.get(threadId) === void 0 ? {} : { terminal: current.stoppedWorkers.get(threadId) } } : {}
+				};
+			}),
+			facts: (threadId, section, after) => Effect.sync(() => {
+				const current = MutableRef.get(state.ref);
+				const facts = {
+					admissions: new Array(),
+					commands: commands(void 0),
+					deliveries: []
+				};
+				let next = after ?? "";
+				if (section === "admissions") {
+					const stored = threadRows(current, threadId, after === void 0 ? -1 : Number(after)).next().value;
+					if (stored !== void 0) {
+						facts.admissions.push(toAdmission(stored.row, stored.finalization?.finalizedAtMillis));
+						next = String(stored.row.queueSequence);
+					}
+				} else {
+					const entries = current.byThread.get(threadId)?.commands[section] ?? [];
+					const at = after === void 0 ? 0 : commandPosition(entries, after);
+					const choice = entries[at + Number(after !== void 0 && entries[at]?.key === after)];
+					if (choice !== void 0) {
+						next = choice.key;
+						const stored = current.submissions.get(choice.submissionId);
+						if (section === "aborts" && stored?.abortIntent !== void 0) facts.commands.aborts.push(cleanCommand(stored.abortIntent));
+						else if (section === "approvals" && choice.toolCallId !== void 0) {
+							const value = stored?.approvalDecisions.get(choice.toolCallId);
+							if (value !== void 0) facts.commands.approvals.push(cleanCommand(value));
+						} else if (section === "resolutions" && choice.resolutionKey !== void 0) {
+							const value = stored?.unknownResolutions.get(choice.resolutionKey);
+							if (value !== void 0) facts.commands.resolutions.push(cleanCommand(value.intent));
+						}
 					}
 				}
-			}
-			return {
-				facts,
-				after: next
-			};
-		}),
-		submissions: (threadId) => Stream.paginate(-1, (after) => Effect.sync(() => {
-			const stored = threadRows(MutableRef.get(state.ref), threadId, after).next().value;
-			return [stored === void 0 ? [] : [toSnapshot(stored.row)], stored === void 0 ? Option.none() : Option.some(stored.row.queueSequence)];
-		})),
-		startImport: Effect.fnUntraced(function* (threadId) {
-			const current = yield* Ref.get(state);
-			if (current.lanes.has(threadId) || current.byThread.has(threadId) || current.stoppedWorkers.has(threadId)) return yield* ThreadImportRejected.make({
-				threadId,
-				reason: "target-not-empty",
-				message: "Destination ledger contains Thread data"
-			});
-			const staged = {
-				submissions: /* @__PURE__ */ new Map(),
-				admissionIndex: /* @__PURE__ */ new Map(),
-				lanes: /* @__PURE__ */ new Map(),
-				childReservations: /* @__PURE__ */ new Map(),
-				freshAdmissionSequence: current.freshAdmissionSequence,
-				stoppedWorkers: /* @__PURE__ */ new Map(),
-				latestByThread: /* @__PURE__ */ new Map(),
-				activeByThread: /* @__PURE__ */ new Map(),
-				byThread: /* @__PURE__ */ new Map(),
-				receipts: /* @__PURE__ */ new Map(),
-				joinsByHost: /* @__PURE__ */ new Map(),
-				childrenByParent: /* @__PURE__ */ new Map()
-			};
-			const commandBytes = /* @__PURE__ */ new Map();
-			const settledTimes = /* @__PURE__ */ new Map();
-			const retainCommandBytes = Effect.fnUntraced(function* (schema, value, id) {
-				const wire = yield* Schema.encodeEffect(Schema.toCodecJson(schema))(value).pipe(Effect.mapError(() => invalidThreadArchive("Invalid accepted command wire", threadId)));
-				const bytes = (commandBytes.get(id) ?? 0) + utf8ByteLength(canonicalJson(wire));
-				if (bytes > MAX_RUN_EVIDENCE_BYTES) return yield* invalidThreadArchive("Accepted commands exceed Run byte bounds", threadId);
-				commandBytes.set(id, bytes);
-			});
-			return {
-				reader: {
-					admission: (id) => Effect.sync(() => {
-						const stored = staged.submissions.get(id);
-						return stored === void 0 ? void 0 : toAdmission(stored.row, settledTimes.get(id));
-					}),
-					runOwner: (runId) => Effect.sync(() => {
-						if (!runId.startsWith("run:")) return void 0;
-						const id = Schema.decodeSync(SubmissionId)(runId.slice(4));
-						const stored = staged.submissions.get(id);
-						return stored === void 0 ? void 0 : toAdmission(stored.row, settledTimes.get(id));
+				return {
+					facts,
+					after: next
+				};
+			}),
+			submissions: (threadId) => Stream.paginate(-1, (after) => Effect.sync(() => {
+				const stored = threadRows(MutableRef.get(state.ref), threadId, after).next().value;
+				return [stored === void 0 ? [] : [toSnapshot(stored.row)], stored === void 0 ? Option.none() : Option.some(stored.row.queueSequence)];
+			})),
+			startImport: Effect.fnUntraced(function* (threadId) {
+				const current = yield* Ref.get(state);
+				if (current.lanes.has(threadId) || current.byThread.has(threadId) || current.stoppedWorkers.has(threadId)) return yield* ThreadImportRejected.make({
+					threadId,
+					reason: "target-not-empty",
+					message: "Destination ledger contains Thread data"
+				});
+				const staged = {
+					submissions: /* @__PURE__ */ new Map(),
+					admissionIndex: /* @__PURE__ */ new Map(),
+					lanes: /* @__PURE__ */ new Map(),
+					childReservations: /* @__PURE__ */ new Map(),
+					freshAdmissionSequence: current.freshAdmissionSequence,
+					stoppedWorkers: /* @__PURE__ */ new Map(),
+					latestByThread: /* @__PURE__ */ new Map(),
+					activeByThread: /* @__PURE__ */ new Map(),
+					byThread: /* @__PURE__ */ new Map(),
+					receipts: /* @__PURE__ */ new Map(),
+					joinsByHost: /* @__PURE__ */ new Map(),
+					childrenByParent: /* @__PURE__ */ new Map()
+				};
+				const commandBytes = /* @__PURE__ */ new Map();
+				const settledTimes = /* @__PURE__ */ new Map();
+				const retainCommandBytes = Effect.fnUntraced(function* (schema, value, id) {
+					const wire = yield* Schema.encodeEffect(Schema.toCodecJson(schema))(value).pipe(Effect.mapError(() => invalidThreadArchive("Invalid accepted command wire", threadId)));
+					const bytes = (commandBytes.get(id) ?? 0) + utf8ByteLength(canonicalJson(wire));
+					if (bytes > MAX_RUN_EVIDENCE_BYTES) return yield* invalidThreadArchive("Accepted commands exceed Run byte bounds", threadId);
+					commandBytes.set(id, bytes);
+				});
+				return {
+					reader: {
+						admission: (id) => Effect.sync(() => {
+							const stored = staged.submissions.get(id);
+							return stored === void 0 ? void 0 : toAdmission(stored.row, settledTimes.get(id));
+						}),
+						runOwner: (runId) => Effect.sync(() => {
+							if (!runId.startsWith("run:")) return void 0;
+							const id = Schema.decodeSync(SubmissionId)(runId.slice(4));
+							const stored = staged.submissions.get(id);
+							return stored === void 0 ? void 0 : toAdmission(stored.row, settledTimes.get(id));
+						}),
+						commands: (id) => readCommands(staged.submissions.get(id))
+					},
+					stage: Effect.fnUntraced(function* (page) {
+						for (const a of page.archive.admissions) {
+							const key = admissionKey(threadId, a.principal, a.idempotencyKey);
+							if (current.submissions.has(a.submissionId) || staged.submissions.has(a.submissionId) || current.receipts.has(a.receiptId) || staged.receipts.has(a.receiptId) || current.admissionIndex.has(key) || staged.admissionIndex.has(key)) return yield* ThreadImportRejected.make({
+								threadId,
+								reason: "destination-conflict",
+								message: "Admission, receipt, or immutable admission key already exists"
+							});
+							if (threadRows(staged, threadId, a.queueSequence - 1).next().value?.row.queueSequence === a.queueSequence) return yield* invalidThreadArchive("Duplicate admission queue position", threadId);
+							if (a.settledAt !== void 0) settledTimes.set(a.submissionId, DateTime.toEpochMillis(a.settledAt));
+							withSubmission(staged, fromRebuilt(RebuiltSubmission.make({
+								admission: a,
+								state: "admitted",
+								unknownToolCallIds: [],
+								approvals: [],
+								resolutions: []
+							})));
+						}
+						for (const fact of page.archive.commands.aborts) {
+							const stored = staged.submissions.get(fact.submissionId);
+							if (stored === void 0 || stored.abortIntent !== void 0) return yield* invalidThreadArchive("Missing admission or duplicate abort", threadId);
+							const intent = AbortIntent.make(fact);
+							yield* retainCommandBytes(AbortIntent, intent, fact.submissionId);
+							withSubmission(staged, {
+								...stored,
+								abortIntent: intent
+							});
+						}
+						for (const fact of page.archive.commands.approvals) {
+							const stored = staged.submissions.get(fact.submissionId);
+							if (stored === void 0 || stored.approvalDecisions.has(fact.toolCallId)) return yield* invalidThreadArchive("Missing admission or duplicate approval", threadId);
+							if (stored.approvalDecisions.size >= MAX_RUN_EVIDENCE_RECORDS) return yield* invalidThreadArchive("Accepted approvals exceed Run record bounds", threadId);
+							const intent = ApprovalDecisionIntent.make(fact);
+							yield* retainCommandBytes(ApprovalDecisionIntent, intent, fact.submissionId);
+							const approvals = new Map(stored.approvalDecisions).set(fact.toolCallId, intent);
+							withSubmission(staged, {
+								...stored,
+								approvalDecisions: approvals
+							});
+						}
+						for (const fact of page.archive.commands.resolutions) {
+							const stored = staged.submissions.get(fact.submissionId);
+							const key = JSON.stringify([fact.toolCallId, unknownResolutionKind(fact.resolution)]);
+							if (stored === void 0 || stored.unknownResolutions.has(key)) return yield* invalidThreadArchive("Missing admission or duplicate resolution", threadId);
+							if (stored.unknownResolutions.size >= MAX_RUN_EVIDENCE_RECORDS) return yield* invalidThreadArchive("Accepted resolutions exceed Run record bounds", threadId);
+							const intent = UnknownResolutionIntent.make(fact);
+							yield* retainCommandBytes(UnknownResolutionIntent, intent, fact.submissionId);
+							const resolutions = new Map(stored.unknownResolutions).set(key, { intent });
+							withSubmission(staged, {
+								...stored,
+								unknownResolutions: resolutions
+							});
+						}
 					}),
-					commands: (id) => readCommands(staged.submissions.get(id))
-				},
-				stage: Effect.fnUntraced(function* (page) {
-					for (const a of page.archive.admissions) {
-						const key = admissionKey(threadId, a.principal, a.idempotencyKey);
-						if (current.submissions.has(a.submissionId) || staged.submissions.has(a.submissionId) || current.receipts.has(a.receiptId) || staged.receipts.has(a.receiptId) || current.admissionIndex.has(key) || staged.admissionIndex.has(key)) return yield* ThreadImportRejected.make({
+					prepareCommit: Effect.fnUntraced(function* (workerSeal) {
+						let lastQueue = 0;
+						let terminalEvidence = workerSeal?.terminal === void 0;
+						for (const stored of threadRows(staged, threadId)) {
+							const a = toAdmission(stored.row, settledTimes.get(stored.row.submissionId));
+							const rebuilt = yield* rebuildClosedSubmission(a);
+							if (rebuilt.settlement !== void 0 && workerTerminalFromRecord(toSnapshot(stored.row), rebuilt.settlement) === workerSeal?.terminal) terminalEvidence = true;
+							withSubmission(staged, fromRebuilt(rebuilt));
+							lastQueue = Math.max(lastQueue, a.queueSequence);
+						}
+						if (!terminalEvidence) return yield* invalidThreadArchive("Worker seal terminal has no exact completed input evidence", threadId);
+						if (!Number.isSafeInteger(lastQueue + 1)) return yield* ThreadImportRejected.make({
 							threadId,
-							reason: "destination-conflict",
-							message: "Admission, receipt, or immutable admission key already exists"
-						});
-						if (threadRows(staged, threadId, a.queueSequence - 1).next().value?.row.queueSequence === a.queueSequence) return yield* invalidThreadArchive("Duplicate admission queue position", threadId);
-						if (a.settledAt !== void 0) settledTimes.set(a.submissionId, DateTime.toEpochMillis(a.settledAt));
-						withSubmission(staged, fromRebuilt(RebuiltSubmission.make({
-							admission: a,
-							state: "admitted",
-							unknownToolCallIds: [],
-							approvals: [],
-							resolutions: []
-						})));
-					}
-					for (const fact of page.archive.commands.aborts) {
-						const stored = staged.submissions.get(fact.submissionId);
-						if (stored === void 0 || stored.abortIntent !== void 0) return yield* invalidThreadArchive("Missing admission or duplicate abort", threadId);
-						const intent = AbortIntent.make(fact);
-						yield* retainCommandBytes(AbortIntent, intent, fact.submissionId);
-						withSubmission(staged, {
-							...stored,
-							abortIntent: intent
-						});
-					}
-					for (const fact of page.archive.commands.approvals) {
-						const stored = staged.submissions.get(fact.submissionId);
-						if (stored === void 0 || stored.approvalDecisions.has(fact.toolCallId)) return yield* invalidThreadArchive("Missing admission or duplicate approval", threadId);
-						if (stored.approvalDecisions.size >= MAX_RUN_EVIDENCE_RECORDS) return yield* invalidThreadArchive("Accepted approvals exceed Run record bounds", threadId);
-						const intent = ApprovalDecisionIntent.make(fact);
-						yield* retainCommandBytes(ApprovalDecisionIntent, intent, fact.submissionId);
-						const approvals = new Map(stored.approvalDecisions).set(fact.toolCallId, intent);
-						withSubmission(staged, {
-							...stored,
-							approvalDecisions: approvals
-						});
-					}
-					for (const fact of page.archive.commands.resolutions) {
-						const stored = staged.submissions.get(fact.submissionId);
-						const key = JSON.stringify([fact.toolCallId, unknownResolutionKind(fact.resolution)]);
-						if (stored === void 0 || stored.unknownResolutions.has(key)) return yield* invalidThreadArchive("Missing admission or duplicate resolution", threadId);
-						if (stored.unknownResolutions.size >= MAX_RUN_EVIDENCE_RECORDS) return yield* invalidThreadArchive("Accepted resolutions exceed Run record bounds", threadId);
-						const intent = UnknownResolutionIntent.make(fact);
-						yield* retainCommandBytes(UnknownResolutionIntent, intent, fact.submissionId);
-						const resolutions = new Map(stored.unknownResolutions).set(key, { intent });
-						withSubmission(staged, {
-							...stored,
-							unknownResolutions: resolutions
+							reason: "unsupported-capacity",
+							message: "Admission queue sequence is exhausted"
 						});
-					}
-				}),
-				prepareCommit: Effect.fnUntraced(function* (workerSeal) {
-					let lastQueue = 0;
-					let terminalEvidence = workerSeal?.terminal === void 0;
-					for (const stored of threadRows(staged, threadId)) {
-						const a = toAdmission(stored.row, settledTimes.get(stored.row.submissionId));
-						const rebuilt = yield* rebuildClosedSubmission(a);
-						if (rebuilt.settlement !== void 0 && workerTerminalFromRecord(toSnapshot(stored.row), rebuilt.settlement) === workerSeal?.terminal) terminalEvidence = true;
-						withSubmission(staged, fromRebuilt(rebuilt));
-						lastQueue = Math.max(lastQueue, a.queueSequence);
-					}
-					if (!terminalEvidence) return yield* invalidThreadArchive("Worker seal terminal has no exact completed input evidence", threadId);
-					if (!Number.isSafeInteger(lastQueue + 1)) return yield* ThreadImportRejected.make({
-						threadId,
-						reason: "unsupported-capacity",
-						message: "Admission queue sequence is exhausted"
-					});
-					return () => {
-						for (const stored of staged.submissions.values()) withSubmission(current, stored);
-						current.lanes.set(threadId, { nextQueueSequence: lastQueue + 1 });
-						if (workerSeal !== void 0) current.stoppedWorkers.set(threadId, workerSeal.terminal);
-					};
-				})
-			};
-		})
-	});
-	return Context.make(SubmissionLedger, ledger).pipe(Context.add(SettlementPublisher, { publish }));
-});
+						return () => {
+							for (const stored of staged.submissions.values()) withSubmission(current, stored);
+							current.lanes.set(threadId, { nextQueueSequence: lastQueue + 1 });
+							if (workerSeal !== void 0) current.stoppedWorkers.set(threadId, workerSeal.terminal);
+						};
+					})
+				};
+			})
+		});
+		return Context.make(SubmissionLedger, ledger).pipe(Context.add(SettlementPublisher, { publish }));
+	}
+);
 /**
 * In-memory reference SubmissionLedger Layer (durability `non-durable`). All state lives in one
 * `Ref` owned by the Layer's Scope. Fresh identities use the supplied `Crypto` service;