@effect-agent/storage-memory 0.1.0-beta.9 → 0.1.0-beta.91

package/dist/index.mjs

@@ -1,1298 +1,7 @@
-import { AttemptId, ConversationId, ReceiptId, SubmissionId } from "@effect-agent/core";
-import { AbortCommand, AbortIntent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, ConversationExport, ConversationExportRequest, ConversationMaterialization, ConversationNotMaterialized, ConversationObservation, ConversationRead, ConversationStore, ConversationStoreError, ConversationTail, ConversationTailRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, OwnershipToken, ProducerEpoch, QueueSequence, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, Settlement, SettlementConflict, SettlementFinalization, SettlementReservation, SettlementReservationSnapshot, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SuspendRequest, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, digestCanonicalBatch } from "@effect-agent/session";
-import { Clock, Crypto, DateTime, Duration, Effect, Encoding, Layer, Option, PubSub, Ref, Schema, Stream } from "effect";
-//#region src/memory-ledger.ts
-const MAX_SUBMISSIONS = 65536;
-/**
-* Lifecycle ordering used to advance-but-never-regress the operational state marker: a reclaimed
-* Attempt must not erase progress markers (input-applied, terminalizing) that an earlier Attempt
-* already committed.
-*/
-const STATE_RANK = {
-	admitted: 0,
-	ready: 1,
-	joining: 2,
-	joined: 3,
-	running: 4,
-	"input-applied": 5,
-	suspended: 6,
-	unknown: 7,
-	terminalizing: 8,
-	settled: 9
-};
-/**
-* States in which `claim` never grants the head: the lane is host-owned (`joining`/`joined`)
-* or durably blocked (`suspended`/`unknown`) rather than worker-claimable.
-*/
-const BLOCKED_HEAD_STATES = /* @__PURE__ */ new Set([
-	"joining",
-	"joined",
-	"suspended",
-	"unknown"
-]);
-const failure = (error) => ({
-	_tag: "failure",
-	error
-});
-const success = (value) => ({
-	_tag: "success",
-	value
-});
-const ledgerError = (operation, message, cause) => cause === void 0 ? LedgerError.make({
-	operation,
-	message
-}) : LedgerError.make({
-	operation,
-	message,
-	cause
-});
-const validate$1 = Effect.fn("MemorySubmissionLedger.validate")((schema, operation, value) => Schema.encodeUnknownEffect(schema)(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(schema)), Effect.mapError((error) => ledgerError(operation, `Invalid ${operation} request`, error))));
-const decodeSubmissionId = Schema.decodeSync(SubmissionId);
-const decodeReceiptId = Schema.decodeSync(ReceiptId);
-const decodeAttemptId = Schema.decodeSync(AttemptId);
-const decodeOwnershipToken = Schema.decodeSync(OwnershipToken);
-const decodeQueueSequence = Schema.decodeSync(QueueSequence);
-const decodeProducerEpoch = Schema.decodeSync(ProducerEpoch);
-const utc = (millis) => DateTime.toUtc(DateTime.makeUnsafe(millis));
-const admissionKey = (conversationId, principal, idempotencyKey) => `${conversationId}\u001f${principal}\u001f${idempotencyKey}`;
-const toSnapshot = (row) => SubmissionSnapshot.make({
-	submissionId: row.submissionId,
-	conversationId: row.conversationId,
-	queueSequence: row.queueSequence,
-	principal: row.principal,
-	idempotencyKey: row.idempotencyKey,
-	agentId: row.agentId,
-	agentDigests: row.agentDigests,
-	deploymentId: row.deploymentId,
-	inputPayload: row.inputPayload,
-	inputDigest: row.inputDigest,
-	receiptId: row.receiptId,
-	state: row.state,
-	createdAt: utc(row.createdAtMillis),
-	...row.settledOutcome === void 0 ? {} : { settledOutcome: row.settledOutcome },
-	...row.readyAtMillis === void 0 ? {} : { readyAt: utc(row.readyAtMillis) },
-	...row.parentLinkage === void 0 ? {} : { parentLinkage: row.parentLinkage }
-});
-const toReservationSnapshot = (row) => ChildBudgetReservationSnapshot.make({
-	reservationId: row.reservationId,
-	parentSubmissionId: row.parentSubmissionId,
-	parentToolCallId: row.parentToolCallId,
-	status: row.status,
-	allocation: row.allocation,
-	allocationDigest: row.allocationDigest,
-	reservedAt: utc(row.reservedAtMillis),
-	...row.childSubmissionId === void 0 ? {} : { childSubmissionId: row.childSubmissionId },
-	...row.accounting === void 0 ? {} : { accounting: row.accounting },
-	...row.releaseBeganAtMillis === void 0 ? {} : { releaseBeganAt: utc(row.releaseBeganAtMillis) },
-	...row.releasedAtMillis === void 0 ? {} : { releasedAt: utc(row.releasedAtMillis) }
-});
-/** Linkage equality: both absent, or both present naming the same parent Tool Call. */
-const sameParentLinkage = (left, right) => left === void 0 ? right === void 0 : right !== void 0 && left.parentSubmissionId === right.parentSubmissionId && left.parentToolCallId === right.parentToolCallId;
-const laneEpoch = (state, conversationId) => state.lanes.get(conversationId)?.producerEpoch ?? 0;
-const ownershipLost = (state, stored) => OwnershipLost.make({
-	submissionId: stored.row.submissionId,
-	actualEpoch: decodeProducerEpoch(laneEpoch(state, stored.row.conversationId))
-});
-/** The presented token owns the lane only while it matches the live ownership record. */
-const ownsLane = (stored, ownershipToken) => stored.ownership !== void 0 && stored.ownership.ownershipToken === ownershipToken;
-const withSubmission = (state, stored) => ({
-	...state,
-	submissions: new Map(state.submissions).set(stored.row.submissionId, stored)
-});
-const withChildReservation = (state, reservation) => ({
-	...state,
-	childReservations: new Map(state.childReservations).set(reservation.reservationId, reservation)
-});
-const findHead = (state, conversationId) => {
-	let head;
-	for (const stored of state.submissions.values()) {
-		if (stored.row.conversationId !== conversationId || stored.row.state === "settled") continue;
-		if (head === void 0 || stored.row.queueSequence < head.row.queueSequence) head = stored;
-	}
-	return head;
-};
-/**
-* Reference in-memory SubmissionLedger. It implements the full port contract — atomic idempotent
-* admission, FIFO-head claims, producer-epoch fencing, Clock-driven ownership leases, idempotent
-* settlement reservation/finalization, and durable abort intent — with every transition applied
-* as one atomic `Ref.modify`, but its state does not survive the process (`non-durable`).
-*
-* Adapter-specific semantics within the port's latitude:
-*
-* - Time comes exclusively from the Effect `Clock` service, so `TestClock` drives lease expiry
-*   deterministically; no wall clock is consulted.
-* - The ownership lease is pinned to `DEFAULT_OWNERSHIP_LEASE_DURATION` (D5); durable adapters
-*   own the configuration seam.
-* - A live lease blocks claims from other producers only: the same `producerId` may reclaim its
-*   own live lease (restart recovery), which supersedes and fences the prior Attempt's token.
-* - Claiming advances `ready` to `running` and otherwise preserves the recorded state, so
-*   progress markers from an earlier Attempt survive a reclaim.
-* - `renewOwnership` keeps the token stable (the port allows rotation); a replayed admission
-*   reports the Submission's current state alongside the original identities.
-* - `claimJoining` walks the strictly-later queue: rows already `joining`/`joined` to the
-*   SAME host extend the claimed prefix and are skipped, and an aborted-settled row is a
-*   closed obligation that is also skipped (P7 §7(c)); any other non-`ready` row (an
-*   `admitted` gap, a non-aborted settled row, foreign-host linkage) breaks the prefix
-*   conservatively.
-* - `markJoined` verifies the token against the HOST's live ownership (the lane is
-*   host-owned), so a later host Attempt can repair a lost marker from history (DUR-016). The
-*   join marker reuses the input-applied marker: the joined input IS `input:{sid}`.
-* - `suspend` and `markUnknown` refuse when an exact settlement is already reserved
-*   (`SettlementConflict` with the reserved outcome) — DUR-011's reservation wins.
-* - `resolveAdmission` derives its answer from the single strongly consistent store, so it
-*   never answers `Indeterminate` on its own; the test-only `resolveAdmissionFault` option
-*   injects the `Indeterminate` classification so SUB-031 callers can be conformance-tested.
-* - `recordChildSettled` and `suspend(WaitingForChild)` observe child settlement directly from
-*   the child rows (single-store latitude); no separate notification marker is stored.
-*/
-const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
-	const state = yield* Ref.make({
-		submissions: /* @__PURE__ */ new Map(),
-		admissionIndex: /* @__PURE__ */ new Map(),
-		lanes: /* @__PURE__ */ new Map(),
-		childReservations: /* @__PURE__ */ new Map(),
-		mintCounter: 0
-	});
-	const leaseMillis = Duration.toMillis(DEFAULT_OWNERSHIP_LEASE_DURATION);
-	const capabilities = Effect.succeed(LedgerCapabilities.make({ durability: "non-durable" }));
-	const admit = Effect.fn("MemorySubmissionLedger.admit")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(AdmissionRequest, "admit", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const key = admissionKey(request.conversationId, request.principal, request.idempotencyKey);
-			const existingId = current.admissionIndex.get(key);
-			if (existingId !== void 0) {
-				const existing = current.submissions.get(existingId);
-				if (existing === void 0) return [failure(ledgerError("admit", "Admission index references a missing Submission")), current];
-				if (existing.row.inputDigest !== request.inputDigest || !sameParentLinkage(existing.row.parentLinkage, request.parentLinkage)) return [failure(AdmissionConflict.make({
-					conversationId: request.conversationId,
-					principal: request.principal,
-					idempotencyKey: request.idempotencyKey,
-					existingInputDigest: existing.row.inputDigest,
-					attemptedInputDigest: request.inputDigest
-				})), current];
-				return [success(AdmissionResult.make({
-					submissionId: existing.row.submissionId,
-					receiptId: existing.row.receiptId,
-					queueSequence: existing.row.queueSequence,
-					state: existing.row.state,
-					replayed: true
-				})), current];
-			}
-			if (current.submissions.size >= MAX_SUBMISSIONS) return [failure(ledgerError("admit", `In-memory submission limit ${MAX_SUBMISSIONS} exceeded`)), current];
-			const lane = current.lanes.get(request.conversationId) ?? {
-				nextQueueSequence: 1,
-				producerEpoch: 0
-			};
-			const mintCounter = current.mintCounter + 1;
-			const row = {
-				submissionId: decodeSubmissionId(`submission-memory-${mintCounter}`),
-				conversationId: request.conversationId,
-				queueSequence: decodeQueueSequence(lane.nextQueueSequence),
-				principal: request.principal,
-				idempotencyKey: request.idempotencyKey,
-				agentId: request.agentId,
-				agentDigests: request.agentDigests,
-				deploymentId: request.deploymentId,
-				inputPayload: request.inputPayload,
-				inputDigest: request.inputDigest,
-				receiptId: decodeReceiptId(`receipt-memory-${mintCounter}`),
-				state: "admitted",
-				settledOutcome: void 0,
-				createdAtMillis: nowMillis,
-				readyAtMillis: void 0,
-				parentLinkage: request.parentLinkage
-			};
-			const submissions = new Map(current.submissions).set(row.submissionId, {
-				row,
-				ownership: void 0,
-				inputApplied: void 0,
-				reservation: void 0,
-				abortIntent: void 0,
-				joinedHostSubmissionId: void 0,
-				suspension: void 0,
-				unknownMark: void 0,
-				approvalDecisions: /* @__PURE__ */ new Map(),
-				unknownResolutions: /* @__PURE__ */ new Map()
-			});
-			const admissionIndex = new Map(current.admissionIndex).set(key, row.submissionId);
-			const lanes = new Map(current.lanes).set(request.conversationId, {
-				nextQueueSequence: lane.nextQueueSequence + 1,
-				producerEpoch: lane.producerEpoch
-			});
-			return [success(AdmissionResult.make({
-				submissionId: row.submissionId,
-				receiptId: row.receiptId,
-				queueSequence: row.queueSequence,
-				state: row.state,
-				replayed: false
-			})), {
-				...current,
-				submissions,
-				admissionIndex,
-				lanes,
-				mintCounter
-			}];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const markReady = Effect.fn("MemorySubmissionLedger.markReady")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(MarkReadyRequest, "markReady", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("markReady", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.row.state !== "admitted") return [success(void 0), current];
-			return [success(void 0), withSubmission(current, {
-				...stored,
-				row: {
-					...stored.row,
-					state: "ready",
-					readyAtMillis: nowMillis
-				}
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-	}));
-	const lookup = Effect.fn("MemorySubmissionLedger.lookup")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(SubmissionLookup, "lookup", unvalidated);
-		const current = yield* Ref.get(state);
-		const submissionId = request._tag === "SubmissionLookupById" ? request.submissionId : current.admissionIndex.get(admissionKey(request.conversationId, request.principal, request.idempotencyKey));
-		const stored = submissionId === void 0 ? void 0 : current.submissions.get(submissionId);
-		return stored === void 0 ? Option.none() : Option.some(toSnapshot(stored.row));
-	}));
-	const resolveAdmission = Effect.fn("MemorySubmissionLedger.resolveAdmission")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(SubmissionLookupByKey, "resolveAdmission", unvalidated);
-		if (options.resolveAdmissionFault !== void 0) {
-			const fault = yield* options.resolveAdmissionFault;
-			if (Option.isSome(fault)) return AdmissionIndeterminate.make({ reason: fault.value });
-		}
-		const current = yield* Ref.get(state);
-		const submissionId = current.admissionIndex.get(admissionKey(request.conversationId, request.principal, request.idempotencyKey));
-		const stored = submissionId === void 0 ? void 0 : current.submissions.get(submissionId);
-		return stored === void 0 ? AdmissionNotAdmitted.make() : AdmissionAdmitted.make({ submission: toSnapshot(stored.row) });
-	}));
-	const claim = Effect.fn("MemorySubmissionLedger.claim")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(ClaimRequest, "claim", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const head = findHead(current, request.conversationId);
-			if (head === void 0) return [success(Option.none()), current];
-			if (BLOCKED_HEAD_STATES.has(head.row.state)) return [success(Option.none()), current];
-			if (head.ownership !== void 0 && head.ownership.leaseExpiresAtMillis > nowMillis && head.ownership.ownerProducerId !== request.producerId) return [success(Option.none()), current];
-			const lane = current.lanes.get(request.conversationId);
-			if (lane === void 0) return [failure(ledgerError("claim", "Claimable head without a Conversation lane")), current];
-			const producerEpoch = decodeProducerEpoch(lane.producerEpoch + 1);
-			const mintCounter = current.mintCounter + 1;
-			const ownership = {
-				attemptId: decodeAttemptId(`attempt-memory-${mintCounter}`),
-				ownershipToken: decodeOwnershipToken(`ownership-memory-${mintCounter}`),
-				producerEpoch,
-				ownerProducerId: request.producerId,
-				leaseExpiresAtMillis: nowMillis + leaseMillis
-			};
-			const row = head.row.state === "ready" ? {
-				...head.row,
-				state: "running"
-			} : head.row;
-			const next = withSubmission(current, {
-				...head,
-				row,
-				ownership
-			});
-			const lanes = new Map(next.lanes).set(request.conversationId, {
-				nextQueueSequence: lane.nextQueueSequence,
-				producerEpoch: lane.producerEpoch + 1
-			});
-			return [success(Option.some(Claim.make({
-				submissionId: row.submissionId,
-				attemptId: ownership.attemptId,
-				ownershipToken: ownership.ownershipToken,
-				producerEpoch,
-				leaseExpiresAt: utc(ownership.leaseExpiresAtMillis),
-				inputPayload: row.inputPayload
-			}))), {
-				...next,
-				lanes,
-				mintCounter
-			}];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const renewOwnership = Effect.fn("MemorySubmissionLedger.renewOwnership")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(RenewOwnershipRequest, "renewOwnership", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("renewOwnership", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.ownership === void 0 || !ownsLane(stored, request.ownershipToken)) return [failure(ownershipLost(current, stored)), current];
-			const ownership = {
-				...stored.ownership,
-				leaseExpiresAtMillis: nowMillis + leaseMillis
-			};
-			return [success(OwnershipRenewal.make({
-				ownershipToken: ownership.ownershipToken,
-				leaseExpiresAt: utc(ownership.leaseExpiresAtMillis)
-			})), withSubmission(current, {
-				...stored,
-				ownership
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const releaseOwnership = Effect.fn("MemorySubmissionLedger.releaseOwnership")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(ReleaseOwnershipRequest, "releaseOwnership", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("releaseOwnership", `Unknown Submission ${request.submissionId}`)), current];
-			if (!ownsLane(stored, request.ownershipToken)) return [failure(ownershipLost(current, stored)), current];
-			return [success(void 0), withSubmission(current, {
-				...stored,
-				ownership: void 0
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-	}));
-	const markInputApplied = Effect.fn("MemorySubmissionLedger.markInputApplied")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(MarkInputAppliedRequest, "markInputApplied", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("markInputApplied", `Unknown Submission ${request.submissionId}`)), current];
-			if (!ownsLane(stored, request.ownershipToken)) return [failure(ownershipLost(current, stored)), current];
-			const marker = InputAppliedMarker.make({
-				recordId: request.recordId,
-				sequence: request.sequence
-			});
-			const row = STATE_RANK[stored.row.state] < STATE_RANK["input-applied"] ? {
-				...stored.row,
-				state: "input-applied"
-			} : stored.row;
-			return [success(void 0), withSubmission(current, {
-				...stored,
-				row,
-				inputApplied: marker
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-	}));
-	const reserveSettlement = Effect.fn("MemorySubmissionLedger.reserveSettlement")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(SettlementReservation, "reserveSettlement", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("reserveSettlement", `Unknown Submission ${request.submissionId}`)), current];
-			const joinedSettlement = stored.row.state === "joined" && stored.joinedHostSubmissionId !== void 0;
-			const queuedAbortSettlement = request.outcome === "aborted" && stored.abortIntent !== void 0 && stored.ownership === void 0 && (stored.row.state === "ready" || stored.row.state === "terminalizing");
-			if (!joinedSettlement && !queuedAbortSettlement && !ownsLane(stored, request.ownershipToken)) return [failure(ownershipLost(current, stored)), current];
-			const existing = stored.reservation;
-			if (existing !== void 0) {
-				if (existing.settlementId !== request.settlementId || existing.outcome !== request.outcome || existing.recordDigest !== request.recordDigest) return [failure(SettlementConflict.make({
-					submissionId: request.submissionId,
-					existingOutcome: existing.outcome
-				})), current];
-				return [success(ReservedSettlement.make({
-					submissionId: request.submissionId,
-					settlementId: existing.settlementId,
-					outcome: existing.outcome,
-					record: existing.record,
-					recordDigest: existing.recordDigest,
-					replayed: true
-				})), current];
-			}
-			const reservation = {
-				settlementId: request.settlementId,
-				outcome: request.outcome,
-				record: request.record,
-				recordDigest: request.recordDigest,
-				finalizedAtMillis: void 0
-			};
-			const row = STATE_RANK[stored.row.state] < STATE_RANK.terminalizing ? {
-				...stored.row,
-				state: "terminalizing"
-			} : stored.row;
-			return [success(ReservedSettlement.make({
-				submissionId: request.submissionId,
-				settlementId: reservation.settlementId,
-				outcome: reservation.outcome,
-				record: reservation.record,
-				recordDigest: reservation.recordDigest,
-				replayed: false
-			})), withSubmission(current, {
-				...stored,
-				row,
-				reservation
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const finalizeSettlement = Effect.fn("MemorySubmissionLedger.finalizeSettlement")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(SettlementFinalization, "finalizeSettlement", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("finalizeSettlement", `Unknown Submission ${request.submissionId}`)), current];
-			const reservation = stored.reservation;
-			if (reservation === void 0) return [failure(ledgerError("finalizeSettlement", `No settlement reservation for Submission ${request.submissionId}`)), current];
-			if (reservation.settlementId !== request.settlementId) return [failure(SettlementConflict.make({
-				submissionId: request.submissionId,
-				existingOutcome: reservation.outcome
-			})), current];
-			if (reservation.finalizedAtMillis !== void 0) return [success(Settlement.make({
-				submissionId: stored.row.submissionId,
-				settlementId: reservation.settlementId,
-				receiptId: stored.row.receiptId,
-				outcome: reservation.outcome,
-				settledAt: utc(reservation.finalizedAtMillis)
-			})), current];
-			const next = withSubmission(current, {
-				...stored,
-				row: {
-					...stored.row,
-					state: "settled",
-					settledOutcome: reservation.outcome
-				},
-				ownership: void 0,
-				reservation: {
-					...reservation,
-					finalizedAtMillis: nowMillis
-				}
-			});
-			return [success(Settlement.make({
-				submissionId: stored.row.submissionId,
-				settlementId: reservation.settlementId,
-				receiptId: stored.row.receiptId,
-				outcome: reservation.outcome,
-				settledAt: utc(nowMillis)
-			})), next];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const requestAbort = Effect.fn("MemorySubmissionLedger.requestAbort")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(AbortCommand, "requestAbort", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("requestAbort", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.row.state === "joined") {
-				if (stored.joinedHostSubmissionId === void 0) return [failure(ledgerError("requestAbort", `Joined Submission ${request.submissionId} is missing its host linkage`)), current];
-				return [failure(JoinedToHost.make({
-					submissionId: request.submissionId,
-					hostSubmissionId: stored.joinedHostSubmissionId
-				})), current];
-			}
-			if (stored.row.state === "settled") {
-				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("requestAbort", `Settled Submission ${request.submissionId} is missing its outcome`)), current];
-				return [failure(SettlementConflict.make({
-					submissionId: request.submissionId,
-					existingOutcome: stored.row.settledOutcome
-				})), current];
-			}
-			if (stored.abortIntent !== void 0) return [success(stored.abortIntent), current];
-			const intent = AbortIntent.make({
-				submissionId: request.submissionId,
-				author: request.author,
-				reason: request.reason,
-				requestedAt: utc(nowMillis)
-			});
-			return [success(intent), withSubmission(current, {
-				...stored,
-				abortIntent: intent
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const claimJoining = Effect.fn("MemorySubmissionLedger.claimJoining")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(ClaimJoiningRequest, "claimJoining", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const host = current.submissions.get(request.hostSubmissionId);
-			if (host === void 0) return [failure(ledgerError("claimJoining", `Unknown Submission ${request.hostSubmissionId}`)), current];
-			if (host.row.conversationId !== request.conversationId) return [failure(ledgerError("claimJoining", `Host Submission ${request.hostSubmissionId} does not belong to Conversation ${request.conversationId}`)), current];
-			if (!ownsLane(host, request.ownershipToken)) return [failure(ownershipLost(current, host)), current];
-			const later = [...current.submissions.values()].filter((stored) => stored.row.conversationId === request.conversationId && stored.row.queueSequence > host.row.queueSequence).sort((left, right) => left.row.queueSequence - right.row.queueSequence);
-			const claims = [];
-			const submissions = new Map(current.submissions);
-			for (const stored of later) {
-				if (claims.length >= request.maxCount) break;
-				if ((stored.row.state === "joining" || stored.row.state === "joined") && stored.joinedHostSubmissionId === request.hostSubmissionId) continue;
-				if (stored.row.state === "settled" && stored.row.settledOutcome === "aborted") continue;
-				if (stored.row.state !== "ready") break;
-				submissions.set(stored.row.submissionId, {
-					...stored,
-					row: {
-						...stored.row,
-						state: "joining"
-					},
-					joinedHostSubmissionId: request.hostSubmissionId
-				});
-				claims.push(JoiningClaim.make({
-					submissionId: stored.row.submissionId,
-					queueSequence: stored.row.queueSequence,
-					inputPayload: stored.row.inputPayload
-				}));
-			}
-			return [success(claims), {
-				...current,
-				submissions
-			}];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const markJoined = Effect.fn("MemorySubmissionLedger.markJoined")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(MarkJoinedRequest, "markJoined", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("markJoined", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.joinedHostSubmissionId === void 0) return [failure(ledgerError("markJoined", `Submission ${request.submissionId} was never claimed for joining`)), current];
-			const host = current.submissions.get(stored.joinedHostSubmissionId);
-			if (host === void 0) return [failure(ledgerError("markJoined", `Host Submission ${stored.joinedHostSubmissionId} is missing`)), current];
-			if (!ownsLane(host, request.ownershipToken)) return [failure(ownershipLost(current, host)), current];
-			if (stored.inputApplied !== void 0) {
-				if (stored.inputApplied.recordId === request.recordId && stored.inputApplied.sequence === request.sequence) return [success(void 0), current];
-				return [failure(ledgerError("markJoined", `A different join marker is already recorded for Submission ${request.submissionId}`)), current];
-			}
-			if (stored.row.state !== "joining" && stored.row.state !== "joined") return [failure(ledgerError("markJoined", `Cannot mark Submission ${request.submissionId} joined from state ${stored.row.state}`)), current];
-			const marker = InputAppliedMarker.make({
-				recordId: request.recordId,
-				sequence: request.sequence
-			});
-			return [success(void 0), withSubmission(current, {
-				...stored,
-				row: {
-					...stored.row,
-					state: "joined"
-				},
-				inputApplied: marker
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-	}));
-	const revertJoining = Effect.fn("MemorySubmissionLedger.revertJoining")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(RevertJoiningRequest, "revertJoining", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("revertJoining", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.row.state !== "joining") return [success(void 0), current];
-			return [success(void 0), withSubmission(current, {
-				...stored,
-				row: {
-					...stored.row,
-					state: "ready"
-				},
-				joinedHostSubmissionId: void 0
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-	}));
-	const suspend = Effect.fn("MemorySubmissionLedger.suspend")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(SuspendRequest, "suspend", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("suspend", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.row.state === "settled") {
-				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("suspend", `Settled Submission ${request.submissionId} is missing its outcome`)), current];
-				return [failure(SettlementConflict.make({
-					submissionId: request.submissionId,
-					existingOutcome: stored.row.settledOutcome
-				})), current];
-			}
-			if (stored.reservation !== void 0) return [failure(SettlementConflict.make({
-				submissionId: request.submissionId,
-				existingOutcome: stored.reservation.outcome
-			})), current];
-			if (!ownsLane(stored, request.ownershipToken)) return [failure(ownershipLost(current, stored)), current];
-			if (request.reason._tag === "ApprovalPending" ? request.reason.toolCallIds.every((toolCallId) => stored.approvalDecisions.has(toolCallId)) : request.reason.children.every((child) => current.submissions.get(child.childSubmissionId)?.row.state === "settled")) return [success("resume-immediately"), current];
-			return [success("suspended"), withSubmission(current, {
-				...stored,
-				row: {
-					...stored.row,
-					state: "suspended"
-				},
-				ownership: void 0,
-				suspension: {
-					reason: request.reason,
-					suspendedAtMillis: nowMillis
-				}
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const recordApprovalDecision = Effect.fn("MemorySubmissionLedger.recordApprovalDecision")((unvalidated) => Effect.gen(function* () {
-		const command = yield* validate$1(ApprovalDecisionCommand, "recordApprovalDecision", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(command.submissionId);
-			if (stored === void 0) return [failure(ledgerError("recordApprovalDecision", `Unknown Submission ${command.submissionId}`)), current];
-			if (stored.row.state === "settled") {
-				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("recordApprovalDecision", `Settled Submission ${command.submissionId} is missing its outcome`)), current];
-				return [failure(SettlementConflict.make({
-					submissionId: command.submissionId,
-					existingOutcome: stored.row.settledOutcome
-				})), current];
-			}
-			const existing = stored.approvalDecisions.get(command.toolCallId);
-			if (existing !== void 0) {
-				if (existing.decision !== command.decision) return [failure(ApprovalConflict.make({
-					submissionId: command.submissionId,
-					toolCallId: command.toolCallId,
-					existingDecision: existing.decision
-				})), current];
-				return [success(existing), current];
-			}
-			const intent = ApprovalDecisionIntent.make({
-				submissionId: command.submissionId,
-				toolCallId: command.toolCallId,
-				decision: command.decision,
-				resolver: command.resolver,
-				reason: command.reason,
-				decidedAt: utc(nowMillis)
-			});
-			const approvalDecisions = new Map(stored.approvalDecisions).set(command.toolCallId, intent);
-			const wakes = stored.row.state === "suspended" && stored.suspension !== void 0 && stored.suspension.reason._tag === "ApprovalPending" && stored.suspension.reason.toolCallIds.every((toolCallId) => approvalDecisions.has(toolCallId));
-			return [success(intent), withSubmission(current, {
-				...stored,
-				row: wakes ? {
-					...stored.row,
-					state: "input-applied"
-				} : stored.row,
-				suspension: wakes ? void 0 : stored.suspension,
-				approvalDecisions
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const markUnknown = Effect.fn("MemorySubmissionLedger.markUnknown")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(MarkUnknownRequest, "markUnknown", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(request.submissionId);
-			if (stored === void 0) return [failure(ledgerError("markUnknown", `Unknown Submission ${request.submissionId}`)), current];
-			if (stored.row.state === "settled") {
-				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("markUnknown", `Settled Submission ${request.submissionId} is missing its outcome`)), current];
-				return [failure(SettlementConflict.make({
-					submissionId: request.submissionId,
-					existingOutcome: stored.row.settledOutcome
-				})), current];
-			}
-			if (stored.reservation !== void 0) return [failure(SettlementConflict.make({
-				submissionId: request.submissionId,
-				existingOutcome: stored.reservation.outcome
-			})), current];
-			const existing = stored.unknownMark;
-			const known = new Set(existing?.toolCallIds ?? []);
-			const merged = [...existing?.toolCallIds ?? [], ...request.toolCallIds.filter((toolCallId) => !known.has(toolCallId))];
-			return [success(void 0), withSubmission(current, {
-				...stored,
-				row: stored.row.state === "unknown" ? stored.row : {
-					...stored.row,
-					state: "unknown"
-				},
-				unknownMark: {
-					reason: existing?.reason ?? request.reason,
-					toolCallIds: merged
-				}
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-	}));
-	const recordUnknownResolution = Effect.fn("MemorySubmissionLedger.recordUnknownResolution")((unvalidated) => Effect.gen(function* () {
-		const command = yield* validate$1(UnknownResolutionCommand, "recordUnknownResolution", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const encodedResolution = yield* Schema.encodeUnknownEffect(UnknownResolution)(command.resolution).pipe(Effect.mapError((error) => ledgerError("recordUnknownResolution", "Invalid unknown-outcome resolution", error)));
-		const resolutionJson = JSON.stringify(encodedResolution);
-		const decision = yield* Ref.modify(state, (current) => {
-			const stored = current.submissions.get(command.submissionId);
-			if (stored === void 0) return [failure(ledgerError("recordUnknownResolution", `Unknown Submission ${command.submissionId}`)), current];
-			if (stored.row.state === "settled") {
-				if (stored.row.settledOutcome === void 0) return [failure(ledgerError("recordUnknownResolution", `Settled Submission ${command.submissionId} is missing its outcome`)), current];
-				return [failure(SettlementConflict.make({
-					submissionId: command.submissionId,
-					existingOutcome: stored.row.settledOutcome
-				})), current];
-			}
-			const existing = stored.unknownResolutions.get(command.toolCallId);
-			if (existing !== void 0 && existing.resolutionJson !== resolutionJson) return [failure(UnknownResolutionConflict.make({
-				submissionId: command.submissionId,
-				toolCallId: command.toolCallId
-			})), current];
-			const intent = existing?.intent ?? UnknownResolutionIntent.make({
-				submissionId: command.submissionId,
-				toolCallId: command.toolCallId,
-				author: command.author,
-				reason: command.reason,
-				resolution: command.resolution,
-				resolvedAt: utc(nowMillis)
-			});
-			const unknownResolutions = existing !== void 0 ? stored.unknownResolutions : new Map(stored.unknownResolutions).set(command.toolCallId, {
-				intent,
-				resolutionJson
-			});
-			const wakes = stored.row.state === "unknown" && stored.unknownMark !== void 0 && stored.unknownMark.toolCallIds.every((toolCallId) => unknownResolutions.has(toolCallId));
-			return [success(intent), withSubmission(current, {
-				...stored,
-				row: wakes ? {
-					...stored.row,
-					state: "input-applied"
-				} : stored.row,
-				unknownMark: wakes ? void 0 : stored.unknownMark,
-				unknownResolutions
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const recordChildSettled = Effect.fn("MemorySubmissionLedger.recordChildSettled")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(ChildSettledNotification, "recordChildSettled", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const parent = current.submissions.get(request.parentSubmissionId);
-			if (parent === void 0) return [failure(ledgerError("recordChildSettled", `Unknown Submission ${request.parentSubmissionId}`)), current];
-			const child = current.submissions.get(request.childSubmissionId);
-			if (child === void 0 || child.row.state !== "settled") return [failure(ledgerError("recordChildSettled", `Child Submission ${request.childSubmissionId} has no recorded settlement`)), current];
-			if (parent.row.state !== "suspended" || parent.suspension === void 0 || parent.suspension.reason._tag !== "WaitingForChild") return [success("not-waiting"), current];
-			const children = parent.suspension.reason.children;
-			if (!children.some((entry) => entry.childSubmissionId === request.childSubmissionId)) return [success("not-waiting"), current];
-			if (!children.every((entry) => current.submissions.get(entry.childSubmissionId)?.row.state === "settled")) return [success("still-waiting"), current];
-			return [success("woken"), withSubmission(current, {
-				...parent,
-				row: {
-					...parent.row,
-					state: "input-applied"
-				},
-				suspension: void 0
-			})];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const reserveChildBudget = Effect.fn("MemorySubmissionLedger.reserveChildBudget")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(ChildBudgetReservationRequest, "reserveChildBudget", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const allocationJson = JSON.stringify(request.allocation);
-		const decision = yield* Ref.modify(state, (current) => {
-			const existing = current.childReservations.get(request.reservationId);
-			if (existing !== void 0) {
-				if (!(existing.parentSubmissionId === request.parentSubmissionId && existing.parentToolCallId === request.parentToolCallId && existing.allocationDigest === request.allocationDigest && existing.allocationJson === allocationJson)) return [failure(ChildReservationConflict.make({
-					reservationId: request.reservationId,
-					status: existing.status,
-					message: "A reservation with this identity exists with a different parent Tool Call or allocation."
-				})), current];
-				return [success(ReservedChildBudget.make({
-					reservation: toReservationSnapshot(existing),
-					replayed: true
-				})), current];
-			}
-			for (const reservation of current.childReservations.values()) if (reservation.parentSubmissionId === request.parentSubmissionId && reservation.parentToolCallId === request.parentToolCallId) return [failure(ChildReservationConflict.make({
-				reservationId: request.reservationId,
-				status: reservation.status,
-				message: `Parent Tool Call ${request.parentToolCallId} already owns reservation ${reservation.reservationId}.`
-			})), current];
-			const parent = current.submissions.get(request.parentSubmissionId);
-			if (parent === void 0) return [failure(ledgerError("reserveChildBudget", `Unknown Submission ${request.parentSubmissionId}`)), current];
-			if (!ownsLane(parent, request.ownershipToken)) return [failure(ownershipLost(current, parent)), current];
-			const reservation = {
-				reservationId: request.reservationId,
-				parentSubmissionId: request.parentSubmissionId,
-				parentToolCallId: request.parentToolCallId,
-				childSubmissionId: void 0,
-				status: "reserved",
-				allocation: request.allocation,
-				allocationJson,
-				allocationDigest: request.allocationDigest,
-				accounting: void 0,
-				accountingJson: void 0,
-				reservedAtMillis: nowMillis,
-				releaseBeganAtMillis: void 0,
-				releasedAtMillis: void 0
-			};
-			return [success(ReservedChildBudget.make({
-				reservation: toReservationSnapshot(reservation),
-				replayed: false
-			})), withChildReservation(current, reservation)];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const attachChildToReservation = Effect.fn("MemorySubmissionLedger.attachChildToReservation")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(AttachChildToReservationRequest, "attachChildToReservation", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const reservation = current.childReservations.get(request.reservationId);
-			if (reservation === void 0) return [failure(ledgerError("attachChildToReservation", `Unknown child reservation ${request.reservationId}`)), current];
-			if (reservation.childSubmissionId !== void 0) {
-				if (reservation.childSubmissionId === request.childSubmissionId) return [success(toReservationSnapshot(reservation)), current];
-				return [failure(ChildReservationConflict.make({
-					reservationId: request.reservationId,
-					status: reservation.status,
-					message: `Reservation ${request.reservationId} already records child ${reservation.childSubmissionId}.`
-				})), current];
-			}
-			const parent = current.submissions.get(reservation.parentSubmissionId);
-			if (parent === void 0) return [failure(ledgerError("attachChildToReservation", `Unknown Submission ${reservation.parentSubmissionId}`)), current];
-			if (!ownsLane(parent, request.ownershipToken)) return [failure(ownershipLost(current, parent)), current];
-			if (reservation.status !== "reserved") return [failure(ChildReservationConflict.make({
-				reservationId: request.reservationId,
-				status: reservation.status,
-				message: `Cannot attach a child to a ${reservation.status} reservation.`
-			})), current];
-			if (!current.submissions.has(request.childSubmissionId)) return [failure(ledgerError("attachChildToReservation", `Unknown child Submission ${request.childSubmissionId}`)), current];
-			const attached = {
-				...reservation,
-				childSubmissionId: request.childSubmissionId
-			};
-			return [success(toReservationSnapshot(attached)), withChildReservation(current, attached)];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const beginChildBudgetRelease = Effect.fn("MemorySubmissionLedger.beginChildBudgetRelease")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(BeginChildBudgetReleaseRequest, "beginChildBudgetRelease", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const accountingJson = JSON.stringify(request.accounting);
-		const decision = yield* Ref.modify(state, (current) => {
-			const reservation = current.childReservations.get(request.reservationId);
-			if (reservation === void 0) return [failure(ledgerError("beginChildBudgetRelease", `Unknown child reservation ${request.reservationId}`)), current];
-			if (reservation.status !== "reserved") {
-				if (reservation.accountingJson === accountingJson) return [success(toReservationSnapshot(reservation)), current];
-				return [failure(ChildReservationConflict.make({
-					reservationId: request.reservationId,
-					status: reservation.status,
-					message: "A different accounting decision is already frozen for this reservation."
-				})), current];
-			}
-			const frozen = {
-				...reservation,
-				status: "releasePending",
-				accounting: request.accounting,
-				accountingJson,
-				releaseBeganAtMillis: nowMillis
-			};
-			return [success(toReservationSnapshot(frozen)), withChildReservation(current, frozen)];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const releaseChildBudget = Effect.fn("MemorySubmissionLedger.releaseChildBudget")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(ReleaseChildBudgetRequest, "releaseChildBudget", unvalidated);
-		const nowMillis = yield* Clock.currentTimeMillis;
-		const decision = yield* Ref.modify(state, (current) => {
-			const reservation = current.childReservations.get(request.reservationId);
-			if (reservation === void 0) return [failure(ledgerError("releaseChildBudget", `Unknown child reservation ${request.reservationId}`)), current];
-			if (reservation.status === "released") return [success(toReservationSnapshot(reservation)), current];
-			if (reservation.status !== "releasePending") return [failure(ChildReservationConflict.make({
-				reservationId: request.reservationId,
-				status: reservation.status,
-				message: "Cannot release a reservation whose accounting decision is not frozen."
-			})), current];
-			const released = {
-				...reservation,
-				status: "released",
-				releasedAtMillis: nowMillis
-			};
-			return [success(toReservationSnapshot(released)), withChildReservation(current, released)];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.value;
-	}));
-	const scanNonterminal = Stream.unwrap(Ref.get(state).pipe(Effect.map((current) => {
-		const snapshots = [...current.submissions.values()].filter((stored) => stored.row.state !== "settled").sort((left, right) => left.row.conversationId < right.row.conversationId ? -1 : left.row.conversationId > right.row.conversationId ? 1 : left.row.queueSequence - right.row.queueSequence).map((stored) => toSnapshot(stored.row));
-		return Stream.fromIterable(snapshots);
-	})));
-	const loadRecoverySnapshot = Effect.fn("MemorySubmissionLedger.loadRecoverySnapshot")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(RecoverySnapshotRequest, "loadRecoverySnapshot", unvalidated);
-		const current = yield* Ref.get(state);
-		const stored = current.submissions.get(request.submissionId);
-		if (stored === void 0) return yield* ledgerError("loadRecoverySnapshot", `Unknown Submission ${request.submissionId}`);
-		const joins = [...current.submissions.values()].filter((candidate) => candidate.joinedHostSubmissionId === request.submissionId).sort((left, right) => left.row.queueSequence - right.row.queueSequence).map((candidate) => JoinSnapshot.make({
-			submissionId: candidate.row.submissionId,
-			state: candidate.row.state,
-			hostSubmissionId: request.submissionId
-		}));
-		const byToolCallId = (left, right) => left.toolCallId < right.toolCallId ? -1 : left.toolCallId > right.toolCallId ? 1 : 0;
-		const childReservations = [...current.childReservations.values()].filter((reservation) => reservation.parentSubmissionId === request.submissionId).sort((left, right) => left.parentToolCallId < right.parentToolCallId ? -1 : left.parentToolCallId > right.parentToolCallId ? 1 : 0);
-		const childAttachments = [];
-		for (const reservation of childReservations) {
-			if (reservation.childSubmissionId === void 0) continue;
-			const child = current.submissions.get(reservation.childSubmissionId);
-			if (child === void 0) continue;
-			childAttachments.push(ChildAttachmentSnapshot.make({
-				toolCallId: reservation.parentToolCallId,
-				childSubmissionId: reservation.childSubmissionId,
-				childState: child.row.state,
-				...child.row.settledOutcome === void 0 ? {} : { childOutcome: child.row.settledOutcome }
-			}));
-		}
-		return RecoverySnapshot.make({
-			submission: toSnapshot(stored.row),
-			joins,
-			approvalDecisions: [...stored.approvalDecisions.values()].sort(byToolCallId),
-			unknownResolutions: [...stored.unknownResolutions.values()].map((resolution) => resolution.intent).sort(byToolCallId),
-			childReservations: childReservations.map(toReservationSnapshot),
-			childAttachments,
-			...stored.row.parentLinkage === void 0 ? {} : { parentLinkage: stored.row.parentLinkage },
-			...stored.joinedHostSubmissionId === void 0 ? {} : { hostSubmissionId: stored.joinedHostSubmissionId },
-			...stored.suspension === void 0 ? {} : { suspension: SuspensionSnapshot.make({
-				reason: stored.suspension.reason,
-				suspendedAt: utc(stored.suspension.suspendedAtMillis)
-			}) },
-			...stored.ownership === void 0 ? {} : { ownership: OwnershipSnapshot.make({
-				attemptId: stored.ownership.attemptId,
-				ownerProducerId: stored.ownership.ownerProducerId,
-				producerEpoch: stored.ownership.producerEpoch,
-				leaseExpiresAt: utc(stored.ownership.leaseExpiresAtMillis)
-			}) },
-			...stored.inputApplied === void 0 ? {} : { inputApplied: stored.inputApplied },
-			...stored.reservation === void 0 ? {} : { reservation: SettlementReservationSnapshot.make({
-				settlementId: stored.reservation.settlementId,
-				outcome: stored.reservation.outcome,
-				record: stored.reservation.record,
-				recordDigest: stored.reservation.recordDigest,
-				finalized: stored.reservation.finalizedAtMillis !== void 0
-			}) },
-			...stored.abortIntent === void 0 ? {} : { abortIntent: stored.abortIntent }
-		});
-	}));
-	return SubmissionLedger.of({
-		capabilities,
-		admit,
-		markReady,
-		lookup,
-		resolveAdmission,
-		claim,
-		renewOwnership,
-		releaseOwnership,
-		markInputApplied,
-		reserveSettlement,
-		finalizeSettlement,
-		requestAbort,
-		claimJoining,
-		markJoined,
-		revertJoining,
-		suspend,
-		recordApprovalDecision,
-		markUnknown,
-		recordUnknownResolution,
-		recordChildSettled,
-		reserveChildBudget,
-		attachChildToReservation,
-		beginChildBudgetRelease,
-		releaseChildBudget,
-		scanNonterminal,
-		loadRecoverySnapshot
-	});
-});
-/**
-* In-memory reference SubmissionLedger Layer (durability `non-durable`). All state lives in one
-* `Ref` owned by the Layer's Scope; no daemon fibers are spawned and no wall clock is consulted.
-*/
-const memorySubmissionLedgerLayer = (options = {}) => Layer.effect(SubmissionLedger, makeSubmissionLedger(options));
-const MemorySubmissionLedgerLive = memorySubmissionLedgerLayer();
-//#endregion
-//#region src/memory-storage.ts
-const MAX_CONVERSATIONS = 256;
-const MAX_RECORDS_PER_CONVERSATION = 65536;
-const MAX_CHECKPOINTS_PER_CONVERSATION = 1024;
-const storeError = (operation, message, cause) => cause === void 0 ? ConversationStoreError.make({
-	operation,
-	message
-}) : ConversationStoreError.make({
-	operation,
-	message,
-	cause
-});
-const validate = Effect.fn("MemoryConversationStore.validate")((schema, operation, value) => Schema.encodeUnknownEffect(schema)(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(schema)), Effect.mapError((error) => storeError(operation, `Invalid ${operation} request`, error))));
-const decodeCanonicalSequence = Schema.decodeSync(CanonicalSequence);
-const ZERO_CANONICAL_SEQUENCE = decodeCanonicalSequence(0);
-const offsetSequence = Effect.fn("MemoryConversationStore.offsetSequence")((conversationId, offset) => {
-	if (offset === void 0) return Effect.succeed(ZERO_CANONICAL_SEQUENCE);
-	const prefix = `memory:v1:${Encoding.encodeBase64(conversationId)}:`;
-	const encodedSequence = offset.startsWith(prefix) ? offset.slice(prefix.length) : "";
-	if (!/^\d+$/.test(encodedSequence)) return Effect.fail(storeError("observe", "Malformed observation offset"));
-	const sequence = Number(encodedSequence);
-	return Number.isSafeInteger(sequence) ? Schema.decodeUnknownEffect(CanonicalSequence)(sequence).pipe(Effect.mapError(() => storeError("observe", "Malformed observation offset"))) : Effect.fail(storeError("observe", "Malformed observation offset"));
-});
-const observationOffset = (conversationId, sequence) => Schema.decodeSync(ObservationOffset)(`memory:v1:${Encoding.encodeBase64(conversationId)}:${sequence}`);
-const findConversation = Effect.fn("MemoryConversationStore.findConversation")((state, conversationId) => {
-	const conversation = state.conversations.get(conversationId);
-	return conversation === void 0 ? Effect.fail(ConversationNotMaterialized.make({ conversationId })) : Effect.succeed(conversation);
-});
-const CheckpointVersionEnvelope = Schema.Struct({ checkpoint: Schema.Struct({
-	conversationId: ConversationId,
-	schemaVersion: Schema.Natural
-}) });
-const validateCheckpointVersion = Effect.fn("MemoryConversationStore.validateCheckpointVersion")(function* (value) {
-	const envelope = yield* Schema.decodeUnknownEffect(CheckpointVersionEnvelope)(value).pipe(Effect.mapError(() => storeError("saveCheckpoint", "Invalid saveCheckpoint request")));
-	if (envelope.checkpoint.schemaVersion !== 1) return yield* CheckpointRejected.make({
-		conversationId: envelope.checkpoint.conversationId,
-		reason: "unsupported-version"
-	});
-});
-const makeConversationStore = Effect.gen(function* () {
-	const crypto = yield* Crypto.Crypto;
-	const state = yield* Ref.make({ conversations: /* @__PURE__ */ new Map() });
-	const updates = yield* PubSub.sliding(1);
-	yield* Effect.addFinalizer(() => PubSub.shutdown(updates));
-	const materialize = Effect.fn("MemoryConversationStore.materialize")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(ConversationMaterialization, "materialize", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const existing = current.conversations.get(request.conversationId);
-			if (existing !== void 0) {
-				if (request.producerEpoch < existing.producerEpoch) return [{
-					_tag: "failure",
-					error: FenceRejected.make({
-						conversationId: request.conversationId,
-						actualEpoch: existing.producerEpoch,
-						attemptedEpoch: request.producerEpoch
-					})
-				}, current];
-				if (request.producerEpoch === existing.producerEpoch) return [{ _tag: "success" }, current];
-				const conversations = new Map(current.conversations);
-				conversations.set(request.conversationId, {
-					...existing,
-					producerEpoch: request.producerEpoch
-				});
-				return [{ _tag: "success" }, { conversations }];
-			}
-			if (current.conversations.size >= MAX_CONVERSATIONS) return [{
-				_tag: "failure",
-				error: storeError("materialize", `In-memory conversation limit ${MAX_CONVERSATIONS} exceeded`)
-			}, current];
-			const conversations = new Map(current.conversations);
-			conversations.set(request.conversationId, {
-				producerEpoch: request.producerEpoch,
-				tailSequence: ZERO_CANONICAL_SEQUENCE,
-				tailDigest: EMPTY_TAIL_DIGEST,
-				records: [],
-				recordIds: /* @__PURE__ */ new Set(),
-				batches: /* @__PURE__ */ new Map(),
-				tailDigests: /* @__PURE__ */ new Map([[ZERO_CANONICAL_SEQUENCE, EMPTY_TAIL_DIGEST]]),
-				checkpoints: /* @__PURE__ */ new Map()
-			});
-			return [{ _tag: "success" }, { conversations }];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-	}));
-	const append = Effect.fn("MemoryConversationStore.append")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(FencedAppendRequest, "append", unvalidated);
-		const digest = yield* digestCanonicalBatch(request.expectedTailDigest, request.batch).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.mapError((error) => storeError("append", error.message, error)));
-		const decision = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const conversation = current.conversations.get(request.conversationId);
-			if (conversation === void 0) return [{
-				_tag: "failure",
-				error: ConversationNotMaterialized.make({ conversationId: request.conversationId })
-			}, current];
-			if (request.producerEpoch !== conversation.producerEpoch) return [{
-				_tag: "failure",
-				error: FenceRejected.make({
-					conversationId: request.conversationId,
-					actualEpoch: conversation.producerEpoch,
-					attemptedEpoch: request.producerEpoch
-				})
-			}, current];
-			const previous = conversation.batches.get(request.batch.batchId);
-			if (previous !== void 0) {
-				if (previous.digest !== digest) return [{
-					_tag: "failure",
-					error: AppendConflict.make({
-						conversationId: request.conversationId,
-						batchId: request.batch.batchId,
-						reason: "batch-digest"
-					})
-				}, current];
-				return [{
-					_tag: "success",
-					result: AppendResult.make({
-						firstSequence: previous.result.firstSequence,
-						lastSequence: previous.result.lastSequence,
-						tailDigest: previous.result.tailDigest,
-						replayed: true
-					}),
-					records: []
-				}, current];
-			}
-			if (request.expectedTailSequence !== conversation.tailSequence || request.expectedTailDigest !== conversation.tailDigest) return [{
-				_tag: "failure",
-				error: AppendConflict.make({
-					conversationId: request.conversationId,
-					batchId: request.batch.batchId,
-					reason: "tail",
-					actualTailSequence: conversation.tailSequence,
-					actualTailDigest: conversation.tailDigest
-				})
-			}, current];
-			if (conversation.records.length + request.batch.records.length > MAX_RECORDS_PER_CONVERSATION) return [{
-				_tag: "failure",
-				error: storeError("append", `In-memory record limit ${MAX_RECORDS_PER_CONVERSATION} exceeded`)
-			}, current];
-			const batchRecordIds = /* @__PURE__ */ new Set();
-			for (const record of request.batch.records) {
-				if (conversation.recordIds.has(record.recordId) || batchRecordIds.has(record.recordId)) return [{
-					_tag: "failure",
-					error: AppendConflict.make({
-						conversationId: request.conversationId,
-						batchId: request.batch.batchId,
-						reason: "record-identity"
-					})
-				}, current];
-				batchRecordIds.add(record.recordId);
-			}
-			const records = request.batch.records.map((record, index) => {
-				const sequence = decodeCanonicalSequence(conversation.tailSequence + index + 1);
-				return CanonicalRecordEnvelope.make({
-					conversationId: request.conversationId,
-					batchId: request.batch.batchId,
-					sequence,
-					offset: observationOffset(request.conversationId, sequence),
-					record
-				});
-			});
-			const lastSequence = decodeCanonicalSequence(conversation.tailSequence + records.length);
-			const result = AppendResult.make({
-				firstSequence: decodeCanonicalSequence(conversation.tailSequence + 1),
-				lastSequence,
-				tailDigest: digest,
-				replayed: false
-			});
-			const batches = new Map(conversation.batches);
-			batches.set(request.batch.batchId, {
-				digest,
-				result
-			});
-			const recordIds = new Set(conversation.recordIds);
-			for (const recordId of batchRecordIds) recordIds.add(recordId);
-			const tailDigests = new Map(conversation.tailDigests);
-			tailDigests.set(lastSequence, digest);
-			const conversations = new Map(current.conversations);
-			conversations.set(request.conversationId, {
-				...conversation,
-				tailSequence: lastSequence,
-				tailDigest: digest,
-				records: [...conversation.records, ...records],
-				recordIds,
-				batches,
-				tailDigests
-			});
-			return [{
-				_tag: "success",
-				result,
-				records
-			}, { conversations }];
-		}).pipe(Effect.tap((decision) => decision._tag === "success" && decision.records.length > 0 ? PubSub.publish(updates, void 0) : Effect.void)));
-		if (decision._tag === "failure") return yield* decision.error;
-		return decision.result;
-	}));
-	const readSnapshot = Effect.fn("MemoryConversationStore.readSnapshot")((conversationId, afterSequence, limit) => Ref.get(state).pipe(Effect.flatMap((current) => findConversation(current, conversationId)), Effect.map((conversation) => conversation.records.filter((record) => record.sequence > (afterSequence ?? ZERO_CANONICAL_SEQUENCE)).slice(0, limit))));
-	const read = (unvalidated) => Stream.unwrap(Effect.gen(function* () {
-		const request = yield* validate(ConversationRead, "read", unvalidated);
-		const records = yield* readSnapshot(request.conversationId, request.afterSequence, request.limit);
-		return Stream.fromIterable(records);
-	}));
-	const observe = (unvalidated) => Stream.unwrap(Effect.gen(function* () {
-		const request = yield* validate(ConversationObservation, "observe", unvalidated);
-		const afterSequence = yield* offsetSequence(request.conversationId, request.afterOffset);
-		return Stream.unwrap(Effect.gen(function* () {
-			const subscription = yield* PubSub.subscribe(updates);
-			const initial = yield* readSnapshot(request.conversationId, afterSequence, MAX_RECORDS_PER_CONVERSATION);
-			const highWater = initial.length === 0 ? afterSequence : initial.at(-1)?.sequence ?? afterSequence;
-			const live = Stream.fromEffectRepeat(PubSub.take(subscription)).pipe(Stream.mapAccumEffect(() => highWater, (lastSequence) => readSnapshot(request.conversationId, lastSequence, MAX_RECORDS_PER_CONVERSATION).pipe(Effect.map((records) => [records.at(-1)?.sequence ?? lastSequence, records]))));
-			return Stream.fromIterable(initial).pipe(Stream.concat(live));
-		}));
-	}));
-	const exportConversation = Effect.fn("MemoryConversationStore.export")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(ConversationExportRequest, "export", unvalidated);
-		const conversation = yield* Ref.get(state).pipe(Effect.flatMap((current) => findConversation(current, request.conversationId)));
-		return ConversationExport.make({
-			format: "effect-agent/conversation@1",
-			conversationId: request.conversationId,
-			tailSequence: conversation.tailSequence,
-			tailDigest: conversation.tailDigest,
-			records: conversation.records
-		});
-	}));
-	const inspectTail = Effect.fn("MemoryConversationStore.inspectTail")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(ConversationTailRequest, "inspectTail", unvalidated);
-		const conversation = yield* Ref.get(state).pipe(Effect.flatMap((current) => findConversation(current, request.conversationId)));
-		return ConversationTail.make({
-			conversationId: request.conversationId,
-			tailSequence: conversation.tailSequence,
-			tailDigest: conversation.tailDigest,
-			producerEpoch: conversation.producerEpoch
-		});
-	}));
-	const saveCheckpoint = Effect.fn("MemoryConversationStore.saveCheckpoint")((unvalidated) => Effect.gen(function* () {
-		yield* validateCheckpointVersion(unvalidated);
-		const request = yield* validate(SaveCheckpointRequest, "saveCheckpoint", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const checkpoint = request.checkpoint;
-			const conversation = current.conversations.get(checkpoint.conversationId);
-			if (conversation === void 0) return [{
-				_tag: "failure",
-				error: ConversationNotMaterialized.make({ conversationId: checkpoint.conversationId })
-			}, current];
-			if (checkpoint.throughSequence > conversation.tailSequence) return [{
-				_tag: "failure",
-				error: CheckpointRejected.make({
-					conversationId: checkpoint.conversationId,
-					reason: "ahead-of-tail"
-				})
-			}, current];
-			if (conversation.tailDigests.get(checkpoint.throughSequence) !== checkpoint.tailDigest) return [{
-				_tag: "failure",
-				error: CheckpointRejected.make({
-					conversationId: checkpoint.conversationId,
-					reason: "digest-mismatch"
-				})
-			}, current];
-			if (!conversation.checkpoints.has(checkpoint.throughSequence) && conversation.checkpoints.size >= MAX_CHECKPOINTS_PER_CONVERSATION) return [{
-				_tag: "failure",
-				error: storeError("saveCheckpoint", `In-memory checkpoint limit ${MAX_CHECKPOINTS_PER_CONVERSATION} exceeded`)
-			}, current];
-			const checkpoints = new Map(conversation.checkpoints);
-			checkpoints.set(checkpoint.throughSequence, checkpoint);
-			const conversations = new Map(current.conversations);
-			conversations.set(checkpoint.conversationId, {
-				...conversation,
-				checkpoints
-			});
-			return [{ _tag: "success" }, { conversations }];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
-	}));
-	const loadCheckpoint = Effect.fn("MemoryConversationStore.loadCheckpoint")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(LoadCheckpointRequest, "loadCheckpoint", unvalidated);
-		const conversation = yield* Ref.get(state).pipe(Effect.flatMap((current) => findConversation(current, request.conversationId)));
-		const maximum = request.atOrBeforeSequence ?? conversation.tailSequence;
-		let selected;
-		for (const [sequence, checkpoint] of conversation.checkpoints) if (sequence <= maximum && (selected === void 0 || sequence > selected.throughSequence)) selected = checkpoint;
-		if (selected !== void 0 && conversation.tailDigests.get(selected.throughSequence) !== selected.tailDigest) return yield* CheckpointRejected.make({
-			conversationId: request.conversationId,
-			reason: "digest-mismatch"
-		});
-		return Option.fromNullishOr(selected);
-	}));
-	return ConversationStore.of({
-		materialize,
-		append,
-		read,
-		observe,
-		export: exportConversation,
-		inspectTail,
-		saveCheckpoint,
-		loadCheckpoint
-	});
-});
-const MemoryConversationStoreLive = Layer.effect(ConversationStore, makeConversationStore);
-/**
-* In-memory canonical Conversation persistence. Durable accepted work is served by the separate
-* SubmissionLedger port; this Layer deliberately provides only the ConversationStore.
-*/
-const MemoryStorageLive = MemoryConversationStoreLive;
-//#endregion
-export { MemoryConversationStoreLive, MemoryStorageLive, MemorySubmissionLedgerLive, memorySubmissionLedgerLayer };
-
-//# sourceMappingURL=index.mjs.map
+import { t as MemoryScheduleStore_exports } from "./MemoryScheduleStore.mjs";
+import { t as MemoryMessageDeliveryStore_exports } from "./MemoryMessageDeliveryStore.mjs";
+import { t as MemorySemanticIndex_exports } from "./MemorySemanticIndex.mjs";
+import { t as MemorySubmissionLedger_exports } from "./MemorySubmissionLedger.mjs";
+import { t as MemorySubscriptionStore_exports } from "./MemorySubscriptionStore.mjs";
+import { t as MemoryThreadStore_exports } from "./MemoryThreadStore.mjs";
+export { MemoryMessageDeliveryStore_exports as MemoryMessageDeliveryStore, MemoryScheduleStore_exports as MemoryScheduleStore, MemorySemanticIndex_exports as MemorySemanticIndex, MemorySubmissionLedger_exports as MemorySubmissionLedger, MemorySubscriptionStore_exports as MemorySubscriptionStore, MemoryThreadStore_exports as MemoryThreadStore };