effect-agent 0.1.0-beta.113 → 0.1.0-beta.115

package/dist/durable/SubmissionLedgerConformance.mjs

@@ -2,11 +2,12 @@ import { AgentId, DelegationId, SubmissionId, ThreadId, ToolCallId } from "../co
 import { AgentPolicy } from "../core/AgentPolicy.mjs";
 import { IdempotencyKey, JoinedToHost, Principal } from "../core/Receipt.mjs";
 import { SubagentDelegationCaps, SubagentGrant, SubagentReservationAmounts } from "../core/SubagentContract.mjs";
-import { p as WorkerUpdate, r as WorkerCompletion } from "../Worker-T_3RbaKc.mjs";
-import { d as MessageAdmission, l as InputMessage } from "../MessagingHost-D89X7ma8.mjs";
+import { b as WorkerUpdate, o as WorkerCompletion } from "../Worker-CfwzMZEK.mjs";
+import { d as MessageAdmission, l as InputMessage } from "../MessagingHost-DfsbMPvq.mjs";
 import { CanonicalSequence, DefinitionDigests, DeploymentId, Digest, PersistedJson, ProducerId, RecordEnvelope, SubmissionSettled, SubmissionSettledRecord, WorkerAdmission } from "./Records.mjs";
-import { AbortCommand, AbortIntentRequest, AdmissionConflict, AdmissionPolicyError, AdmissionRequest, ApprovalConflict, ApprovalDecisionCommand, ApprovalPendingSuspension, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, ChildBudgetReservationRequest, ChildReservationConflict, ChildReservationId, ChildSettledNotification, ClaimJoiningRequest, ClaimRequest, LedgerError, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, OwnershipLost, OwnershipToken, ParentLinkage, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ResolutionCompletedWithResult, ResolutionNeverHappened, ResolutionSafeToRetry, RevertJoiningRequest, SettlementConflict, SettlementFinalization, SettlementReservation, SubmissionLedger, SubmissionLookupById, SubmissionLookupByKey, SuspendRequest, UnknownResolutionCommand, UnknownResolutionConflict, WaitingChild, WaitingForChildSuspension, submissionInputRecordId, submissionSettlementId, submissionSettlementRecordId } from "./SubmissionLedger.mjs";
+import { AbortCommand, AbortIntentRequest, AdmissionConflict, AdmissionPolicyError, AdmissionRequest, ApprovalConflict, ApprovalDecisionCommand, ApprovalPendingSuspension, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, ChildBudgetReservationRequest, ChildReservationConflict, ChildReservationId, ChildSettledNotification, ClaimJoiningRequest, ClaimRequest, LedgerError, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, OwnershipLost, OwnershipToken, ParentLinkage, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ResolutionCompletedWithResult, ResolutionNeverHappened, ResolutionSafeToRetry, RevertJoiningRequest, Settlement, SettlementConflict, SettlementFinalization, SettlementReservation, SubmissionLedger, SubmissionLookupById, SubmissionLookupByKey, SuspendRequest, UnknownResolutionCommand, UnknownResolutionConflict, WaitingChild, WaitingForChildSuspension, submissionInputRecordId, submissionSettlementId, submissionSettlementRecordId } from "./SubmissionLedger.mjs";
 import { digestJson } from "./Digest.mjs";
+import { S as runIdForSubmission } from "../RunJournal-BXrq0VIK.mjs";
 import { Clock, DateTime, Duration, Effect, Option, Result, Schema, Stream } from "effect";
 import { TestClock } from "effect/testing";
 //#region src/durable/SubmissionLedgerConformance.ts
@@ -220,54 +221,55 @@ const admissionIdempotency = conformanceCase("replays identical admissions and r
 	const second = yield* ledger.admit(yield* admissionRequest(threadId, "admission-key-2", { city: "Faro" }));
 	yield* ensure(second.submissionId !== first.submissionId && second.queueSequence !== first.queueSequence, "A different key on the same lane must mint fresh identities and a fresh queue sequence");
 }));
+const workerMetadata = (base) => WorkerAdmission.make({
+	messageId: base.idempotencyKey,
+	sourceSubmissionId: Schema.decodeSync(SubmissionId)("source-input"),
+	deliveryPrincipal: base.principal,
+	parameters: { prompt: "original projection parameters" },
+	createdAtMillis: 1,
+	origin: {
+		worker: {
+			schemaVersion: 1,
+			threadId: base.threadId,
+			targetAgentId: CONFORMANCE_AGENT,
+			delegationId: Schema.decodeSync(DelegationId)("worker-research")
+		},
+		source: {
+			_tag: "programmatic",
+			threadId: decodeThreadId("worker-source"),
+			agentId: CONFORMANCE_AGENT
+		},
+		targetDigests: CONFORMANCE_DIGESTS,
+		policy: AgentPolicy.resolve(),
+		budget: {
+			caps: SubagentDelegationCaps.make({
+				maxConcurrentChildren: 1,
+				maxTotalChildInvocations: 2
+			}),
+			allocation: SubagentReservationAmounts.make({
+				turns: 12,
+				toolCalls: 24,
+				durationMillis: 3e5,
+				inputTokens: 0,
+				outputTokens: 0,
+				costMicrousd: 0,
+				resultBytes: 1e3
+			})
+		},
+		grant: SubagentGrant.make({
+			maxDepth: 1,
+			allowedToolNames: []
+		}),
+		depth: 1,
+		firstMessageId: base.idempotencyKey,
+		createdAtMillis: 1,
+		expiresAtMillis: 1e6
+	}
+});
 const workerAdmissionIdentity = conformanceCase("retains immutable worker admission metadata and rejects same-key changes or omission", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
 	const ledger = yield* SubmissionLedger;
 	const base = yield* admissionRequest(decodeThreadId("ledger-conformance-worker"), "worker-message", { text: "first" });
-	const metadata = WorkerAdmission.make({
-		messageId: base.idempotencyKey,
-		sourceSubmissionId: Schema.decodeSync(SubmissionId)("source-input"),
-		deliveryPrincipal: base.principal,
-		parameters: { prompt: "original projection parameters" },
-		createdAtMillis: 1,
-		origin: {
-			worker: {
-				schemaVersion: 1,
-				threadId: base.threadId,
-				targetAgentId: CONFORMANCE_AGENT,
-				delegationId: Schema.decodeSync(DelegationId)("worker-research")
-			},
-			source: {
-				_tag: "programmatic",
-				threadId: decodeThreadId("worker-source"),
-				agentId: CONFORMANCE_AGENT
-			},
-			targetDigests: CONFORMANCE_DIGESTS,
-			policy: AgentPolicy.resolve(),
-			budget: {
-				caps: SubagentDelegationCaps.make({
-					maxConcurrentChildren: 1,
-					maxTotalChildInvocations: 2
-				}),
-				allocation: SubagentReservationAmounts.make({
-					turns: 12,
-					toolCalls: 24,
-					durationMillis: 3e5,
-					inputTokens: 0,
-					outputTokens: 0,
-					costMicrousd: 0,
-					resultBytes: 1e3
-				})
-			},
-			grant: SubagentGrant.make({
-				maxDepth: 1,
-				allowedToolNames: []
-			}),
-			depth: 1,
-			firstMessageId: base.idempotencyKey,
-			createdAtMillis: 1,
-			expiresAtMillis: 1e6
-		}
-	});
+	const metadata = workerMetadata(base);
 	const admitted = yield* ledger.admit(AdmissionRequest.make({
 		...base,
 		workerAdmission: metadata
@@ -1297,6 +1299,664 @@ const unknownAbortClaim = conformanceCase("a durable abort makes an unknown head
 		yield* ensure((yield* expectSome("follower claim", yield* claimLane(threadId, PRODUCER_B))).submissionId === follower.submissionId, "Settlement must release the follower");
 	}
 }));
+const unknownResolutionLifecycle = conformanceCase("unknown resolutions reopen the lane only when no open call remains", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("ledger-conformance-unknown");
+	const ledger = yield* SubmissionLedger;
+	const admitted = yield* admitReady(threadId, "unknown-key-1", { work: "unknown" });
+	const claim = yield* expectSome("the claim before the unknown marking", yield* claimLane(threadId, PRODUCER_A));
+	const call1 = decodeToolCallId("call-unknown-1");
+	const call2 = decodeToolCallId("call-unknown-2");
+	const call3 = decodeToolCallId("call-unknown-3");
+	const marking = MarkUnknownRequest.make({
+		submissionId: admitted.submissionId,
+		toolCallIds: [call1, call2],
+		reason: "the worker died during two supplier calls"
+	});
+	yield* ledger.markUnknown(marking);
+	yield* ledger.markUnknown(marking);
+	yield* ensure((yield* expectSome("lookup after marking unknown", yield* lookupById(admitted.submissionId))).state === "unknown", "Marking unknown must be idempotent and block the lane");
+	yield* advancePastLease(claim.leaseExpiresAt);
+	yield* ensure(Option.isNone(yield* claimLane(threadId, PRODUCER_B)), "An unknown lane must consume no worker permit");
+	const first = yield* ledger.recordUnknownResolution(UnknownResolutionCommand.make({
+		submissionId: admitted.submissionId,
+		toolCallId: call1,
+		author: "conformance-operator",
+		reason: "supplier store shows no booking",
+		resolution: ResolutionNeverHappened.make()
+	}));
+	yield* ensure((yield* expectSome("lookup after a partial resolution", yield* lookupById(admitted.submissionId))).state === "unknown" && Option.isNone(yield* claimLane(threadId, PRODUCER_B)), "A partial resolution must keep the lane blocked while calls remain open");
+	yield* TestClock.adjust("1 second");
+	const divergent = yield* expectFailure("re-resolving the same call divergently", ledger.recordUnknownResolution(UnknownResolutionCommand.make({
+		submissionId: admitted.submissionId,
+		toolCallId: call1,
+		author: "conformance-operator",
+		reason: "changed my mind",
+		resolution: ResolutionSafeToRetry.make()
+	})));
+	yield* ensure(isUnknownResolutionConflict(divergent) && divergent.toolCallId === call1, "A divergent re-resolution must conflict");
+	const replayed = yield* ledger.recordUnknownResolution(UnknownResolutionCommand.make({
+		submissionId: admitted.submissionId,
+		toolCallId: call1,
+		author: "conformance-operator-second",
+		reason: "a different reason text",
+		resolution: ResolutionNeverHappened.make()
+	}));
+	yield* ensure(sameInstant(replayed.resolvedAt, first.resolvedAt) && replayed.reason === first.reason, "Repeating the same resolution must replay the recorded intent unchanged");
+	yield* ledger.markUnknown(MarkUnknownRequest.make({
+		submissionId: admitted.submissionId,
+		toolCallIds: [call3],
+		reason: "a second wave of uncertainty"
+	}));
+	yield* ledger.recordUnknownResolution(UnknownResolutionCommand.make({
+		submissionId: admitted.submissionId,
+		toolCallId: call2,
+		author: "conformance-operator",
+		reason: "supplier confirmed the booking",
+		resolution: ResolutionCompletedWithResult.make({
+			result: { bookingRef: "booking-1" },
+			isFailure: false
+		})
+	}));
+	yield* ensure((yield* expectSome("lookup while the extended set stays open", yield* lookupById(admitted.submissionId))).state === "unknown" && Option.isNone(yield* claimLane(threadId, PRODUCER_B)), "The lane must stay blocked while any marked call lacks a resolution");
+	yield* ledger.recordUnknownResolution(UnknownResolutionCommand.make({
+		submissionId: admitted.submissionId,
+		toolCallId: call3,
+		author: "conformance-operator",
+		reason: "idempotency key covers a repeat",
+		resolution: ResolutionSafeToRetry.make()
+	}));
+	yield* ensure((yield* expectSome("lookup after the covering resolution", yield* lookupById(admitted.submissionId))).state === "input-applied", "Covering every marked call must reopen the lane as input-applied");
+	yield* ensure((yield* recoverySnapshot(admitted.submissionId)).unknownResolutions.length === 3, "The recovery snapshot must expose every recorded resolution intent");
+	const reclaim = yield* expectSome("the claim after the lane reopened", yield* claimLane(threadId, PRODUCER_B));
+	yield* ensure(reclaim.submissionId === admitted.submissionId && reclaim.producerEpoch > claim.producerEpoch, "The reopened lane must grant a fresh fenced Attempt");
+	yield* settleClaimed(admitted, reclaim.ownershipToken);
+	const late = yield* expectFailure("resolving an unknown call for a settled Submission", ledger.recordUnknownResolution(UnknownResolutionCommand.make({
+		submissionId: admitted.submissionId,
+		toolCallId: decodeToolCallId("call-unknown-late"),
+		author: "conformance-operator",
+		reason: "too late",
+		resolution: ResolutionNeverHappened.make()
+	})));
+	yield* ensure(isSettlementConflict(late), "A resolution must never land on a settled Submission");
+}));
+const suspendResumesImmediatelyWhenDecided = conformanceCase("suspend with an already-present decision resumes immediately", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("ledger-conformance-suspend");
+	const ledger = yield* SubmissionLedger;
+	const admitted = yield* admitReady(threadId, "suspend-key-1", { work: "suspend" });
+	const claim = yield* expectSome("the claim before suspension", yield* claimLane(threadId, PRODUCER_A));
+	const callA = decodeToolCallId("call-suspend-a");
+	const callB = decodeToolCallId("call-suspend-b");
+	const foreign = yield* expectFailure("suspending without owning the lane", ledger.suspend(SuspendRequest.make({
+		submissionId: admitted.submissionId,
+		ownershipToken: BOGUS_TOKEN,
+		reason: ApprovalPendingSuspension.make({ toolCallIds: [callA] })
+	})));
+	yield* ensure(isOwnershipLost(foreign), "suspend must be fenced by the owning token");
+	yield* ledger.recordApprovalDecision(ApprovalDecisionCommand.make({
+		submissionId: admitted.submissionId,
+		toolCallId: callA,
+		decision: "approved",
+		resolver: "conformance-approver",
+		reason: "decided before the suspend committed"
+	}));
+	yield* ensure((yield* ledger.suspend(SuspendRequest.make({
+		submissionId: admitted.submissionId,
+		ownershipToken: claim.ownershipToken,
+		reason: ApprovalPendingSuspension.make({ toolCallIds: [callA] })
+	}))) === "resume-immediately", "A fully-decided suspension reason must resume immediately");
+	yield* ensure((yield* expectSome("lookup after the immediate resume", yield* lookupById(admitted.submissionId))).state === "running", "An immediate resume must not transition the Submission to suspended");
+	yield* ledger.renewOwnership(RenewOwnershipRequest.make({
+		submissionId: admitted.submissionId,
+		ownershipToken: claim.ownershipToken
+	}));
+	yield* ensure((yield* ledger.suspend(SuspendRequest.make({
+		submissionId: admitted.submissionId,
+		ownershipToken: claim.ownershipToken,
+		reason: ApprovalPendingSuspension.make({ toolCallIds: [callA, callB] })
+	}))) === "suspended", "An undecided call in the reason must suspend durably");
+	yield* ensure((yield* expectSome("lookup after the suspension", yield* lookupById(admitted.submissionId))).state === "suspended", "The suspension must be durable");
+	const suspendedSnapshot = yield* recoverySnapshot(admitted.submissionId);
+	yield* ensure(suspendedSnapshot.suspension !== void 0 && suspendedSnapshot.suspension.reason._tag === "ApprovalPending" && suspendedSnapshot.suspension.reason.toolCallIds.length === 2 && suspendedSnapshot.approvalDecisions.length === 1, "The recovery snapshot must expose the suspension reason and prior decisions");
+	const ended = yield* expectFailure("renewing after the suspension ended the ownership period", ledger.renewOwnership(RenewOwnershipRequest.make({
+		submissionId: admitted.submissionId,
+		ownershipToken: claim.ownershipToken
+	})));
+	yield* ensure(isOwnershipLost(ended), "Suspension must end the ownership period without settling");
+	yield* ledger.recordApprovalDecision(ApprovalDecisionCommand.make({
+		submissionId: admitted.submissionId,
+		toolCallId: callB,
+		decision: "denied",
+		resolver: "conformance-approver",
+		reason: "the covering decision"
+	}));
+	yield* ensure((yield* expectSome("lookup after the covering decision", yield* lookupById(admitted.submissionId))).state === "input-applied", "The covering decision must wake the suspended lane");
+	yield* ensure((yield* recoverySnapshot(admitted.submissionId)).suspension === void 0, "Waking must clear the durable suspension");
+	const reclaim = yield* expectSome("the claim after waking", yield* claimLane(threadId, PRODUCER_B));
+	yield* settleClaimed(admitted, reclaim.ownershipToken);
+	const terminal = yield* expectFailure("suspending a settled Submission", ledger.suspend(SuspendRequest.make({
+		submissionId: admitted.submissionId,
+		ownershipToken: reclaim.ownershipToken,
+		reason: ApprovalPendingSuspension.make({ toolCallIds: [callA] })
+	})));
+	yield* ensure(isSettlementConflict(terminal) && terminal.existingOutcome === "completed", "Suspension must never land on a settled Submission");
+}));
+const joinedSettlementLinkageAuthority = conformanceCase("a joined Submission's settlement reservation is authorized by host linkage", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("ledger-conformance-joined-settlement");
+	const ledger = yield* SubmissionLedger;
+	const host = yield* admitReady(threadId, "joined-settle-host", { work: "host" });
+	const queued = yield* admitReady(threadId, "joined-settle-2", { queued: 2 });
+	const hostClaim = yield* expectSome("the host claim", yield* claimLane(threadId, PRODUCER_A));
+	const claims = yield* ledger.claimJoining(ClaimJoiningRequest.make({
+		threadId,
+		hostSubmissionId: host.submissionId,
+		ownershipToken: hostClaim.ownershipToken,
+		maxCount: 1
+	}));
+	yield* ensure(claims.length === 1 && claims[0]?.submissionId === queued.submissionId, "The queued Submission must join the host's contiguous prefix");
+	const joiningReservation = yield* settlementReservation({
+		submissionId: queued.submissionId,
+		ownershipToken: BOGUS_TOKEN,
+		receiptId: queued.receiptId,
+		outcome: "completed"
+	});
+	const fenced = yield* expectFailure("reserving a joining Submission's settlement without lane ownership", ledger.reserveSettlement(joiningReservation));
+	yield* ensure(isOwnershipLost(fenced), "A joining Submission's settlement reservation must stay ownership-fenced");
+	yield* ledger.markJoined(MarkJoinedRequest.make({
+		submissionId: queued.submissionId,
+		ownershipToken: hostClaim.ownershipToken,
+		recordId: submissionInputRecordId(queued.submissionId),
+		sequence: decodeSequence(7)
+	}));
+	const joinedReservation = yield* settlementReservation({
+		submissionId: queued.submissionId,
+		ownershipToken: BOGUS_TOKEN,
+		receiptId: queued.receiptId,
+		outcome: "completed"
+	});
+	yield* ledger.reserveSettlement(joinedReservation);
+	yield* ensure((yield* ledger.finalizeSettlement(SettlementFinalization.make({
+		submissionId: queued.submissionId,
+		settlementId: submissionSettlementId(queued.submissionId)
+	}))).outcome === "completed", "The joined settlement must finalize with the reserved outcome");
+	const settled = yield* expectSome("lookup after the joined settlement", yield* lookupById(queued.submissionId));
+	yield* ensure(settled.state === "settled" && settled.settledOutcome === "completed", "The joined Submission must settle terminally");
+}));
+const childReservationIdempotency = conformanceCase("replays an identical child reservation and rejects a divergent allocation digest", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("ledger-conformance-child-reserve");
+	const ledger = yield* SubmissionLedger;
+	const parent = yield* admitReady(threadId, "child-reserve-parent", { work: "parent" });
+	const claim = yield* expectSome("the parent claim", yield* claimLane(threadId, PRODUCER_A));
+	const allocation = {
+		turns: 4,
+		toolCalls: 8
+	};
+	const allocationDigest = yield* digestJson(allocation);
+	const requestFields = {
+		reservationId: decodeChildReservationId("child-reservation:run-reserve:call-1"),
+		parentSubmissionId: parent.submissionId,
+		parentToolCallId: decodeToolCallId("call-child-reserve"),
+		ownershipToken: claim.ownershipToken,
+		allocation,
+		allocationDigest
+	};
+	const request = ChildBudgetReservationRequest.make(requestFields);
+	const first = yield* ledger.reserveChildBudget(request);
+	yield* ensure(!first.replayed && first.reservation.status === "reserved" && first.reservation.allocationDigest === allocationDigest && first.reservation.childSubmissionId === void 0 && persistedJsonEquivalent(first.reservation.allocation, allocation), "The first reservation must create a reserved row carrying the exact allocation");
+	yield* TestClock.adjust("1 second");
+	const replayed = yield* ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
+		...requestFields,
+		allocation: {
+			toolCalls: 8,
+			turns: 4
+		}
+	}));
+	yield* ensure(replayed.replayed && replayed.reservation.status === "reserved" && persistedJsonEquivalent(replayed.reservation.allocation, allocation) && sameInstant(replayed.reservation.reservedAt, first.reservation.reservedAt), "An identical reservation must replay the stored row unchanged");
+	const divergentAllocation = {
+		turns: 64,
+		toolCalls: 8
+	};
+	const divergent = yield* expectFailure("a divergent allocation for the same reservation id", ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
+		...requestFields,
+		allocation: divergentAllocation,
+		allocationDigest: yield* digestJson(divergentAllocation)
+	})));
+	yield* ensure(isChildReservationConflict(divergent) && divergent.status === "reserved", "A divergent allocation must conflict with the recorded reservation");
+	const secondId = yield* expectFailure("a second reservation id for the same parent Tool Call", ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
+		...requestFields,
+		reservationId: decodeChildReservationId("child-reservation:run-reserve:call-1-other")
+	})));
+	yield* ensure(isChildReservationConflict(secondId), "One parent Tool Call must never own two reservations");
+	const snapshot = yield* recoverySnapshot(parent.submissionId);
+	yield* ensure(snapshot.childReservations.length === 1 && snapshot.childReservations[0].reservationId === request.reservationId && snapshot.childReservations[0].status === "reserved" && snapshot.childAttachments.length === 0, "The parent recovery snapshot must expose the reservation before any attachment");
+}));
+const childReservationFencing = conformanceCase("a stale parent token cannot transition a child reservation", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("ledger-conformance-child-fence");
+	const childLane = decodeThreadId("ledger-conformance-child-fence-child");
+	const ledger = yield* SubmissionLedger;
+	const parent = yield* admitReady(threadId, "child-fence-parent", { work: "parent" });
+	const child = yield* admitReady(childLane, "child-fence-child", { work: "child" });
+	const firstClaim = yield* expectSome("the first parent claim", yield* claimLane(threadId, PRODUCER_A));
+	const allocation = { turns: 2 };
+	const allocationDigest = yield* digestJson(allocation);
+	const requestFields = {
+		reservationId: decodeChildReservationId("child-reservation:run-fence:call-1"),
+		parentSubmissionId: parent.submissionId,
+		parentToolCallId: decodeToolCallId("call-child-fence"),
+		ownershipToken: BOGUS_TOKEN,
+		allocation,
+		allocationDigest
+	};
+	const request = ChildBudgetReservationRequest.make(requestFields);
+	const foreign = yield* expectFailure("creating a reservation without owning the parent lane", ledger.reserveChildBudget(request));
+	yield* ensure(isOwnershipLost(foreign), "Reservation creation must be fenced by the parent's live ownership token");
+	yield* ensure((yield* recoverySnapshot(parent.submissionId)).childReservations.length === 0, "A fenced reservation attempt must leave no row behind");
+	yield* ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
+		...requestFields,
+		ownershipToken: firstClaim.ownershipToken
+	}));
+	yield* ledger.releaseOwnership(ReleaseOwnershipRequest.make({
+		submissionId: parent.submissionId,
+		ownershipToken: firstClaim.ownershipToken
+	}));
+	const reclaim = yield* expectSome("the replacement parent claim", yield* claimLane(threadId, PRODUCER_B));
+	yield* ensure(reclaim.producerEpoch > firstClaim.producerEpoch, "The replacement claim must fence the stale parent Attempt");
+	const staleAttach = yield* expectFailure("attaching a child with the superseded parent token", ledger.attachChildToReservation(AttachChildToReservationRequest.make({
+		reservationId: request.reservationId,
+		ownershipToken: firstClaim.ownershipToken,
+		childSubmissionId: child.submissionId
+	})));
+	yield* ensure(isOwnershipLost(staleAttach), "A superseded parent token must not attach a child");
+	const staleCreate = yield* expectFailure("creating a second-call reservation with the superseded parent token", ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
+		...requestFields,
+		reservationId: decodeChildReservationId("child-reservation:run-fence:call-2"),
+		parentToolCallId: decodeToolCallId("call-child-fence-second"),
+		ownershipToken: firstClaim.ownershipToken
+	})));
+	yield* ensure(isOwnershipLost(staleCreate), "A superseded parent token must not create new reservation state");
+	const staleReplay = yield* ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
+		...requestFields,
+		ownershipToken: firstClaim.ownershipToken
+	}));
+	yield* ensure(staleReplay.replayed && staleReplay.reservation.status === "reserved", "An identical reservation replay must return the recorded row even from a stale caller");
+	yield* ensure((yield* ledger.attachChildToReservation(AttachChildToReservationRequest.make({
+		reservationId: request.reservationId,
+		ownershipToken: reclaim.ownershipToken,
+		childSubmissionId: child.submissionId
+	}))).childSubmissionId === child.submissionId, "The live replacement token must attach the child");
+}));
+const attachChildIdempotency = conformanceCase("attachChildToReservation is idempotent and rejects a divergent child", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("ledger-conformance-child-attach");
+	const childLane = decodeThreadId("ledger-conformance-child-attach-child");
+	const ledger = yield* SubmissionLedger;
+	const parent = yield* admitReady(threadId, "child-attach-parent", { work: "parent" });
+	const child = yield* admitReady(childLane, "child-attach-child", { queued: 1 });
+	const otherChild = yield* admitReady(childLane, "child-attach-other", { queued: 2 });
+	const claim = yield* expectSome("the parent claim", yield* claimLane(threadId, PRODUCER_A));
+	const allocation = { turns: 3 };
+	const reservationId = decodeChildReservationId("child-reservation:run-attach:call-1");
+	yield* ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
+		reservationId,
+		parentSubmissionId: parent.submissionId,
+		parentToolCallId: decodeToolCallId("call-child-attach"),
+		ownershipToken: claim.ownershipToken,
+		allocation,
+		allocationDigest: yield* digestJson(allocation)
+	}));
+	const unknownReservation = yield* expectFailure("attaching to a reservation that was never created", ledger.attachChildToReservation(AttachChildToReservationRequest.make({
+		reservationId: decodeChildReservationId("child-reservation:run-attach:missing"),
+		ownershipToken: claim.ownershipToken,
+		childSubmissionId: child.submissionId
+	})));
+	yield* ensure(isLedgerError(unknownReservation), "Attaching to an unknown reservation must fail as a ledger error");
+	const attached = yield* ledger.attachChildToReservation(AttachChildToReservationRequest.make({
+		reservationId,
+		ownershipToken: claim.ownershipToken,
+		childSubmissionId: child.submissionId
+	}));
+	yield* ensure(attached.childSubmissionId === child.submissionId && attached.status === "reserved", "Attaching must record the child on the reservation row");
+	yield* ensure((yield* ledger.attachChildToReservation(AttachChildToReservationRequest.make({
+		reservationId,
+		ownershipToken: claim.ownershipToken,
+		childSubmissionId: child.submissionId
+	}))).childSubmissionId === child.submissionId, "Repeating the identical attachment must be a no-op");
+	const divergent = yield* expectFailure("attaching a different child to the same reservation", ledger.attachChildToReservation(AttachChildToReservationRequest.make({
+		reservationId,
+		ownershipToken: claim.ownershipToken,
+		childSubmissionId: otherChild.submissionId
+	})));
+	yield* ensure(isChildReservationConflict(divergent), "A divergent child attachment must conflict with the recorded child");
+	const snapshot = yield* recoverySnapshot(parent.submissionId);
+	yield* ensure(snapshot.childAttachments.length === 1 && snapshot.childAttachments[0].childSubmissionId === child.submissionId && snapshot.childAttachments[0].toolCallId === decodeToolCallId("call-child-attach") && snapshot.childAttachments[0].childState === "ready" && snapshot.childAttachments[0].childOutcome === void 0, "The parent recovery snapshot must expose the attachment with the child's lane state");
+}));
+const beginReleaseFreezesAccountingOnce = conformanceCase("beginRelease freezes the accounting decision exactly once", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("ledger-conformance-child-freeze");
+	const ledger = yield* SubmissionLedger;
+	const parent = yield* admitReady(threadId, "child-freeze-parent", { work: "parent" });
+	const claim = yield* expectSome("the parent claim", yield* claimLane(threadId, PRODUCER_A));
+	const allocation = { turns: 4 };
+	const reservationId = decodeChildReservationId("child-reservation:run-freeze:call-1");
+	yield* ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
+		reservationId,
+		parentSubmissionId: parent.submissionId,
+		parentToolCallId: decodeToolCallId("call-child-freeze"),
+		ownershipToken: claim.ownershipToken,
+		allocation,
+		allocationDigest: yield* digestJson(allocation)
+	}));
+	const accounting = {
+		consumed: { turns: 1 },
+		released: { turns: 3 }
+	};
+	const frozen = yield* ledger.beginChildBudgetRelease(BeginChildBudgetReleaseRequest.make({
+		reservationId,
+		accounting
+	}));
+	yield* ensure(frozen.status === "releasePending" && frozen.accounting !== void 0 && persistedJsonEquivalent(frozen.accounting, accounting) && frozen.releaseBeganAt !== void 0, "The first beginRelease must freeze the accounting and move to releasePending");
+	yield* TestClock.adjust("1 second");
+	const replayed = yield* ledger.beginChildBudgetRelease(BeginChildBudgetReleaseRequest.make({
+		reservationId,
+		accounting: {
+			released: { turns: 3 },
+			consumed: { turns: 1 }
+		}
+	}));
+	yield* ensure(replayed.status === "releasePending" && replayed.releaseBeganAt !== void 0 && frozen.releaseBeganAt !== void 0 && sameInstant(replayed.releaseBeganAt, frozen.releaseBeganAt), "Replaying the identical accounting must be a no-op with the frozen decision retained");
+	const divergent = yield* expectFailure("freezing a different accounting decision", ledger.beginChildBudgetRelease(BeginChildBudgetReleaseRequest.make({
+		reservationId,
+		accounting: {
+			consumed: { turns: 4 },
+			released: { turns: 0 }
+		}
+	})));
+	yield* ensure(isChildReservationConflict(divergent) && divergent.status === "releasePending", "A divergent accounting freeze must conflict with the frozen decision");
+	yield* ledger.releaseChildBudget(ReleaseChildBudgetRequest.make({ reservationId }));
+	const afterRelease = yield* ledger.beginChildBudgetRelease(BeginChildBudgetReleaseRequest.make({
+		reservationId,
+		accounting
+	}));
+	yield* ensure(afterRelease.status === "released" && afterRelease.accounting !== void 0 && persistedJsonEquivalent(afterRelease.accounting, accounting), "Replaying the identical accounting after release must return the released row");
+	const divergentAfterRelease = yield* expectFailure("freezing a different accounting decision after release", ledger.beginChildBudgetRelease(BeginChildBudgetReleaseRequest.make({
+		reservationId,
+		accounting: {
+			consumed: { turns: 2 },
+			released: { turns: 2 }
+		}
+	})));
+	yield* ensure(isChildReservationConflict(divergentAfterRelease) && divergentAfterRelease.status === "released", "The frozen decision must stay immutable after release");
+}));
+const releaseAppliedExactlyOnce = conformanceCase("release returns unused allocation exactly once", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("ledger-conformance-child-release");
+	const ledger = yield* SubmissionLedger;
+	const parent = yield* admitReady(threadId, "child-release-parent", { work: "parent" });
+	const claim = yield* expectSome("the parent claim", yield* claimLane(threadId, PRODUCER_A));
+	const allocation = { turns: 4 };
+	const reservationId = decodeChildReservationId("child-reservation:run-release:call-1");
+	yield* ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
+		reservationId,
+		parentSubmissionId: parent.submissionId,
+		parentToolCallId: decodeToolCallId("call-child-release"),
+		ownershipToken: claim.ownershipToken,
+		allocation,
+		allocationDigest: yield* digestJson(allocation)
+	}));
+	const early = yield* expectFailure("releasing before the accounting decision is frozen", ledger.releaseChildBudget(ReleaseChildBudgetRequest.make({ reservationId })));
+	yield* ensure(isChildReservationConflict(early) && early.status === "reserved", "Release must never skip the releasePending freeze");
+	yield* ledger.beginChildBudgetRelease(BeginChildBudgetReleaseRequest.make({
+		reservationId,
+		accounting: {
+			consumed: {},
+			released: { turns: 4 }
+		}
+	}));
+	const released = yield* ledger.releaseChildBudget(ReleaseChildBudgetRequest.make({ reservationId }));
+	yield* ensure(released.status === "released" && released.releasedAt !== void 0, "Release must transition releasePending to released");
+	yield* TestClock.adjust("1 second");
+	const replayed = yield* ledger.releaseChildBudget(ReleaseChildBudgetRequest.make({ reservationId }));
+	yield* ensure(replayed.status === "released" && replayed.releasedAt !== void 0 && released.releasedAt !== void 0 && sameInstant(replayed.releasedAt, released.releasedAt), "Replaying the release must return the stored row unchanged — never applied twice");
+	const snapshot = yield* recoverySnapshot(parent.submissionId);
+	yield* ensure(snapshot.childReservations.length === 1 && snapshot.childReservations[0].status === "released", "The recovery snapshot must expose the released reservation");
+}));
+const recordChildSettledWake = conformanceCase("recordChildSettled accepts canonical terminalizing prefixes and wakes only when all are covered", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
+	const parentLane = decodeThreadId("ledger-conformance-child-wake");
+	const childLaneA = decodeThreadId("ledger-conformance-child-wake-a");
+	const childLaneB = decodeThreadId("ledger-conformance-child-wake-b");
+	const ledger = yield* SubmissionLedger;
+	const parent = yield* admitReady(parentLane, "child-wake-parent", { work: "parent" });
+	const childA = yield* admitReady(childLaneA, "child-wake-a", { child: "a" });
+	const childB = yield* admitReady(childLaneB, "child-wake-b", { child: "b" });
+	const parentClaim = yield* expectSome("the parent claim", yield* claimLane(parentLane, PRODUCER_A));
+	yield* ensure((yield* ledger.suspend(SuspendRequest.make({
+		submissionId: parent.submissionId,
+		ownershipToken: parentClaim.ownershipToken,
+		reason: WaitingForChildSuspension.make({ children: [WaitingChild.make({
+			toolCallId: decodeToolCallId("call-wake-a"),
+			childSubmissionId: childA.submissionId
+		}), WaitingChild.make({
+			toolCallId: decodeToolCallId("call-wake-b"),
+			childSubmissionId: childB.submissionId
+		})] })
+	}))) === "suspended", "Unsettled children must suspend the parent durably");
+	const ended = yield* expectFailure("renewing after the waitingForChild suspension ended the ownership period", ledger.renewOwnership(RenewOwnershipRequest.make({
+		submissionId: parent.submissionId,
+		ownershipToken: parentClaim.ownershipToken
+	})));
+	yield* ensure(isOwnershipLost(ended), "waitingForChild must end the ownership period without settling (SUB-030)");
+	yield* ensure(Option.isNone(yield* claimLane(parentLane, PRODUCER_B)), "A waitingForChild head must produce no claim and consume no worker permit");
+	const childClaimA = yield* expectSome("the first child claim", yield* claimLane(childLaneA, PRODUCER_A));
+	const childReservationA = yield* settlementReservation({
+		submissionId: childA.submissionId,
+		ownershipToken: childClaimA.ownershipToken,
+		receiptId: childA.receiptId,
+		outcome: "completed"
+	});
+	yield* ledger.reserveSettlement(childReservationA);
+	yield* ensure((yield* ledger.recordChildSettled(ChildSettledNotification.make({
+		parentSubmissionId: parent.submissionId,
+		childSubmissionId: childA.submissionId
+	}))) === "still-waiting", "A settlement notification must not wake the parent while a listed child is unsettled");
+	yield* ledger.finalizeSettlement(SettlementFinalization.make({
+		submissionId: childA.submissionId,
+		settlementId: childReservationA.settlementId
+	}));
+	yield* ensure((yield* expectSome("lookup while one child is outstanding", yield* lookupById(parent.submissionId))).state === "suspended" && Option.isNone(yield* claimLane(parentLane, PRODUCER_B)), "The parent lane must stay suspended until every listed child settled");
+	const childClaimB = yield* expectSome("the second child claim", yield* claimLane(childLaneB, PRODUCER_A));
+	const childReservationB = yield* settlementReservation({
+		submissionId: childB.submissionId,
+		ownershipToken: childClaimB.ownershipToken,
+		receiptId: childB.receiptId,
+		outcome: "completed"
+	});
+	yield* ledger.reserveSettlement(childReservationB);
+	yield* ensure((yield* ledger.recordChildSettled(ChildSettledNotification.make({
+		parentSubmissionId: parent.submissionId,
+		childSubmissionId: childB.submissionId
+	}))) === "woken", "The covering canonical settlement prefix must wake the parent before child finalization");
+	yield* ledger.finalizeSettlement(SettlementFinalization.make({
+		submissionId: childB.submissionId,
+		settlementId: childReservationB.settlementId
+	}));
+	yield* ensure((yield* expectSome("lookup after the covering settlement", yield* lookupById(parent.submissionId))).state === "input-applied", "The woken parent must transition suspended(WaitingForChild) to input-applied");
+	yield* ensure((yield* recoverySnapshot(parent.submissionId)).suspension === void 0, "Waking must clear the durable suspension");
+	yield* ensure((yield* ledger.recordChildSettled(ChildSettledNotification.make({
+		parentSubmissionId: parent.submissionId,
+		childSubmissionId: childA.submissionId
+	}))) === "not-waiting", "Replaying a notification after the wake must be an idempotent no-op");
+	const reclaim = yield* expectSome("the parent claim after waking", yield* claimLane(parentLane, PRODUCER_B));
+	yield* ensure(reclaim.submissionId === parent.submissionId && reclaim.producerEpoch > parentClaim.producerEpoch, "The woken lane must grant a fresh fenced Attempt");
+	yield* settleClaimed(parent, reclaim.ownershipToken);
+	yield* ensure((yield* ledger.recordChildSettled(ChildSettledNotification.make({
+		parentSubmissionId: parent.submissionId,
+		childSubmissionId: childB.submissionId
+	}))) === "not-waiting", "A notification for a settled parent must answer not-waiting");
+}));
+const suspendResumesImmediatelyForSettledChildren = conformanceCase("suspend returns resume-immediately when children already settled", ({ ensure, expectSome }) => Effect.gen(function* () {
+	const parentLane = decodeThreadId("ledger-conformance-child-raced");
+	const childLaneA = decodeThreadId("ledger-conformance-child-raced-a");
+	const childLaneB = decodeThreadId("ledger-conformance-child-raced-b");
+	const ledger = yield* SubmissionLedger;
+	const settledChild = yield* admitReady(childLaneA, "child-raced-a", { child: "a" });
+	const settledClaim = yield* expectSome("the settled child's claim", yield* claimLane(childLaneA, PRODUCER_A));
+	yield* settleClaimed(settledChild, settledClaim.ownershipToken);
+	const pendingChild = yield* admitReady(childLaneB, "child-raced-b", { child: "b" });
+	const parent = yield* admitReady(parentLane, "child-raced-parent", { work: "parent" });
+	const parentClaim = yield* expectSome("the parent claim", yield* claimLane(parentLane, PRODUCER_A));
+	yield* ensure((yield* ledger.suspend(SuspendRequest.make({
+		submissionId: parent.submissionId,
+		ownershipToken: parentClaim.ownershipToken,
+		reason: WaitingForChildSuspension.make({ children: [WaitingChild.make({
+			toolCallId: decodeToolCallId("call-raced-a"),
+			childSubmissionId: settledChild.submissionId
+		})] })
+	}))) === "resume-immediately", "A suspend listing only settled children must resume immediately");
+	yield* ensure((yield* expectSome("lookup after the immediate resume", yield* lookupById(parent.submissionId))).state === "running", "An immediate resume must not transition the parent to suspended");
+	yield* ledger.renewOwnership(RenewOwnershipRequest.make({
+		submissionId: parent.submissionId,
+		ownershipToken: parentClaim.ownershipToken
+	}));
+	yield* ensure((yield* ledger.suspend(SuspendRequest.make({
+		submissionId: parent.submissionId,
+		ownershipToken: parentClaim.ownershipToken,
+		reason: WaitingForChildSuspension.make({ children: [WaitingChild.make({
+			toolCallId: decodeToolCallId("call-raced-a"),
+			childSubmissionId: settledChild.submissionId
+		}), WaitingChild.make({
+			toolCallId: decodeToolCallId("call-raced-b"),
+			childSubmissionId: pendingChild.submissionId
+		})] })
+	}))) === "suspended", "One unsettled listed child must suspend the parent durably");
+	const snapshot = yield* recoverySnapshot(parent.submissionId);
+	yield* ensure(snapshot.suspension !== void 0 && snapshot.suspension.reason._tag === "WaitingForChild" && snapshot.suspension.reason.children.length === 2, "The recovery snapshot must expose the WaitingForChild reason with its children");
+}));
+const admissionParentLinkage = conformanceCase("admit records and replays parent linkage", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
+	const parentLane = decodeThreadId("ledger-conformance-linkage");
+	const childLane = decodeThreadId("ledger-conformance-linkage-child");
+	const ledger = yield* SubmissionLedger;
+	const parent = yield* admitReady(parentLane, "linkage-parent", { work: "parent" });
+	const linkage = ParentLinkage.make({
+		parentSubmissionId: parent.submissionId,
+		parentToolCallId: decodeToolCallId("call-linkage")
+	});
+	const request = yield* admissionRequest(childLane, "linkage-child-key", { task: "research" }, linkage);
+	const admitted = yield* ledger.admit(request);
+	yield* ensure(!admitted.replayed, "The first linked admission must create the child");
+	const byId = yield* expectSome("lookup of the linked child", yield* lookupById(admitted.submissionId));
+	yield* ensure(byId.parentLinkage !== void 0 && byId.parentLinkage.parentSubmissionId === parent.submissionId && byId.parentLinkage.parentToolCallId === linkage.parentToolCallId, "The child snapshot must expose its immutable parent linkage");
+	const childSnapshot = yield* recoverySnapshot(admitted.submissionId);
+	yield* ensure(childSnapshot.parentLinkage !== void 0 && childSnapshot.parentLinkage.parentSubmissionId === parent.submissionId, "The child recovery snapshot must expose its parent linkage");
+	const replayed = yield* ledger.admit(request);
+	yield* ensure(replayed.replayed && replayed.submissionId === admitted.submissionId && replayed.receiptId === admitted.receiptId, "An identical linked admission must replay the original identities (SUB-016)");
+	const divergentLinkage = yield* expectFailure("replaying the admission with a different parent Tool Call", ledger.admit(yield* admissionRequest(childLane, "linkage-child-key", { task: "research" }, ParentLinkage.make({
+		parentSubmissionId: parent.submissionId,
+		parentToolCallId: decodeToolCallId("call-linkage-other")
+	}))));
+	yield* ensure(isAdmissionConflict(divergentLinkage), "A divergent parent linkage must conflict even when the input digest matches");
+	const droppedLinkage = yield* expectFailure("replaying the admission without its parent linkage", ledger.admit(yield* admissionRequest(childLane, "linkage-child-key", { task: "research" })));
+	yield* ensure(isAdmissionConflict(droppedLinkage), "Dropping the recorded linkage on replay must conflict");
+	const plain = yield* ledger.admit(yield* admissionRequest(childLane, "linkage-plain-key", { task: "plain" }));
+	const addedLinkage = yield* expectFailure("replaying an unlinked admission with a parent linkage", ledger.admit(yield* admissionRequest(childLane, "linkage-plain-key", { task: "plain" }, linkage)));
+	yield* ensure(isAdmissionConflict(addedLinkage), "Adding a linkage to an unlinked admission on replay must conflict");
+	yield* ensure((yield* expectSome("lookup of the unlinked Submission", yield* lookupById(plain.submissionId))).parentLinkage === void 0, "An unlinked Submission must expose no parent linkage");
+}));
+const resolveAdmissionAuthority = conformanceCase("resolveAdmission distinguishes notAdmitted from admitted authoritatively", ({ ensure, expectSome }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("ledger-conformance-resolve");
+	const ledger = yield* SubmissionLedger;
+	const key = SubmissionLookupByKey.make({
+		threadId,
+		principal: CONFORMANCE_PRINCIPAL,
+		idempotencyKey: decodeIdempotencyKey("resolve-key-1")
+	});
+	yield* ensure((yield* ledger.resolveAdmission(key))._tag === "NotAdmitted", "The authoritative store must prove absence before admission (SUB-031)");
+	const admitted = yield* ledger.admit(yield* admissionRequest(threadId, "resolve-key-1", { work: "resolve" }));
+	const after = yield* ledger.resolveAdmission(key);
+	yield* ensure(after._tag === "Admitted" && after.submission.submissionId === admitted.submissionId && after.submission.receiptId === admitted.receiptId && after.submission.state === "admitted", "An admitted key must resolve to the full authoritative snapshot");
+	yield* ensure((yield* ledger.resolveAdmission(SubmissionLookupByKey.make({
+		threadId,
+		principal: OTHER_PRINCIPAL,
+		idempotencyKey: decodeIdempotencyKey("resolve-key-1")
+	})))._tag === "NotAdmitted", "Admission resolution must stay scoped to the requesting principal");
+	yield* ledger.markReady(MarkReadyRequest.make({ submissionId: admitted.submissionId }));
+	const claim = yield* expectSome("the claim before terminal resolution", yield* claimLane(threadId, PRODUCER_A));
+	yield* settleClaimed(admitted, claim.ownershipToken);
+	const settled = yield* ledger.resolveAdmission(key);
+	yield* ensure(settled._tag === "Admitted" && settled.submission.state === "settled" && settled.submission.settledOutcome === "completed", "A settled Submission still resolves as admitted — terminality never becomes absence");
+}));
+const queuedAbortSettlementAuthority = conformanceCase("reserveSettlement authorizes an aborted, unowned queued settlement by its durable intent", ({ ensure, expectFailure }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("ledger-conformance-queued-abort");
+	const ledger = yield* SubmissionLedger;
+	const head = yield* admitReady(threadId, "queued-abort-head", { work: "head" });
+	const second = yield* admitReady(threadId, "queued-abort-2", { queued: 2 });
+	const third = yield* admitReady(threadId, "queued-abort-3", { queued: 3 });
+	yield* ledger.requestAbort(AbortCommand.make({
+		submissionId: second.submissionId,
+		author: "operator",
+		reason: "cancelled while queued"
+	}));
+	const unaborted = yield* expectFailure("reserving an aborted settlement for a queued row without an abort intent", settlementReservation({
+		submissionId: third.submissionId,
+		ownershipToken: BOGUS_TOKEN,
+		receiptId: third.receiptId,
+		outcome: "aborted"
+	}).pipe(Effect.flatMap((reservation) => ledger.reserveSettlement(reservation))));
+	yield* ensure(isOwnershipLost(unaborted), "A queued reservation without a durable abort intent must stay fenced (OwnershipLost)");
+	const wrongOutcome = yield* expectFailure("reserving a completed settlement for the aborted queued row", settlementReservation({
+		submissionId: second.submissionId,
+		ownershipToken: BOGUS_TOKEN,
+		receiptId: second.receiptId,
+		outcome: "completed",
+		result: { fabricated: true }
+	}).pipe(Effect.flatMap((reservation) => ledger.reserveSettlement(reservation))));
+	yield* ensure(isOwnershipLost(wrongOutcome), "An abort intent must never authorize a non-aborted settlement outcome");
+	const reservation = yield* settlementReservation({
+		submissionId: second.submissionId,
+		ownershipToken: BOGUS_TOKEN,
+		receiptId: second.receiptId,
+		outcome: "aborted"
+	});
+	const reserved = yield* ledger.reserveSettlement(reservation);
+	yield* ensure(reserved.replayed === false && reserved.outcome === "aborted", "The abort intent must authorize the aborted reservation without lane ownership");
+	yield* ensure((yield* ledger.reserveSettlement(reservation)).replayed === true, "Replaying the identical aborted reservation must short-circuit idempotently");
+	yield* ledger.finalizeSettlement(SettlementFinalization.make({
+		submissionId: second.submissionId,
+		settlementId: submissionSettlementId(second.submissionId)
+	}));
+	const settled = yield* recoverySnapshot(second.submissionId);
+	yield* ensure(settled.submission.state === "settled" && settled.submission.settledOutcome === "aborted", "The aborted queued Submission must settle while the head is still unsettled");
+	yield* ensure((yield* recoverySnapshot(head.submissionId)).submission.state === "ready", "Settling the aborted queued row must not disturb the unclaimed head");
+}));
+const abortedSettledRowIsNotAJoiningGap = conformanceCase("claimJoining treats an aborted-settled row as a non-gap", ({ ensure, expectSome }) => Effect.gen(function* () {
+	const threadId = decodeThreadId("ledger-conformance-aborted-non-gap");
+	const ledger = yield* SubmissionLedger;
+	const host = yield* admitReady(threadId, "aborted-gap-host", { work: "host" });
+	const second = yield* admitReady(threadId, "aborted-gap-2", { queued: 2 });
+	const third = yield* admitReady(threadId, "aborted-gap-3", { queued: 3 });
+	yield* ledger.requestAbort(AbortCommand.make({
+		submissionId: second.submissionId,
+		author: "operator",
+		reason: "cancelled while queued"
+	}));
+	const reservation = yield* settlementReservation({
+		submissionId: second.submissionId,
+		ownershipToken: BOGUS_TOKEN,
+		receiptId: second.receiptId,
+		outcome: "aborted"
+	});
+	yield* ledger.reserveSettlement(reservation);
+	yield* ledger.finalizeSettlement(SettlementFinalization.make({
+		submissionId: second.submissionId,
+		settlementId: submissionSettlementId(second.submissionId)
+	}));
+	const hostClaim = yield* expectSome("the host claim", yield* claimLane(threadId, PRODUCER_A));
+	yield* ensure(hostClaim.submissionId === host.submissionId, "The host must head the lane (the aborted-settled row is out of the queue)");
+	const claims = yield* ledger.claimJoining(ClaimJoiningRequest.make({
+		threadId,
+		hostSubmissionId: host.submissionId,
+		ownershipToken: hostClaim.ownershipToken,
+		maxCount: 8
+	}));
+	yield* ensure(claims.length === 1 && claims[0].submissionId === third.submissionId, "The joining prefix must skip the aborted-settled row and claim the later ready work");
+	const settled = yield* recoverySnapshot(second.submissionId);
+	yield* ensure(settled.submission.state === "settled" && settled.submission.settledOutcome === "aborted", "Walking the prefix must never disturb the aborted-settled row");
+}));
 /**
 * The shared, adapter-parameterized SubmissionLedger contract suite (STORE-010). Every durable
 * ledger adapter test suite must execute each case against its own ledger provisioning, inside
@@ -1305,6 +1965,183 @@ const unknownAbortClaim = conformanceCase("a durable abort makes an unknown head
 const submissionLedgerConformanceCases = [
 	admissionIdempotency,
 	workerAdmissionIdentity,
+	conformanceCase("seals terminal assignments atomically while waiting and unapplied corrections remain steerable", ({ ensure, expectSome, expectFailure }) => Effect.gen(function* () {
+		const ledger = yield* SubmissionLedger;
+		if (ledger.inspectWorker === void 0) return;
+		for (const scenario of [
+			{
+				name: "completed",
+				outcome: "completed",
+				disposition: "completed",
+				terminal: "completed"
+			},
+			{
+				name: "waiting",
+				outcome: "completed",
+				disposition: "waiting",
+				terminal: void 0
+			},
+			{
+				name: "failure",
+				outcome: "failed",
+				queued: true,
+				terminal: "failed"
+			},
+			{
+				name: "failure-joining",
+				outcome: "failed",
+				queued: true,
+				joining: true,
+				terminal: "failed"
+			},
+			{
+				name: "exhaustion",
+				outcome: "completed",
+				exhausted: true,
+				terminal: "failed"
+			},
+			{
+				name: "active-abort",
+				outcome: "aborted",
+				terminal: "cancelled"
+			},
+			{
+				name: "queued-abort",
+				outcome: "aborted",
+				noRun: true,
+				terminal: void 0
+			},
+			{
+				name: "reusable",
+				outcome: "completed",
+				disposition: "completed",
+				reusable: true,
+				terminal: void 0
+			},
+			{
+				name: "late-correction",
+				outcome: "completed",
+				disposition: "completed",
+				queued: true,
+				terminal: void 0
+			},
+			{
+				name: "applied-correction",
+				outcome: "completed",
+				disposition: "completed",
+				queued: true,
+				joined: true,
+				terminal: "completed"
+			}
+		]) {
+			const threadId = decodeThreadId(`assignment-${scenario.name}`);
+			const base = yield* admissionRequest(threadId, "first", { text: "first" });
+			const metadata = workerMetadata(base);
+			const workerAdmission = WorkerAdmission.make({
+				...metadata,
+				origin: {
+					...metadata.origin,
+					..."reusable" in scenario ? {} : { lifecycle: "assignment" }
+				}
+			});
+			const request = AdmissionRequest.make({
+				...base,
+				workerAdmission
+			});
+			const first = yield* ledger.admit(request);
+			yield* ledger.markReady(MarkReadyRequest.make({ submissionId: first.submissionId }));
+			const claim = yield* expectSome("assignment claim", yield* claimLane(threadId, PRODUCER_A));
+			const runId = runIdForSubmission(first.submissionId);
+			const payload = yield* Schema.decodeEffect(SubmissionSettledRecord)(SubmissionSettled.make({
+				submissionId: first.submissionId,
+				settlementId: submissionSettlementId(first.submissionId),
+				receiptId: first.receiptId,
+				outcome: scenario.outcome,
+				..."noRun" in scenario ? {} : { runId },
+				...scenario.outcome === "aborted" ? {} : { result: scenario.outcome === "failed" ? {
+					errorTag: "TestFailure",
+					message: "Failed task"
+				} : { answer: "done" } },
+				..."disposition" in scenario ? { runDisposition: scenario.disposition } : {},
+				..."exhausted" in scenario ? {
+					finishReason: "budget-exhausted",
+					exhausted: "turns"
+				} : {}
+			})).pipe(Effect.orDie);
+			const record = RecordEnvelope.make({
+				recordId: submissionSettlementRecordId(first.submissionId),
+				family: "thread",
+				schemaVersion: 1,
+				createdAt: CONFORMANCE_CREATED_AT,
+				deploymentId: CONFORMANCE_DEPLOYMENT,
+				payload
+			});
+			let queued;
+			if ("queued" in scenario) {
+				const next = yield* admissionRequest(threadId, "correction", { text: "correction" });
+				queued = yield* ledger.admit(AdmissionRequest.make({
+					...next,
+					workerAdmission: {
+						...workerAdmission,
+						messageId: next.idempotencyKey
+					}
+				}));
+				yield* ledger.markReady(MarkReadyRequest.make({ submissionId: queued.submissionId }));
+				if ("joined" in scenario || "joining" in scenario) yield* ledger.claimJoining(ClaimJoiningRequest.make({
+					threadId,
+					hostSubmissionId: first.submissionId,
+					ownershipToken: claim.ownershipToken,
+					maxCount: 1
+				}));
+				if ("joined" in scenario) yield* ledger.markJoined(MarkJoinedRequest.make({
+					submissionId: queued.submissionId,
+					ownershipToken: claim.ownershipToken,
+					recordId: submissionInputRecordId(queued.submissionId),
+					sequence: Schema.decodeSync(CanonicalSequence)(2)
+				}));
+			}
+			yield* ledger.reserveSettlement(SettlementReservation.make({
+				submissionId: first.submissionId,
+				ownershipToken: claim.ownershipToken,
+				settlementId: payload.settlementId,
+				outcome: scenario.outcome,
+				record,
+				recordDigest: yield* digestJson(yield* Schema.encodeEffect(RecordEnvelope)(record).pipe(Effect.orDie))
+			}));
+			const finalization = SettlementFinalization.make({
+				submissionId: first.submissionId,
+				settlementId: payload.settlementId
+			});
+			const settled = yield* ledger.finalizeSettlement(finalization);
+			yield* ensure(Schema.toEquivalence(Settlement)(settled, yield* ledger.finalizeSettlement(finalization)), "Finalization replay must preserve its exact outcome");
+			const control = yield* ledger.inspectWorker(threadId);
+			yield* ensure(control.terminal === scenario.terminal && control.stopped === (scenario.terminal !== void 0), `Wrong assignment state for ${scenario.name}`);
+			yield* ensure((yield* ledger.admit(request)).receiptId === first.receiptId, "A seal must preserve same-command receipt replay");
+			const next = yield* admissionRequest(threadId, "later", { text: "later" });
+			const later = AdmissionRequest.make({
+				...next,
+				workerAdmission: {
+					...workerAdmission,
+					messageId: next.idempotencyKey
+				}
+			});
+			if (scenario.terminal !== void 0) {
+				const refusal = yield* expectFailure("terminal admission", ledger.admit(later));
+				yield* ensure(Schema.is(AdmissionPolicyError)(refusal) && refusal.code === "worker-stopped", "New instructions cannot reopen a terminal assignment");
+			} else yield* ledger.admit(later);
+			if (queued !== void 0) {
+				if ("joining" in scenario) yield* ledger.revertJoining(RevertJoiningRequest.make({ submissionId: queued.submissionId }));
+				yield* ensure((yield* recoverySnapshot(queued.submissionId)).abortIntent !== void 0 === (scenario.outcome === "failed"), "Failure aborts queued inputs; completion never cancels an accepted correction or joined member");
+			}
+			if (scenario.terminal !== void 0 && ledger.stopWorker !== void 0) {
+				yield* ledger.stopWorker({
+					threadId,
+					author: CONFORMANCE_PRINCIPAL
+				});
+				yield* ensure((yield* ledger.inspectWorker(threadId)).terminal === scenario.terminal, "Explicit stop cannot replace an assignment's first terminal outcome");
+			}
+		}
+	})),
 	messageAdmissionIdentity,
 	workerCompletionIdentity,
 	workerUpdateIdentity,
@@ -1328,665 +2165,21 @@ const submissionLedgerConformanceCases = [
 	markJoinedIdempotency,
 	claimNeverGrantsBlockedHead,
 	approvalDecisionIdempotency,
-	conformanceCase("unknown resolutions reopen the lane only when no open call remains", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
-		const threadId = decodeThreadId("ledger-conformance-unknown");
-		const ledger = yield* SubmissionLedger;
-		const admitted = yield* admitReady(threadId, "unknown-key-1", { work: "unknown" });
-		const claim = yield* expectSome("the claim before the unknown marking", yield* claimLane(threadId, PRODUCER_A));
-		const call1 = decodeToolCallId("call-unknown-1");
-		const call2 = decodeToolCallId("call-unknown-2");
-		const call3 = decodeToolCallId("call-unknown-3");
-		const marking = MarkUnknownRequest.make({
-			submissionId: admitted.submissionId,
-			toolCallIds: [call1, call2],
-			reason: "the worker died during two supplier calls"
-		});
-		yield* ledger.markUnknown(marking);
-		yield* ledger.markUnknown(marking);
-		yield* ensure((yield* expectSome("lookup after marking unknown", yield* lookupById(admitted.submissionId))).state === "unknown", "Marking unknown must be idempotent and block the lane");
-		yield* advancePastLease(claim.leaseExpiresAt);
-		yield* ensure(Option.isNone(yield* claimLane(threadId, PRODUCER_B)), "An unknown lane must consume no worker permit");
-		const first = yield* ledger.recordUnknownResolution(UnknownResolutionCommand.make({
-			submissionId: admitted.submissionId,
-			toolCallId: call1,
-			author: "conformance-operator",
-			reason: "supplier store shows no booking",
-			resolution: ResolutionNeverHappened.make()
-		}));
-		yield* ensure((yield* expectSome("lookup after a partial resolution", yield* lookupById(admitted.submissionId))).state === "unknown" && Option.isNone(yield* claimLane(threadId, PRODUCER_B)), "A partial resolution must keep the lane blocked while calls remain open");
-		yield* TestClock.adjust("1 second");
-		const divergent = yield* expectFailure("re-resolving the same call divergently", ledger.recordUnknownResolution(UnknownResolutionCommand.make({
-			submissionId: admitted.submissionId,
-			toolCallId: call1,
-			author: "conformance-operator",
-			reason: "changed my mind",
-			resolution: ResolutionSafeToRetry.make()
-		})));
-		yield* ensure(isUnknownResolutionConflict(divergent) && divergent.toolCallId === call1, "A divergent re-resolution must conflict");
-		const replayed = yield* ledger.recordUnknownResolution(UnknownResolutionCommand.make({
-			submissionId: admitted.submissionId,
-			toolCallId: call1,
-			author: "conformance-operator-second",
-			reason: "a different reason text",
-			resolution: ResolutionNeverHappened.make()
-		}));
-		yield* ensure(sameInstant(replayed.resolvedAt, first.resolvedAt) && replayed.reason === first.reason, "Repeating the same resolution must replay the recorded intent unchanged");
-		yield* ledger.markUnknown(MarkUnknownRequest.make({
-			submissionId: admitted.submissionId,
-			toolCallIds: [call3],
-			reason: "a second wave of uncertainty"
-		}));
-		yield* ledger.recordUnknownResolution(UnknownResolutionCommand.make({
-			submissionId: admitted.submissionId,
-			toolCallId: call2,
-			author: "conformance-operator",
-			reason: "supplier confirmed the booking",
-			resolution: ResolutionCompletedWithResult.make({
-				result: { bookingRef: "booking-1" },
-				isFailure: false
-			})
-		}));
-		yield* ensure((yield* expectSome("lookup while the extended set stays open", yield* lookupById(admitted.submissionId))).state === "unknown" && Option.isNone(yield* claimLane(threadId, PRODUCER_B)), "The lane must stay blocked while any marked call lacks a resolution");
-		yield* ledger.recordUnknownResolution(UnknownResolutionCommand.make({
-			submissionId: admitted.submissionId,
-			toolCallId: call3,
-			author: "conformance-operator",
-			reason: "idempotency key covers a repeat",
-			resolution: ResolutionSafeToRetry.make()
-		}));
-		yield* ensure((yield* expectSome("lookup after the covering resolution", yield* lookupById(admitted.submissionId))).state === "input-applied", "Covering every marked call must reopen the lane as input-applied");
-		yield* ensure((yield* recoverySnapshot(admitted.submissionId)).unknownResolutions.length === 3, "The recovery snapshot must expose every recorded resolution intent");
-		const reclaim = yield* expectSome("the claim after the lane reopened", yield* claimLane(threadId, PRODUCER_B));
-		yield* ensure(reclaim.submissionId === admitted.submissionId && reclaim.producerEpoch > claim.producerEpoch, "The reopened lane must grant a fresh fenced Attempt");
-		yield* settleClaimed(admitted, reclaim.ownershipToken);
-		const late = yield* expectFailure("resolving an unknown call for a settled Submission", ledger.recordUnknownResolution(UnknownResolutionCommand.make({
-			submissionId: admitted.submissionId,
-			toolCallId: decodeToolCallId("call-unknown-late"),
-			author: "conformance-operator",
-			reason: "too late",
-			resolution: ResolutionNeverHappened.make()
-		})));
-		yield* ensure(isSettlementConflict(late), "A resolution must never land on a settled Submission");
-	})),
+	unknownResolutionLifecycle,
 	unknownAbortClaim,
-	conformanceCase("suspend with an already-present decision resumes immediately", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
-		const threadId = decodeThreadId("ledger-conformance-suspend");
-		const ledger = yield* SubmissionLedger;
-		const admitted = yield* admitReady(threadId, "suspend-key-1", { work: "suspend" });
-		const claim = yield* expectSome("the claim before suspension", yield* claimLane(threadId, PRODUCER_A));
-		const callA = decodeToolCallId("call-suspend-a");
-		const callB = decodeToolCallId("call-suspend-b");
-		const foreign = yield* expectFailure("suspending without owning the lane", ledger.suspend(SuspendRequest.make({
-			submissionId: admitted.submissionId,
-			ownershipToken: BOGUS_TOKEN,
-			reason: ApprovalPendingSuspension.make({ toolCallIds: [callA] })
-		})));
-		yield* ensure(isOwnershipLost(foreign), "suspend must be fenced by the owning token");
-		yield* ledger.recordApprovalDecision(ApprovalDecisionCommand.make({
-			submissionId: admitted.submissionId,
-			toolCallId: callA,
-			decision: "approved",
-			resolver: "conformance-approver",
-			reason: "decided before the suspend committed"
-		}));
-		yield* ensure((yield* ledger.suspend(SuspendRequest.make({
-			submissionId: admitted.submissionId,
-			ownershipToken: claim.ownershipToken,
-			reason: ApprovalPendingSuspension.make({ toolCallIds: [callA] })
-		}))) === "resume-immediately", "A fully-decided suspension reason must resume immediately");
-		yield* ensure((yield* expectSome("lookup after the immediate resume", yield* lookupById(admitted.submissionId))).state === "running", "An immediate resume must not transition the Submission to suspended");
-		yield* ledger.renewOwnership(RenewOwnershipRequest.make({
-			submissionId: admitted.submissionId,
-			ownershipToken: claim.ownershipToken
-		}));
-		yield* ensure((yield* ledger.suspend(SuspendRequest.make({
-			submissionId: admitted.submissionId,
-			ownershipToken: claim.ownershipToken,
-			reason: ApprovalPendingSuspension.make({ toolCallIds: [callA, callB] })
-		}))) === "suspended", "An undecided call in the reason must suspend durably");
-		yield* ensure((yield* expectSome("lookup after the suspension", yield* lookupById(admitted.submissionId))).state === "suspended", "The suspension must be durable");
-		const suspendedSnapshot = yield* recoverySnapshot(admitted.submissionId);
-		yield* ensure(suspendedSnapshot.suspension !== void 0 && suspendedSnapshot.suspension.reason._tag === "ApprovalPending" && suspendedSnapshot.suspension.reason.toolCallIds.length === 2 && suspendedSnapshot.approvalDecisions.length === 1, "The recovery snapshot must expose the suspension reason and prior decisions");
-		const ended = yield* expectFailure("renewing after the suspension ended the ownership period", ledger.renewOwnership(RenewOwnershipRequest.make({
-			submissionId: admitted.submissionId,
-			ownershipToken: claim.ownershipToken
-		})));
-		yield* ensure(isOwnershipLost(ended), "Suspension must end the ownership period without settling");
-		yield* ledger.recordApprovalDecision(ApprovalDecisionCommand.make({
-			submissionId: admitted.submissionId,
-			toolCallId: callB,
-			decision: "denied",
-			resolver: "conformance-approver",
-			reason: "the covering decision"
-		}));
-		yield* ensure((yield* expectSome("lookup after the covering decision", yield* lookupById(admitted.submissionId))).state === "input-applied", "The covering decision must wake the suspended lane");
-		yield* ensure((yield* recoverySnapshot(admitted.submissionId)).suspension === void 0, "Waking must clear the durable suspension");
-		const reclaim = yield* expectSome("the claim after waking", yield* claimLane(threadId, PRODUCER_B));
-		yield* settleClaimed(admitted, reclaim.ownershipToken);
-		const terminal = yield* expectFailure("suspending a settled Submission", ledger.suspend(SuspendRequest.make({
-			submissionId: admitted.submissionId,
-			ownershipToken: reclaim.ownershipToken,
-			reason: ApprovalPendingSuspension.make({ toolCallIds: [callA] })
-		})));
-		yield* ensure(isSettlementConflict(terminal) && terminal.existingOutcome === "completed", "Suspension must never land on a settled Submission");
-	})),
-	conformanceCase("a joined Submission's settlement reservation is authorized by host linkage", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
-		const threadId = decodeThreadId("ledger-conformance-joined-settlement");
-		const ledger = yield* SubmissionLedger;
-		const host = yield* admitReady(threadId, "joined-settle-host", { work: "host" });
-		const queued = yield* admitReady(threadId, "joined-settle-2", { queued: 2 });
-		const hostClaim = yield* expectSome("the host claim", yield* claimLane(threadId, PRODUCER_A));
-		const claims = yield* ledger.claimJoining(ClaimJoiningRequest.make({
-			threadId,
-			hostSubmissionId: host.submissionId,
-			ownershipToken: hostClaim.ownershipToken,
-			maxCount: 1
-		}));
-		yield* ensure(claims.length === 1 && claims[0]?.submissionId === queued.submissionId, "The queued Submission must join the host's contiguous prefix");
-		const joiningReservation = yield* settlementReservation({
-			submissionId: queued.submissionId,
-			ownershipToken: BOGUS_TOKEN,
-			receiptId: queued.receiptId,
-			outcome: "completed"
-		});
-		const fenced = yield* expectFailure("reserving a joining Submission's settlement without lane ownership", ledger.reserveSettlement(joiningReservation));
-		yield* ensure(isOwnershipLost(fenced), "A joining Submission's settlement reservation must stay ownership-fenced");
-		yield* ledger.markJoined(MarkJoinedRequest.make({
-			submissionId: queued.submissionId,
-			ownershipToken: hostClaim.ownershipToken,
-			recordId: submissionInputRecordId(queued.submissionId),
-			sequence: decodeSequence(7)
-		}));
-		const joinedReservation = yield* settlementReservation({
-			submissionId: queued.submissionId,
-			ownershipToken: BOGUS_TOKEN,
-			receiptId: queued.receiptId,
-			outcome: "completed"
-		});
-		yield* ledger.reserveSettlement(joinedReservation);
-		yield* ensure((yield* ledger.finalizeSettlement(SettlementFinalization.make({
-			submissionId: queued.submissionId,
-			settlementId: submissionSettlementId(queued.submissionId)
-		}))).outcome === "completed", "The joined settlement must finalize with the reserved outcome");
-		const settled = yield* expectSome("lookup after the joined settlement", yield* lookupById(queued.submissionId));
-		yield* ensure(settled.state === "settled" && settled.settledOutcome === "completed", "The joined Submission must settle terminally");
-	})),
-	conformanceCase("replays an identical child reservation and rejects a divergent allocation digest", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
-		const threadId = decodeThreadId("ledger-conformance-child-reserve");
-		const ledger = yield* SubmissionLedger;
-		const parent = yield* admitReady(threadId, "child-reserve-parent", { work: "parent" });
-		const claim = yield* expectSome("the parent claim", yield* claimLane(threadId, PRODUCER_A));
-		const allocation = {
-			turns: 4,
-			toolCalls: 8
-		};
-		const allocationDigest = yield* digestJson(allocation);
-		const requestFields = {
-			reservationId: decodeChildReservationId("child-reservation:run-reserve:call-1"),
-			parentSubmissionId: parent.submissionId,
-			parentToolCallId: decodeToolCallId("call-child-reserve"),
-			ownershipToken: claim.ownershipToken,
-			allocation,
-			allocationDigest
-		};
-		const request = ChildBudgetReservationRequest.make(requestFields);
-		const first = yield* ledger.reserveChildBudget(request);
-		yield* ensure(!first.replayed && first.reservation.status === "reserved" && first.reservation.allocationDigest === allocationDigest && first.reservation.childSubmissionId === void 0 && persistedJsonEquivalent(first.reservation.allocation, allocation), "The first reservation must create a reserved row carrying the exact allocation");
-		yield* TestClock.adjust("1 second");
-		const replayed = yield* ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
-			...requestFields,
-			allocation: {
-				toolCalls: 8,
-				turns: 4
-			}
-		}));
-		yield* ensure(replayed.replayed && replayed.reservation.status === "reserved" && persistedJsonEquivalent(replayed.reservation.allocation, allocation) && sameInstant(replayed.reservation.reservedAt, first.reservation.reservedAt), "An identical reservation must replay the stored row unchanged");
-		const divergentAllocation = {
-			turns: 64,
-			toolCalls: 8
-		};
-		const divergent = yield* expectFailure("a divergent allocation for the same reservation id", ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
-			...requestFields,
-			allocation: divergentAllocation,
-			allocationDigest: yield* digestJson(divergentAllocation)
-		})));
-		yield* ensure(isChildReservationConflict(divergent) && divergent.status === "reserved", "A divergent allocation must conflict with the recorded reservation");
-		const secondId = yield* expectFailure("a second reservation id for the same parent Tool Call", ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
-			...requestFields,
-			reservationId: decodeChildReservationId("child-reservation:run-reserve:call-1-other")
-		})));
-		yield* ensure(isChildReservationConflict(secondId), "One parent Tool Call must never own two reservations");
-		const snapshot = yield* recoverySnapshot(parent.submissionId);
-		yield* ensure(snapshot.childReservations.length === 1 && snapshot.childReservations[0].reservationId === request.reservationId && snapshot.childReservations[0].status === "reserved" && snapshot.childAttachments.length === 0, "The parent recovery snapshot must expose the reservation before any attachment");
-	})),
-	conformanceCase("a stale parent token cannot transition a child reservation", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
-		const threadId = decodeThreadId("ledger-conformance-child-fence");
-		const childLane = decodeThreadId("ledger-conformance-child-fence-child");
-		const ledger = yield* SubmissionLedger;
-		const parent = yield* admitReady(threadId, "child-fence-parent", { work: "parent" });
-		const child = yield* admitReady(childLane, "child-fence-child", { work: "child" });
-		const firstClaim = yield* expectSome("the first parent claim", yield* claimLane(threadId, PRODUCER_A));
-		const allocation = { turns: 2 };
-		const allocationDigest = yield* digestJson(allocation);
-		const requestFields = {
-			reservationId: decodeChildReservationId("child-reservation:run-fence:call-1"),
-			parentSubmissionId: parent.submissionId,
-			parentToolCallId: decodeToolCallId("call-child-fence"),
-			ownershipToken: BOGUS_TOKEN,
-			allocation,
-			allocationDigest
-		};
-		const request = ChildBudgetReservationRequest.make(requestFields);
-		const foreign = yield* expectFailure("creating a reservation without owning the parent lane", ledger.reserveChildBudget(request));
-		yield* ensure(isOwnershipLost(foreign), "Reservation creation must be fenced by the parent's live ownership token");
-		yield* ensure((yield* recoverySnapshot(parent.submissionId)).childReservations.length === 0, "A fenced reservation attempt must leave no row behind");
-		yield* ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
-			...requestFields,
-			ownershipToken: firstClaim.ownershipToken
-		}));
-		yield* ledger.releaseOwnership(ReleaseOwnershipRequest.make({
-			submissionId: parent.submissionId,
-			ownershipToken: firstClaim.ownershipToken
-		}));
-		const reclaim = yield* expectSome("the replacement parent claim", yield* claimLane(threadId, PRODUCER_B));
-		yield* ensure(reclaim.producerEpoch > firstClaim.producerEpoch, "The replacement claim must fence the stale parent Attempt");
-		const staleAttach = yield* expectFailure("attaching a child with the superseded parent token", ledger.attachChildToReservation(AttachChildToReservationRequest.make({
-			reservationId: request.reservationId,
-			ownershipToken: firstClaim.ownershipToken,
-			childSubmissionId: child.submissionId
-		})));
-		yield* ensure(isOwnershipLost(staleAttach), "A superseded parent token must not attach a child");
-		const staleCreate = yield* expectFailure("creating a second-call reservation with the superseded parent token", ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
-			...requestFields,
-			reservationId: decodeChildReservationId("child-reservation:run-fence:call-2"),
-			parentToolCallId: decodeToolCallId("call-child-fence-second"),
-			ownershipToken: firstClaim.ownershipToken
-		})));
-		yield* ensure(isOwnershipLost(staleCreate), "A superseded parent token must not create new reservation state");
-		const staleReplay = yield* ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
-			...requestFields,
-			ownershipToken: firstClaim.ownershipToken
-		}));
-		yield* ensure(staleReplay.replayed && staleReplay.reservation.status === "reserved", "An identical reservation replay must return the recorded row even from a stale caller");
-		yield* ensure((yield* ledger.attachChildToReservation(AttachChildToReservationRequest.make({
-			reservationId: request.reservationId,
-			ownershipToken: reclaim.ownershipToken,
-			childSubmissionId: child.submissionId
-		}))).childSubmissionId === child.submissionId, "The live replacement token must attach the child");
-	})),
-	conformanceCase("attachChildToReservation is idempotent and rejects a divergent child", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
-		const threadId = decodeThreadId("ledger-conformance-child-attach");
-		const childLane = decodeThreadId("ledger-conformance-child-attach-child");
-		const ledger = yield* SubmissionLedger;
-		const parent = yield* admitReady(threadId, "child-attach-parent", { work: "parent" });
-		const child = yield* admitReady(childLane, "child-attach-child", { queued: 1 });
-		const otherChild = yield* admitReady(childLane, "child-attach-other", { queued: 2 });
-		const claim = yield* expectSome("the parent claim", yield* claimLane(threadId, PRODUCER_A));
-		const allocation = { turns: 3 };
-		const reservationId = decodeChildReservationId("child-reservation:run-attach:call-1");
-		yield* ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
-			reservationId,
-			parentSubmissionId: parent.submissionId,
-			parentToolCallId: decodeToolCallId("call-child-attach"),
-			ownershipToken: claim.ownershipToken,
-			allocation,
-			allocationDigest: yield* digestJson(allocation)
-		}));
-		const unknownReservation = yield* expectFailure("attaching to a reservation that was never created", ledger.attachChildToReservation(AttachChildToReservationRequest.make({
-			reservationId: decodeChildReservationId("child-reservation:run-attach:missing"),
-			ownershipToken: claim.ownershipToken,
-			childSubmissionId: child.submissionId
-		})));
-		yield* ensure(isLedgerError(unknownReservation), "Attaching to an unknown reservation must fail as a ledger error");
-		const attached = yield* ledger.attachChildToReservation(AttachChildToReservationRequest.make({
-			reservationId,
-			ownershipToken: claim.ownershipToken,
-			childSubmissionId: child.submissionId
-		}));
-		yield* ensure(attached.childSubmissionId === child.submissionId && attached.status === "reserved", "Attaching must record the child on the reservation row");
-		yield* ensure((yield* ledger.attachChildToReservation(AttachChildToReservationRequest.make({
-			reservationId,
-			ownershipToken: claim.ownershipToken,
-			childSubmissionId: child.submissionId
-		}))).childSubmissionId === child.submissionId, "Repeating the identical attachment must be a no-op");
-		const divergent = yield* expectFailure("attaching a different child to the same reservation", ledger.attachChildToReservation(AttachChildToReservationRequest.make({
-			reservationId,
-			ownershipToken: claim.ownershipToken,
-			childSubmissionId: otherChild.submissionId
-		})));
-		yield* ensure(isChildReservationConflict(divergent), "A divergent child attachment must conflict with the recorded child");
-		const snapshot = yield* recoverySnapshot(parent.submissionId);
-		yield* ensure(snapshot.childAttachments.length === 1 && snapshot.childAttachments[0].childSubmissionId === child.submissionId && snapshot.childAttachments[0].toolCallId === decodeToolCallId("call-child-attach") && snapshot.childAttachments[0].childState === "ready" && snapshot.childAttachments[0].childOutcome === void 0, "The parent recovery snapshot must expose the attachment with the child's lane state");
-	})),
-	conformanceCase("beginRelease freezes the accounting decision exactly once", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
-		const threadId = decodeThreadId("ledger-conformance-child-freeze");
-		const ledger = yield* SubmissionLedger;
-		const parent = yield* admitReady(threadId, "child-freeze-parent", { work: "parent" });
-		const claim = yield* expectSome("the parent claim", yield* claimLane(threadId, PRODUCER_A));
-		const allocation = { turns: 4 };
-		const reservationId = decodeChildReservationId("child-reservation:run-freeze:call-1");
-		yield* ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
-			reservationId,
-			parentSubmissionId: parent.submissionId,
-			parentToolCallId: decodeToolCallId("call-child-freeze"),
-			ownershipToken: claim.ownershipToken,
-			allocation,
-			allocationDigest: yield* digestJson(allocation)
-		}));
-		const accounting = {
-			consumed: { turns: 1 },
-			released: { turns: 3 }
-		};
-		const frozen = yield* ledger.beginChildBudgetRelease(BeginChildBudgetReleaseRequest.make({
-			reservationId,
-			accounting
-		}));
-		yield* ensure(frozen.status === "releasePending" && frozen.accounting !== void 0 && persistedJsonEquivalent(frozen.accounting, accounting) && frozen.releaseBeganAt !== void 0, "The first beginRelease must freeze the accounting and move to releasePending");
-		yield* TestClock.adjust("1 second");
-		const replayed = yield* ledger.beginChildBudgetRelease(BeginChildBudgetReleaseRequest.make({
-			reservationId,
-			accounting: {
-				released: { turns: 3 },
-				consumed: { turns: 1 }
-			}
-		}));
-		yield* ensure(replayed.status === "releasePending" && replayed.releaseBeganAt !== void 0 && frozen.releaseBeganAt !== void 0 && sameInstant(replayed.releaseBeganAt, frozen.releaseBeganAt), "Replaying the identical accounting must be a no-op with the frozen decision retained");
-		const divergent = yield* expectFailure("freezing a different accounting decision", ledger.beginChildBudgetRelease(BeginChildBudgetReleaseRequest.make({
-			reservationId,
-			accounting: {
-				consumed: { turns: 4 },
-				released: { turns: 0 }
-			}
-		})));
-		yield* ensure(isChildReservationConflict(divergent) && divergent.status === "releasePending", "A divergent accounting freeze must conflict with the frozen decision");
-		yield* ledger.releaseChildBudget(ReleaseChildBudgetRequest.make({ reservationId }));
-		const afterRelease = yield* ledger.beginChildBudgetRelease(BeginChildBudgetReleaseRequest.make({
-			reservationId,
-			accounting
-		}));
-		yield* ensure(afterRelease.status === "released" && afterRelease.accounting !== void 0 && persistedJsonEquivalent(afterRelease.accounting, accounting), "Replaying the identical accounting after release must return the released row");
-		const divergentAfterRelease = yield* expectFailure("freezing a different accounting decision after release", ledger.beginChildBudgetRelease(BeginChildBudgetReleaseRequest.make({
-			reservationId,
-			accounting: {
-				consumed: { turns: 2 },
-				released: { turns: 2 }
-			}
-		})));
-		yield* ensure(isChildReservationConflict(divergentAfterRelease) && divergentAfterRelease.status === "released", "The frozen decision must stay immutable after release");
-	})),
-	conformanceCase("release returns unused allocation exactly once", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
-		const threadId = decodeThreadId("ledger-conformance-child-release");
-		const ledger = yield* SubmissionLedger;
-		const parent = yield* admitReady(threadId, "child-release-parent", { work: "parent" });
-		const claim = yield* expectSome("the parent claim", yield* claimLane(threadId, PRODUCER_A));
-		const allocation = { turns: 4 };
-		const reservationId = decodeChildReservationId("child-reservation:run-release:call-1");
-		yield* ledger.reserveChildBudget(ChildBudgetReservationRequest.make({
-			reservationId,
-			parentSubmissionId: parent.submissionId,
-			parentToolCallId: decodeToolCallId("call-child-release"),
-			ownershipToken: claim.ownershipToken,
-			allocation,
-			allocationDigest: yield* digestJson(allocation)
-		}));
-		const early = yield* expectFailure("releasing before the accounting decision is frozen", ledger.releaseChildBudget(ReleaseChildBudgetRequest.make({ reservationId })));
-		yield* ensure(isChildReservationConflict(early) && early.status === "reserved", "Release must never skip the releasePending freeze");
-		yield* ledger.beginChildBudgetRelease(BeginChildBudgetReleaseRequest.make({
-			reservationId,
-			accounting: {
-				consumed: {},
-				released: { turns: 4 }
-			}
-		}));
-		const released = yield* ledger.releaseChildBudget(ReleaseChildBudgetRequest.make({ reservationId }));
-		yield* ensure(released.status === "released" && released.releasedAt !== void 0, "Release must transition releasePending to released");
-		yield* TestClock.adjust("1 second");
-		const replayed = yield* ledger.releaseChildBudget(ReleaseChildBudgetRequest.make({ reservationId }));
-		yield* ensure(replayed.status === "released" && replayed.releasedAt !== void 0 && released.releasedAt !== void 0 && sameInstant(replayed.releasedAt, released.releasedAt), "Replaying the release must return the stored row unchanged — never applied twice");
-		const snapshot = yield* recoverySnapshot(parent.submissionId);
-		yield* ensure(snapshot.childReservations.length === 1 && snapshot.childReservations[0].status === "released", "The recovery snapshot must expose the released reservation");
-	})),
-	conformanceCase("recordChildSettled accepts canonical terminalizing prefixes and wakes only when all are covered", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
-		const parentLane = decodeThreadId("ledger-conformance-child-wake");
-		const childLaneA = decodeThreadId("ledger-conformance-child-wake-a");
-		const childLaneB = decodeThreadId("ledger-conformance-child-wake-b");
-		const ledger = yield* SubmissionLedger;
-		const parent = yield* admitReady(parentLane, "child-wake-parent", { work: "parent" });
-		const childA = yield* admitReady(childLaneA, "child-wake-a", { child: "a" });
-		const childB = yield* admitReady(childLaneB, "child-wake-b", { child: "b" });
-		const parentClaim = yield* expectSome("the parent claim", yield* claimLane(parentLane, PRODUCER_A));
-		yield* ensure((yield* ledger.suspend(SuspendRequest.make({
-			submissionId: parent.submissionId,
-			ownershipToken: parentClaim.ownershipToken,
-			reason: WaitingForChildSuspension.make({ children: [WaitingChild.make({
-				toolCallId: decodeToolCallId("call-wake-a"),
-				childSubmissionId: childA.submissionId
-			}), WaitingChild.make({
-				toolCallId: decodeToolCallId("call-wake-b"),
-				childSubmissionId: childB.submissionId
-			})] })
-		}))) === "suspended", "Unsettled children must suspend the parent durably");
-		const ended = yield* expectFailure("renewing after the waitingForChild suspension ended the ownership period", ledger.renewOwnership(RenewOwnershipRequest.make({
-			submissionId: parent.submissionId,
-			ownershipToken: parentClaim.ownershipToken
-		})));
-		yield* ensure(isOwnershipLost(ended), "waitingForChild must end the ownership period without settling (SUB-030)");
-		yield* ensure(Option.isNone(yield* claimLane(parentLane, PRODUCER_B)), "A waitingForChild head must produce no claim and consume no worker permit");
-		const childClaimA = yield* expectSome("the first child claim", yield* claimLane(childLaneA, PRODUCER_A));
-		const childReservationA = yield* settlementReservation({
-			submissionId: childA.submissionId,
-			ownershipToken: childClaimA.ownershipToken,
-			receiptId: childA.receiptId,
-			outcome: "completed"
-		});
-		yield* ledger.reserveSettlement(childReservationA);
-		yield* ensure((yield* ledger.recordChildSettled(ChildSettledNotification.make({
-			parentSubmissionId: parent.submissionId,
-			childSubmissionId: childA.submissionId
-		}))) === "still-waiting", "A settlement notification must not wake the parent while a listed child is unsettled");
-		yield* ledger.finalizeSettlement(SettlementFinalization.make({
-			submissionId: childA.submissionId,
-			settlementId: childReservationA.settlementId
-		}));
-		yield* ensure((yield* expectSome("lookup while one child is outstanding", yield* lookupById(parent.submissionId))).state === "suspended" && Option.isNone(yield* claimLane(parentLane, PRODUCER_B)), "The parent lane must stay suspended until every listed child settled");
-		const childClaimB = yield* expectSome("the second child claim", yield* claimLane(childLaneB, PRODUCER_A));
-		const childReservationB = yield* settlementReservation({
-			submissionId: childB.submissionId,
-			ownershipToken: childClaimB.ownershipToken,
-			receiptId: childB.receiptId,
-			outcome: "completed"
-		});
-		yield* ledger.reserveSettlement(childReservationB);
-		yield* ensure((yield* ledger.recordChildSettled(ChildSettledNotification.make({
-			parentSubmissionId: parent.submissionId,
-			childSubmissionId: childB.submissionId
-		}))) === "woken", "The covering canonical settlement prefix must wake the parent before child finalization");
-		yield* ledger.finalizeSettlement(SettlementFinalization.make({
-			submissionId: childB.submissionId,
-			settlementId: childReservationB.settlementId
-		}));
-		yield* ensure((yield* expectSome("lookup after the covering settlement", yield* lookupById(parent.submissionId))).state === "input-applied", "The woken parent must transition suspended(WaitingForChild) to input-applied");
-		yield* ensure((yield* recoverySnapshot(parent.submissionId)).suspension === void 0, "Waking must clear the durable suspension");
-		yield* ensure((yield* ledger.recordChildSettled(ChildSettledNotification.make({
-			parentSubmissionId: parent.submissionId,
-			childSubmissionId: childA.submissionId
-		}))) === "not-waiting", "Replaying a notification after the wake must be an idempotent no-op");
-		const reclaim = yield* expectSome("the parent claim after waking", yield* claimLane(parentLane, PRODUCER_B));
-		yield* ensure(reclaim.submissionId === parent.submissionId && reclaim.producerEpoch > parentClaim.producerEpoch, "The woken lane must grant a fresh fenced Attempt");
-		yield* settleClaimed(parent, reclaim.ownershipToken);
-		yield* ensure((yield* ledger.recordChildSettled(ChildSettledNotification.make({
-			parentSubmissionId: parent.submissionId,
-			childSubmissionId: childB.submissionId
-		}))) === "not-waiting", "A notification for a settled parent must answer not-waiting");
-	})),
-	conformanceCase("suspend returns resume-immediately when children already settled", ({ ensure, expectSome }) => Effect.gen(function* () {
-		const parentLane = decodeThreadId("ledger-conformance-child-raced");
-		const childLaneA = decodeThreadId("ledger-conformance-child-raced-a");
-		const childLaneB = decodeThreadId("ledger-conformance-child-raced-b");
-		const ledger = yield* SubmissionLedger;
-		const settledChild = yield* admitReady(childLaneA, "child-raced-a", { child: "a" });
-		const settledClaim = yield* expectSome("the settled child's claim", yield* claimLane(childLaneA, PRODUCER_A));
-		yield* settleClaimed(settledChild, settledClaim.ownershipToken);
-		const pendingChild = yield* admitReady(childLaneB, "child-raced-b", { child: "b" });
-		const parent = yield* admitReady(parentLane, "child-raced-parent", { work: "parent" });
-		const parentClaim = yield* expectSome("the parent claim", yield* claimLane(parentLane, PRODUCER_A));
-		yield* ensure((yield* ledger.suspend(SuspendRequest.make({
-			submissionId: parent.submissionId,
-			ownershipToken: parentClaim.ownershipToken,
-			reason: WaitingForChildSuspension.make({ children: [WaitingChild.make({
-				toolCallId: decodeToolCallId("call-raced-a"),
-				childSubmissionId: settledChild.submissionId
-			})] })
-		}))) === "resume-immediately", "A suspend listing only settled children must resume immediately");
-		yield* ensure((yield* expectSome("lookup after the immediate resume", yield* lookupById(parent.submissionId))).state === "running", "An immediate resume must not transition the parent to suspended");
-		yield* ledger.renewOwnership(RenewOwnershipRequest.make({
-			submissionId: parent.submissionId,
-			ownershipToken: parentClaim.ownershipToken
-		}));
-		yield* ensure((yield* ledger.suspend(SuspendRequest.make({
-			submissionId: parent.submissionId,
-			ownershipToken: parentClaim.ownershipToken,
-			reason: WaitingForChildSuspension.make({ children: [WaitingChild.make({
-				toolCallId: decodeToolCallId("call-raced-a"),
-				childSubmissionId: settledChild.submissionId
-			}), WaitingChild.make({
-				toolCallId: decodeToolCallId("call-raced-b"),
-				childSubmissionId: pendingChild.submissionId
-			})] })
-		}))) === "suspended", "One unsettled listed child must suspend the parent durably");
-		const snapshot = yield* recoverySnapshot(parent.submissionId);
-		yield* ensure(snapshot.suspension !== void 0 && snapshot.suspension.reason._tag === "WaitingForChild" && snapshot.suspension.reason.children.length === 2, "The recovery snapshot must expose the WaitingForChild reason with its children");
-	})),
-	conformanceCase("admit records and replays parent linkage", ({ ensure, expectFailure, expectSome }) => Effect.gen(function* () {
-		const parentLane = decodeThreadId("ledger-conformance-linkage");
-		const childLane = decodeThreadId("ledger-conformance-linkage-child");
-		const ledger = yield* SubmissionLedger;
-		const parent = yield* admitReady(parentLane, "linkage-parent", { work: "parent" });
-		const linkage = ParentLinkage.make({
-			parentSubmissionId: parent.submissionId,
-			parentToolCallId: decodeToolCallId("call-linkage")
-		});
-		const request = yield* admissionRequest(childLane, "linkage-child-key", { task: "research" }, linkage);
-		const admitted = yield* ledger.admit(request);
-		yield* ensure(!admitted.replayed, "The first linked admission must create the child");
-		const byId = yield* expectSome("lookup of the linked child", yield* lookupById(admitted.submissionId));
-		yield* ensure(byId.parentLinkage !== void 0 && byId.parentLinkage.parentSubmissionId === parent.submissionId && byId.parentLinkage.parentToolCallId === linkage.parentToolCallId, "The child snapshot must expose its immutable parent linkage");
-		const childSnapshot = yield* recoverySnapshot(admitted.submissionId);
-		yield* ensure(childSnapshot.parentLinkage !== void 0 && childSnapshot.parentLinkage.parentSubmissionId === parent.submissionId, "The child recovery snapshot must expose its parent linkage");
-		const replayed = yield* ledger.admit(request);
-		yield* ensure(replayed.replayed && replayed.submissionId === admitted.submissionId && replayed.receiptId === admitted.receiptId, "An identical linked admission must replay the original identities (SUB-016)");
-		const divergentLinkage = yield* expectFailure("replaying the admission with a different parent Tool Call", ledger.admit(yield* admissionRequest(childLane, "linkage-child-key", { task: "research" }, ParentLinkage.make({
-			parentSubmissionId: parent.submissionId,
-			parentToolCallId: decodeToolCallId("call-linkage-other")
-		}))));
-		yield* ensure(isAdmissionConflict(divergentLinkage), "A divergent parent linkage must conflict even when the input digest matches");
-		const droppedLinkage = yield* expectFailure("replaying the admission without its parent linkage", ledger.admit(yield* admissionRequest(childLane, "linkage-child-key", { task: "research" })));
-		yield* ensure(isAdmissionConflict(droppedLinkage), "Dropping the recorded linkage on replay must conflict");
-		const plain = yield* ledger.admit(yield* admissionRequest(childLane, "linkage-plain-key", { task: "plain" }));
-		const addedLinkage = yield* expectFailure("replaying an unlinked admission with a parent linkage", ledger.admit(yield* admissionRequest(childLane, "linkage-plain-key", { task: "plain" }, linkage)));
-		yield* ensure(isAdmissionConflict(addedLinkage), "Adding a linkage to an unlinked admission on replay must conflict");
-		yield* ensure((yield* expectSome("lookup of the unlinked Submission", yield* lookupById(plain.submissionId))).parentLinkage === void 0, "An unlinked Submission must expose no parent linkage");
-	})),
-	conformanceCase("resolveAdmission distinguishes notAdmitted from admitted authoritatively", ({ ensure, expectSome }) => Effect.gen(function* () {
-		const threadId = decodeThreadId("ledger-conformance-resolve");
-		const ledger = yield* SubmissionLedger;
-		const key = SubmissionLookupByKey.make({
-			threadId,
-			principal: CONFORMANCE_PRINCIPAL,
-			idempotencyKey: decodeIdempotencyKey("resolve-key-1")
-		});
-		yield* ensure((yield* ledger.resolveAdmission(key))._tag === "NotAdmitted", "The authoritative store must prove absence before admission (SUB-031)");
-		const admitted = yield* ledger.admit(yield* admissionRequest(threadId, "resolve-key-1", { work: "resolve" }));
-		const after = yield* ledger.resolveAdmission(key);
-		yield* ensure(after._tag === "Admitted" && after.submission.submissionId === admitted.submissionId && after.submission.receiptId === admitted.receiptId && after.submission.state === "admitted", "An admitted key must resolve to the full authoritative snapshot");
-		yield* ensure((yield* ledger.resolveAdmission(SubmissionLookupByKey.make({
-			threadId,
-			principal: OTHER_PRINCIPAL,
-			idempotencyKey: decodeIdempotencyKey("resolve-key-1")
-		})))._tag === "NotAdmitted", "Admission resolution must stay scoped to the requesting principal");
-		yield* ledger.markReady(MarkReadyRequest.make({ submissionId: admitted.submissionId }));
-		const claim = yield* expectSome("the claim before terminal resolution", yield* claimLane(threadId, PRODUCER_A));
-		yield* settleClaimed(admitted, claim.ownershipToken);
-		const settled = yield* ledger.resolveAdmission(key);
-		yield* ensure(settled._tag === "Admitted" && settled.submission.state === "settled" && settled.submission.settledOutcome === "completed", "A settled Submission still resolves as admitted — terminality never becomes absence");
-	})),
-	conformanceCase("reserveSettlement authorizes an aborted, unowned queued settlement by its durable intent", ({ ensure, expectFailure }) => Effect.gen(function* () {
-		const threadId = decodeThreadId("ledger-conformance-queued-abort");
-		const ledger = yield* SubmissionLedger;
-		const head = yield* admitReady(threadId, "queued-abort-head", { work: "head" });
-		const second = yield* admitReady(threadId, "queued-abort-2", { queued: 2 });
-		const third = yield* admitReady(threadId, "queued-abort-3", { queued: 3 });
-		yield* ledger.requestAbort(AbortCommand.make({
-			submissionId: second.submissionId,
-			author: "operator",
-			reason: "cancelled while queued"
-		}));
-		const unaborted = yield* expectFailure("reserving an aborted settlement for a queued row without an abort intent", settlementReservation({
-			submissionId: third.submissionId,
-			ownershipToken: BOGUS_TOKEN,
-			receiptId: third.receiptId,
-			outcome: "aborted"
-		}).pipe(Effect.flatMap((reservation) => ledger.reserveSettlement(reservation))));
-		yield* ensure(isOwnershipLost(unaborted), "A queued reservation without a durable abort intent must stay fenced (OwnershipLost)");
-		const wrongOutcome = yield* expectFailure("reserving a completed settlement for the aborted queued row", settlementReservation({
-			submissionId: second.submissionId,
-			ownershipToken: BOGUS_TOKEN,
-			receiptId: second.receiptId,
-			outcome: "completed",
-			result: { fabricated: true }
-		}).pipe(Effect.flatMap((reservation) => ledger.reserveSettlement(reservation))));
-		yield* ensure(isOwnershipLost(wrongOutcome), "An abort intent must never authorize a non-aborted settlement outcome");
-		const reservation = yield* settlementReservation({
-			submissionId: second.submissionId,
-			ownershipToken: BOGUS_TOKEN,
-			receiptId: second.receiptId,
-			outcome: "aborted"
-		});
-		const reserved = yield* ledger.reserveSettlement(reservation);
-		yield* ensure(reserved.replayed === false && reserved.outcome === "aborted", "The abort intent must authorize the aborted reservation without lane ownership");
-		yield* ensure((yield* ledger.reserveSettlement(reservation)).replayed === true, "Replaying the identical aborted reservation must short-circuit idempotently");
-		yield* ledger.finalizeSettlement(SettlementFinalization.make({
-			submissionId: second.submissionId,
-			settlementId: submissionSettlementId(second.submissionId)
-		}));
-		const settled = yield* recoverySnapshot(second.submissionId);
-		yield* ensure(settled.submission.state === "settled" && settled.submission.settledOutcome === "aborted", "The aborted queued Submission must settle while the head is still unsettled");
-		yield* ensure((yield* recoverySnapshot(head.submissionId)).submission.state === "ready", "Settling the aborted queued row must not disturb the unclaimed head");
-	})),
-	conformanceCase("claimJoining treats an aborted-settled row as a non-gap", ({ ensure, expectSome }) => Effect.gen(function* () {
-		const threadId = decodeThreadId("ledger-conformance-aborted-non-gap");
-		const ledger = yield* SubmissionLedger;
-		const host = yield* admitReady(threadId, "aborted-gap-host", { work: "host" });
-		const second = yield* admitReady(threadId, "aborted-gap-2", { queued: 2 });
-		const third = yield* admitReady(threadId, "aborted-gap-3", { queued: 3 });
-		yield* ledger.requestAbort(AbortCommand.make({
-			submissionId: second.submissionId,
-			author: "operator",
-			reason: "cancelled while queued"
-		}));
-		const reservation = yield* settlementReservation({
-			submissionId: second.submissionId,
-			ownershipToken: BOGUS_TOKEN,
-			receiptId: second.receiptId,
-			outcome: "aborted"
-		});
-		yield* ledger.reserveSettlement(reservation);
-		yield* ledger.finalizeSettlement(SettlementFinalization.make({
-			submissionId: second.submissionId,
-			settlementId: submissionSettlementId(second.submissionId)
-		}));
-		const hostClaim = yield* expectSome("the host claim", yield* claimLane(threadId, PRODUCER_A));
-		yield* ensure(hostClaim.submissionId === host.submissionId, "The host must head the lane (the aborted-settled row is out of the queue)");
-		const claims = yield* ledger.claimJoining(ClaimJoiningRequest.make({
-			threadId,
-			hostSubmissionId: host.submissionId,
-			ownershipToken: hostClaim.ownershipToken,
-			maxCount: 8
-		}));
-		yield* ensure(claims.length === 1 && claims[0].submissionId === third.submissionId, "The joining prefix must skip the aborted-settled row and claim the later ready work");
-		const settled = yield* recoverySnapshot(second.submissionId);
-		yield* ensure(settled.submission.state === "settled" && settled.submission.settledOutcome === "aborted", "Walking the prefix must never disturb the aborted-settled row");
-	}))
+	suspendResumesImmediatelyWhenDecided,
+	joinedSettlementLinkageAuthority,
+	childReservationIdempotency,
+	childReservationFencing,
+	attachChildIdempotency,
+	beginReleaseFreezesAccountingOnce,
+	releaseAppliedExactlyOnce,
+	recordChildSettledWake,
+	suspendResumesImmediatelyForSettledChildren,
+	admissionParentLinkage,
+	resolveAdmissionAuthority,
+	queuedAbortSettlementAuthority,
+	abortedSettledRowIsNotAJoiningGap
 ];
 //#endregion
 export { SubmissionLedgerConformanceViolation, submissionLedgerConformanceCases };