@effect-agent/storage-cloudflare 0.1.0-beta.8 → 0.1.0-beta.80

package/dist/index.mjs

@@ -1,3695 +1,14 @@
-import { AbortCommand, AbortIntent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResolution, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecision, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildReservationStatus, ChildSettledNotification, ChildSettledOutcome, Claim, ClaimJoiningRequest, ClaimRequest, ConversationCheckpoint, ConversationExport, ConversationExportRequest, ConversationMaterialization, ConversationNotMaterialized, ConversationObservation, ConversationRead, ConversationStore, ConversationStoreError, ConversationTail, ConversationTailRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, Digest, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, ParentLinkage, PersistedJson, ProducerEpoch, QueueSequence, RecordEnvelope, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, Settlement, SettlementConflict, SettlementFinalization, SettlementOutcome, SettlementReservation, SettlementReservationSnapshot, SubmissionLedger, SubmissionLookup, SubmissionLookupById, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SuspendRequest, SuspensionReason, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, digestCanonicalBatch, submissionAbortRecordId } from "@effect-agent/session";
-import { Clock, Context, Crypto, DateTime, Duration, Effect, Layer, Option, Ref, Schema, Stream } from "effect";
-import { SqliteClient, SqliteMigrator } from "@effect/sql-sqlite-do";
-import * as SqlClient from "effect/unstable/sql/SqlClient";
-import { BrowserCrypto } from "@effect/platform-browser";
-import { SqlError } from "effect/unstable/sql/SqlError";
-//#region src/errors.ts
-/** The Durable Object's SQLite storage uses a private-development format this adapter cannot read. */
-var DoStorageCompatibilityError = class extends Schema.TaggedError()("DoStorageCompatibilityError", {
-	actualVersion: Schema.Int,
-	message: Schema.String,
-	supportedVersion: Schema.Int
-}) {};
-/** Stored bytes failed the current Schema and cannot be used as recovery truth. */
-var DoStorageCorruptionError = class extends Schema.TaggedError()("DoStorageCorruptionError", {
-	message: Schema.String,
-	rowKey: Schema.String,
-	table: Schema.String
-}) {};
-/** Durable Object SQLite infrastructure failed while opening or operating the store. */
-var DoStorageError = class extends Schema.TaggedError()("DoStorageError", {
-	cause: Schema.optionalKey(Schema.Defect()),
-	message: Schema.String,
-	operation: Schema.String
-}) {};
-/**
-* Durable Object SQLite infrastructure failed while operating the Submission Ledger. Surfaces
-* at the SubmissionLedger port as the typed `LedgerError` with this error preserved as its
-* cause, so the adapter-level tag is never erased.
-*/
-var DoLedgerError = class extends Schema.TaggedError()("DoLedgerError", {
-	cause: Schema.optionalKey(Schema.Defect()),
-	message: Schema.String,
-	operation: Schema.String
-}) {};
-/**
-* A value to be stored exceeds the configured Durable Object per-value bound
-* (`DoStorageConfigValue.maxStoredValueBytes`, kept under the platform's 2 MB SQLite value
-* limit). The refusal happens typed BEFORE any durable mutation; no partial state is written.
-* Payloads of this size are the designed overflow case for a future R2-backed AttachmentStore
-* (deployment spec §3.1, deferred until a real attachment requirement exists).
-*/
-var DoValueBoundExceeded = class extends Schema.TaggedError()("DoValueBoundExceeded", {
-	actualBytes: Schema.Int,
-	maxBytes: Schema.Int,
-	operation: Schema.String
-}) {
-	get message() {
-		return `A stored value of ${this.actualBytes} bytes exceeds the Durable Object per-value bound of ${this.maxBytes} bytes during ${this.operation}. Nothing was written. Values of this size are the designed R2 AttachmentStore overflow path (deferred, deployment spec §3.1).`;
-	}
-};
-/**
-* A canonical batch retry conflicts with existing append state. Tail conflicts carry the
-* actual committed tail as a diagnostic resume hint.
-*/
-var DoAppendConflict = class extends Schema.TaggedError()("DoAppendConflict", {
-	message: Schema.String,
-	reason: Schema.Literals([
-		"batch-digest",
-		"record-identity",
-		"tail"
-	]),
-	actualTailSequence: Schema.optionalKey(CanonicalSequence),
-	actualTailDigest: Schema.optionalKey(Schema.String)
-}) {};
-/**
-* A producer epoch does not match the Conversation's current writer registration. Appends
-* require the exact registered epoch, so both older and newer unregistered epochs are fenced;
-* a newer epoch takes over by materializing first.
-*/
-var DoFenceRejected = class extends Schema.TaggedError()("DoFenceRejected", {
-	actualEpoch: ProducerEpoch,
-	message: Schema.String,
-	producerEpoch: ProducerEpoch
-}) {};
-/** A checkpoint conflicts with a previously stored checkpoint at the same offset. */
-var DoCheckpointConflict = class extends Schema.TaggedError()("DoCheckpointConflict", { message: Schema.String }) {};
-/**
-* Deterministic fault-injection locations at Durable Object storage operation boundaries.
-*
-* The string list is copied VERBATIM from `SqliteStorageFailpointLocation`
-* (`packages/storage-sqlite/src/errors.ts`) so every crash-matrix row keeps the same name on
-* both platforms — the DN process-kill evidence and the DC eviction evidence address identical
-* locations. There is intentionally no Cloudflare-only location.
-*/
-const DoStorageFailpointLocation = Schema.Literals([
-	"materialize:before",
-	"materialize:after",
-	"append:before",
-	"append:after-batch-insert",
-	"append:after-record-insert",
-	"append:after-tail-update",
-	"append:after",
-	"export:after-conversation-read",
-	"save-checkpoint:before",
-	"save-checkpoint:after",
-	"ledger:admit:before",
-	"ledger:admit:after",
-	"ledger:mark-ready:before",
-	"ledger:mark-ready:after",
-	"ledger:claim:before",
-	"ledger:claim:after",
-	"ledger:mark-input-applied:before",
-	"ledger:mark-input-applied:after",
-	"ledger:renew:before",
-	"ledger:renew:after",
-	"ledger:reserve-settlement:before",
-	"ledger:reserve-settlement:after",
-	"ledger:finalize-settlement:before",
-	"ledger:finalize-settlement:after",
-	"ledger:request-abort:before",
-	"ledger:request-abort:after",
-	"ledger:release:before",
-	"ledger:release:after",
-	"ledger:claim-joining:before",
-	"ledger:claim-joining:after",
-	"ledger:mark-joined:before",
-	"ledger:mark-joined:after",
-	"ledger:revert-joining:before",
-	"ledger:revert-joining:after",
-	"ledger:suspend:before",
-	"ledger:suspend:after",
-	"ledger:approval-decision:before",
-	"ledger:approval-decision:after",
-	"ledger:mark-unknown:before",
-	"ledger:mark-unknown:after",
-	"ledger:unknown-resolution:before",
-	"ledger:unknown-resolution:after",
-	"ledger:child-reservation:before",
-	"ledger:child-reservation:after",
-	"ledger:child-attach:before",
-	"ledger:child-attach:after",
-	"ledger:child-release-pending:before",
-	"ledger:child-release-pending:after",
-	"ledger:child-release:before",
-	"ledger:child-release:after",
-	"ledger:child-settled:before",
-	"ledger:child-settled:after"
-]);
-/** Deterministic test-only fault or pause injected at a Durable Object storage boundary. */
-var DoStorageFailpointError = class extends Schema.TaggedError()("DoStorageFailpointError", { location: DoStorageFailpointLocation }) {
-	get message() {
-		return `Injected Durable Object storage failure at ${this.location}.`;
-	}
-};
-//#endregion
-//#region src/migrations.ts
-/**
-* The exact-or-fresh storage version recorded in `effect_agent_meta`. Cloudflare is a fresh
-* platform, so there is exactly ONE migration carrying the complete current schema — no
-* v1→v4 history to replay (deployment spec §9: no rolling data-version promise during
-* private development).
-*/
-const CurrentDoStorageVersion = 1;
-/**
-* The Conversation Durable Object schema. Table names and columns mirror the Node/SQLite v4
-* schema byte-for-byte (`packages/storage-sqlite/src/migrations.ts`, migrations 1–4 collapsed
-* into their final shape) so the shared conformance suites and crash-matrix rows address
-* identical durable state. Two DC-specific additions:
-*
-* 1. `effect_agent_meta` replaces `PRAGMA user_version` as the exact-or-fresh version gate —
-*    a meta table is portable regardless of which PRAGMAs Durable Object SQL storage allows.
-* 2. `effect_agent_child_settlements` is the durable cross-store notification marker the
-*    SubmissionLedger port contract mandates for cross-store adapters (`suspend`'s covering
-*    check and `recordChildSettled`'s wake both consult it): parent and child Conversations
-*    live in different Durable Objects, so a child settlement reported before the parent's
-*    suspend commits must be observable from the PARENT's own storage.
-*/
-const doMigrations = SqliteMigrator.fromRecord({ "1_current_cloudflare_conversation_object": Effect.gen(function* () {
-	const sql = yield* SqlClient.SqlClient;
-	yield* sql`
-      CREATE TABLE effect_agent_conversations (
-        conversation_id TEXT PRIMARY KEY NOT NULL,
-        created_at TEXT NOT NULL,
-        tail_sequence INTEGER NOT NULL,
-        tail_digest TEXT NOT NULL,
-        producer_epoch INTEGER NOT NULL
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_canonical_batches (
-        conversation_id TEXT NOT NULL,
-        batch_id TEXT NOT NULL,
-        first_sequence INTEGER NOT NULL,
-        last_sequence INTEGER NOT NULL,
-        batch_digest TEXT NOT NULL,
-        tail_digest TEXT NOT NULL,
-        batch_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, batch_id),
-        FOREIGN KEY (conversation_id)
-          REFERENCES effect_agent_conversations(conversation_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_canonical_records (
-        conversation_id TEXT NOT NULL,
-        sequence INTEGER NOT NULL,
-        record_id TEXT NOT NULL,
-        batch_id TEXT NOT NULL,
-        record_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, sequence),
-        UNIQUE (conversation_id, record_id),
-        FOREIGN KEY (conversation_id, batch_id)
-          REFERENCES effect_agent_canonical_batches(conversation_id, batch_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE INDEX effect_agent_canonical_records_batch
-        ON effect_agent_canonical_records (conversation_id, batch_id, sequence)
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_checkpoints (
-        conversation_id TEXT NOT NULL,
-        through_sequence INTEGER NOT NULL,
-        tail_digest TEXT NOT NULL,
-        checkpoint_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, through_sequence),
-        FOREIGN KEY (conversation_id)
-          REFERENCES effect_agent_conversations(conversation_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_submissions (
-        submission_id TEXT PRIMARY KEY NOT NULL,
-        conversation_id TEXT NOT NULL,
-        queue_sequence INTEGER NOT NULL,
-        principal TEXT NOT NULL,
-        idempotency_key TEXT NOT NULL,
-        agent_id TEXT NOT NULL,
-        agent_digests_json TEXT NOT NULL,
-        deployment_id TEXT NOT NULL,
-        input_json TEXT NOT NULL,
-        input_digest TEXT NOT NULL,
-        receipt_id TEXT NOT NULL,
-        state TEXT NOT NULL,
-        settled_outcome TEXT,
-        created_at TEXT NOT NULL,
-        ready_at TEXT,
-        input_applied_record_id TEXT,
-        input_applied_sequence INTEGER,
-        joined_host_submission_id TEXT,
-        suspended_reason_json TEXT,
-        suspended_at TEXT,
-        unknown_reason TEXT,
-        unknown_tool_call_ids_json TEXT,
-        parent_submission_id TEXT,
-        parent_tool_call_id TEXT,
-        UNIQUE (conversation_id, principal, idempotency_key),
-        UNIQUE (conversation_id, queue_sequence)
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE INDEX effect_agent_submissions_joined_host
-        ON effect_agent_submissions (joined_host_submission_id)
-    `.withoutTransform;
-	yield* sql`
-      CREATE INDEX effect_agent_submissions_parent
-        ON effect_agent_submissions (parent_submission_id)
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_submission_ownership (
-        submission_id TEXT PRIMARY KEY NOT NULL,
-        attempt_id TEXT NOT NULL,
-        ownership_token TEXT NOT NULL,
-        producer_epoch INTEGER NOT NULL,
-        owner_producer_id TEXT NOT NULL,
-        lease_expires_at TEXT NOT NULL,
-        FOREIGN KEY (submission_id)
-          REFERENCES effect_agent_submissions(submission_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_attempts (
-        attempt_id TEXT PRIMARY KEY NOT NULL,
-        submission_id TEXT NOT NULL,
-        conversation_id TEXT NOT NULL,
-        owner_producer_id TEXT NOT NULL,
-        producer_epoch INTEGER NOT NULL,
-        claimed_at TEXT NOT NULL,
-        FOREIGN KEY (submission_id)
-          REFERENCES effect_agent_submissions(submission_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_settlement_reservations (
-        submission_id TEXT PRIMARY KEY NOT NULL,
-        settlement_id TEXT NOT NULL,
-        outcome TEXT NOT NULL,
-        record_id TEXT NOT NULL,
-        record_json TEXT NOT NULL,
-        record_digest TEXT NOT NULL,
-        reserved_at TEXT NOT NULL,
-        finalized_at TEXT,
-        FOREIGN KEY (submission_id)
-          REFERENCES effect_agent_submissions(submission_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_abort_intents (
-        submission_id TEXT PRIMARY KEY NOT NULL,
-        author TEXT NOT NULL,
-        reason TEXT NOT NULL,
-        requested_at TEXT NOT NULL,
-        canonical_record_id TEXT,
-        FOREIGN KEY (submission_id)
-          REFERENCES effect_agent_submissions(submission_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_approval_decisions (
-        submission_id TEXT NOT NULL,
-        tool_call_id TEXT NOT NULL,
-        decision TEXT NOT NULL,
-        resolver TEXT NOT NULL,
-        reason TEXT NOT NULL,
-        decided_at TEXT NOT NULL,
-        PRIMARY KEY (submission_id, tool_call_id),
-        FOREIGN KEY (submission_id)
-          REFERENCES effect_agent_submissions(submission_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_unknown_resolutions (
-        submission_id TEXT NOT NULL,
-        tool_call_id TEXT NOT NULL,
-        author TEXT NOT NULL,
-        reason TEXT NOT NULL,
-        resolution_json TEXT NOT NULL,
-        resolved_at TEXT NOT NULL,
-        PRIMARY KEY (submission_id, tool_call_id),
-        FOREIGN KEY (submission_id)
-          REFERENCES effect_agent_submissions(submission_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_child_reservations (
-        reservation_id TEXT PRIMARY KEY NOT NULL,
-        parent_submission_id TEXT NOT NULL,
-        parent_tool_call_id TEXT NOT NULL,
-        child_submission_id TEXT,
-        status TEXT NOT NULL,
-        allocation_json TEXT NOT NULL,
-        allocation_digest TEXT NOT NULL,
-        accounting_json TEXT,
-        reserved_at TEXT NOT NULL,
-        release_began_at TEXT,
-        released_at TEXT,
-        UNIQUE (parent_submission_id, parent_tool_call_id),
-        FOREIGN KEY (parent_submission_id)
-          REFERENCES effect_agent_submissions(submission_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_child_settlements (
-        parent_submission_id TEXT NOT NULL,
-        child_submission_id TEXT NOT NULL,
-        child_outcome TEXT,
-        recorded_at TEXT NOT NULL,
-        PRIMARY KEY (parent_submission_id, child_submission_id)
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_meta (
-        key TEXT PRIMARY KEY NOT NULL,
-        value TEXT NOT NULL
-      )
-    `.withoutTransform;
-	yield* sql`
-      INSERT INTO effect_agent_meta (key, value)
-      VALUES ('storage_version', ${String(1)})
-    `.withoutTransform;
-}) });
-//#endregion
-//#region src/do-journal.ts
-/**
-* Static schema ceiling for stored text columns. Writes are bounded in BYTES by the
-* configured `maxStoredValueBytes` (always ≤ 2,000,000); UTF-8 byte length is never smaller
-* than UTF-16 string length, so any value that passed the byte bound also passes this
-* decode-side character ceiling.
-*/
-const BoundedStoredText$1 = Schema.String.check(Schema.isMaxLength(2e6));
-const BoundedIdentifier$1 = Schema.NonEmptyString.check(Schema.isMaxLength(1024));
-const MAX_RECORDS_PER_CONVERSATION = 65536;
-const MAX_IDENTIFIER_LENGTH$1 = 1024;
-/** Durable Object SQL storage allows at most 100 bound parameters per statement. */
-const MAX_BOUND_PARAMETERS = 100;
-const storedTextBytes = (value) => new TextEncoder().encode(value).byteLength;
-const chunked = (values, size) => {
-	const chunks = [];
-	for (let index = 0; index < values.length; index += size) chunks.push(values.slice(index, index + size));
-	return chunks;
-};
-var DoMetaRow = class extends Schema.Class("DoMetaRow")({ value: Schema.NonEmptyString.check(Schema.isMaxLength(128)) }) {};
-var DoNameRow = class extends Schema.Class("DoNameRow")({ name: BoundedIdentifier$1 }) {};
-var ConversationRow = class extends Schema.Class("ConversationRow")({
-	conversation_id: BoundedIdentifier$1,
-	created_at: Schema.NonEmptyString.check(Schema.isMaxLength(128)),
-	producer_epoch: ProducerEpoch,
-	tail_digest: BoundedStoredText$1,
-	tail_sequence: CanonicalSequence
-}) {};
-var BatchRow = class extends Schema.Class("BatchRow")({
-	batch_digest: BoundedStoredText$1,
-	batch_id: BoundedIdentifier$1,
-	batch_json: BoundedStoredText$1,
-	conversation_id: BoundedIdentifier$1,
-	first_sequence: CanonicalSequence,
-	last_sequence: CanonicalSequence,
-	tail_digest: BoundedStoredText$1
-}) {};
-var RecordRow = class extends Schema.Class("RecordRow")({
-	batch_id: BoundedIdentifier$1,
-	conversation_id: BoundedIdentifier$1,
-	record_id: BoundedIdentifier$1,
-	record_json: BoundedStoredText$1,
-	sequence: CanonicalSequence
-}) {};
-var CheckpointRow = class extends Schema.Class("CheckpointRow")({
-	checkpoint_json: BoundedStoredText$1,
-	conversation_id: BoundedIdentifier$1,
-	tail_digest: BoundedStoredText$1,
-	through_sequence: CanonicalSequence
-}) {};
-var RawRecord = class extends Schema.Class("@effect-agent/storage-cloudflare/RawRecord")({
-	recordId: BoundedIdentifier$1,
-	recordJson: BoundedStoredText$1
-}) {};
-var RawAppendRequest = class extends Schema.Class("@effect-agent/storage-cloudflare/RawAppendRequest")({
-	batchDigest: BoundedStoredText$1,
-	batchId: BoundedIdentifier$1,
-	batchJson: BoundedStoredText$1,
-	conversationId: BoundedIdentifier$1,
-	expectedTailDigest: BoundedStoredText$1,
-	expectedTailSequence: CanonicalSequence,
-	producerEpoch: ProducerEpoch,
-	records: Schema.NonEmptyArray(RawRecord).check(Schema.isMaxLength(256)),
-	tailDigest: BoundedStoredText$1
-}) {};
-var RawAppendResult = class extends Schema.Class("@effect-agent/storage-cloudflare/RawAppendResult")({
-	firstSequence: CanonicalSequence,
-	lastSequence: CanonicalSequence,
-	replayed: Schema.Boolean,
-	tailDigest: BoundedStoredText$1
-}) {};
-var RawReadRequest = class extends Schema.Class("@effect-agent/storage-cloudflare/RawReadRequest")({
-	conversationId: BoundedIdentifier$1,
-	fromSequenceExclusive: CanonicalSequence,
-	limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1024))
-}) {};
-var RawCheckpoint = class extends Schema.Class("@effect-agent/storage-cloudflare/RawCheckpoint")({
-	checkpointJson: BoundedStoredText$1,
-	conversationId: BoundedIdentifier$1,
-	tailDigest: BoundedStoredText$1,
-	throughSequence: CanonicalSequence
-}) {};
-var RawConversationExport = class extends Schema.Class("@effect-agent/storage-cloudflare/RawConversationExport")({
-	batches: Schema.Array(BatchRow),
-	checkpoints: Schema.Array(CheckpointRow),
-	conversation: ConversationRow,
-	records: Schema.Array(RecordRow)
-}) {};
-const noFailpoint$1 = () => Effect.void;
-const storageError = (operation) => (error) => DoStorageError.make({
-	cause: error,
-	operation,
-	message: error.message
-});
-/** Decode raw Durable Object SQLite rows against a Schema, reporting failures as typed corruption. */
-const decodeRows = Effect.fn("DoJournal.decodeRows")((schema, table, rowKey, rows) => Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError((error) => DoStorageCorruptionError.make({
-	table,
-	rowKey,
-	message: String(error)
-}))));
-/** Decode exactly one raw row against a Schema, reporting failures as typed corruption. */
-const decodeSingleRow = Effect.fn("DoJournal.decodeSingleRow")((schema, table, rowKey, rows) => decodeRows(schema, table, rowKey, rows).pipe(Effect.flatMap((decoded) => decoded.length === 1 ? Effect.succeed(decoded[0]) : Effect.fail(DoStorageCorruptionError.make({
-	table,
-	rowKey,
-	message: `Expected exactly one row but found ${decoded.length}.`
-})))));
-const REQUIRED_TABLES = [
-	"effect_agent_abort_intents",
-	"effect_agent_approval_decisions",
-	"effect_agent_attempts",
-	"effect_agent_canonical_batches",
-	"effect_agent_canonical_records",
-	"effect_agent_checkpoints",
-	"effect_agent_child_reservations",
-	"effect_agent_child_settlements",
-	"effect_agent_conversations",
-	"effect_agent_meta",
-	"effect_agent_settlement_reservations",
-	"effect_agent_submission_ownership",
-	"effect_agent_submissions",
-	"effect_agent_unknown_resolutions"
-];
-/**
-* Exact-or-fresh storage gate (DEPLOY-008) over `effect_agent_meta` instead of
-* `PRAGMA user_version` (unverified on Durable Object SQL storage; a meta table is portable
-* regardless). No WAL check (Durable Object storage owns durability and confirms writes
-* through output gates) and no busy timeout (a Durable Object has exactly one writer): the
-* Node machinery those served has no DC analogue and is deliberately absent.
-*/
-const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(function* (sql, failpoint = noFailpoint$1, maxStoredValueBytes) {
-	const metaTableRows = yield* sql`
-    SELECT name
-    FROM sqlite_master
-    WHERE type = 'table'
-      AND name = 'effect_agent_meta'
-  `.pipe(Effect.mapError(storageError("read storage version table")));
-	if ((yield* decodeRows(Schema.Array(DoNameRow), "sqlite_master", "effect_agent_meta", metaTableRows)).length === 0) {
-		const existingRows = yield* sql`
-      SELECT name
-      FROM sqlite_master
-      WHERE type = 'table'
-        AND name LIKE 'effect_agent_%'
-      ORDER BY name
-    `.pipe(Effect.mapError(storageError("inspect unversioned storage")));
-		if ((yield* decodeRows(Schema.Array(DoNameRow), "sqlite_master", "effect_agent_%", existingRows)).length > 0) return yield* DoStorageCompatibilityError.make({
-			actualVersion: 0,
-			supportedVersion: 1,
-			message: "The Durable Object contains unversioned Effect Agent tables. Reset the development namespace explicitly; refusing to mutate ambiguous stored data."
-		});
-		yield* SqliteMigrator.run({ loader: doMigrations }).pipe(Effect.provideService(SqlClient.SqlClient, sql), Effect.mapError((error) => DoStorageError.make({
-			cause: error,
-			operation: "initialize current storage",
-			message: error.message
-		})));
-	} else {
-		const versionRows = yield* sql`
-      SELECT value
-      FROM effect_agent_meta
-      WHERE key = 'storage_version'
-    `.pipe(Effect.mapError(storageError("read storage version")));
-		const version = yield* decodeSingleRow(Schema.Array(DoMetaRow), "effect_agent_meta", "storage_version", versionRows);
-		if (version.value !== String(1)) {
-			const actualVersion = Number.parseInt(version.value, 10);
-			return yield* DoStorageCompatibilityError.make({
-				actualVersion: Number.isSafeInteger(actualVersion) ? actualVersion : -1,
-				supportedVersion: 1,
-				message: `The Durable Object uses private-development storage version ${version.value}; this build supports exactly version 1. Replace the development namespace explicitly; automatic stored-data migrations are not provided during private development.`
-			});
-		}
-	}
-	const requiredRows = yield* sql`
-    SELECT name
-    FROM sqlite_master
-    WHERE type = 'table'
-      AND name IN ${sql.in([...REQUIRED_TABLES])}
-    ORDER BY name
-  `.pipe(Effect.mapError(storageError("verify storage tables")));
-	if ((yield* decodeRows(Schema.Array(DoNameRow), "sqlite_master", "required_tables", requiredRows)).length !== REQUIRED_TABLES.length) return yield* DoStorageCompatibilityError.make({
-		actualVersion: 1,
-		supportedVersion: 1,
-		message: "The Durable Object claims the current format but is missing required tables. Reset the corrupt private-development data."
-	});
-	return makeJournal(sql, failpoint, maxStoredValueBytes);
-});
-const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
-	/** Typed pre-write refusal for any single value over the configured byte bound. */
-	const checkValueBound = (operation, value) => {
-		const actualBytes = storedTextBytes(value);
-		return actualBytes > maxStoredValueBytes ? Effect.fail(DoValueBoundExceeded.make({
-			actualBytes,
-			maxBytes: maxStoredValueBytes,
-			operation
-		})) : Effect.void;
-	};
-	/**
-	* Runs one journal write transaction on the Durable Object storage-backed
-	* `withTransaction` (`ctx.storage.transaction()` under the hood). Within one Durable
-	* Object there is exactly ONE writer, so the Node `BEGIN IMMEDIATE` + busy-retry +
-	* `SqliteWriteContention` machinery has no analogue here and is deliberately absent.
-	* Ownership-token and epoch checks still run INSIDE the transaction, so fencing atomicity
-	* (DUR-006) is preserved identically.
-	*
-	* Journal write transactions are always top level: the Durable Object client rejects
-	* nested transactions, so new journal operations must not wrap this helper inside another
-	* transaction.
-	*/
-	const withWriteTransaction = (operation) => (effect) => sql.withTransaction(effect).pipe(Effect.mapError((error) => error instanceof SqlError ? storageError(operation)(error) : error), Effect.withSpan("DoJournal.withWriteTransaction", { attributes: { operation } }));
-	const materialize = Effect.fn("DoJournal.materialize")(function* (conversationId, createdAt, emptyTailDigest, producerEpoch) {
-		if (conversationId.length > MAX_IDENTIFIER_LENGTH$1) return yield* DoStorageError.make({
-			operation: "materialize conversation",
-			message: "Conversation identity exceeds the Durable Object storage bounds."
-		});
-		yield* checkValueBound("materialize conversation", emptyTailDigest);
-		yield* withWriteTransaction("materialize transaction")(Effect.gen(function* () {
-			const existingRows = yield* sql`
-          SELECT
-            conversation_id,
-            created_at,
-            tail_sequence,
-            tail_digest,
-            producer_epoch
-          FROM effect_agent_conversations
-          WHERE conversation_id = ${conversationId}
-        `.pipe(Effect.mapError(storageError("read materialized conversation")));
-			const existing = yield* decodeRows(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, existingRows);
-			if (existing.length > 1) return yield* DoStorageCorruptionError.make({
-				table: "effect_agent_conversations",
-				rowKey: conversationId,
-				message: "A conversation primary key returned more than one row."
-			});
-			if (existing.length === 0) {
-				yield* sql`
-            INSERT INTO effect_agent_conversations (
-              conversation_id,
-              created_at,
-              tail_sequence,
-              tail_digest,
-              producer_epoch
-            ) VALUES (
-              ${conversationId},
-              ${createdAt},
-              0,
-              ${emptyTailDigest},
-              ${producerEpoch}
-            )
-          `.pipe(Effect.mapError(storageError("materialize conversation")));
-				return;
-			}
-			if (producerEpoch < existing[0].producer_epoch) return yield* DoFenceRejected.make({
-				producerEpoch,
-				actualEpoch: existing[0].producer_epoch,
-				message: `Producer epoch ${producerEpoch} is stale; current epoch is ${existing[0].producer_epoch}.`
-			});
-			if (producerEpoch > existing[0].producer_epoch) yield* sql`
-            UPDATE effect_agent_conversations
-            SET producer_epoch = ${producerEpoch}
-            WHERE conversation_id = ${conversationId}
-          `.pipe(Effect.mapError(storageError("advance materialization epoch")));
-		}));
-	});
-	const getConversation = Effect.fn("DoJournal.getConversation")(function* (conversationId) {
-		const rows = yield* sql`
-      SELECT
-        conversation_id,
-        created_at,
-        tail_sequence,
-        tail_digest,
-        producer_epoch
-      FROM effect_agent_conversations
-      WHERE conversation_id = ${conversationId}
-    `.pipe(Effect.mapError(storageError("read conversation")));
-		return yield* decodeRows(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, rows);
-	});
-	const append = Effect.fn("DoJournal.append")(function* (request) {
-		if (request.conversationId.length > MAX_IDENTIFIER_LENGTH$1 || request.batchId.length > MAX_IDENTIFIER_LENGTH$1 || request.records.some((record) => record.recordId.length > MAX_IDENTIFIER_LENGTH$1)) return yield* DoStorageError.make({
-			operation: "append canonical batch",
-			message: "Canonical identifiers exceed the Durable Object storage bounds."
-		});
-		yield* checkValueBound("append canonical batch", request.batchJson);
-		yield* checkValueBound("append canonical batch", request.batchDigest);
-		yield* checkValueBound("append canonical batch", request.tailDigest);
-		yield* Effect.forEach(request.records, (record) => checkValueBound("append canonical record", record.recordJson), { discard: true });
-		return yield* withWriteTransaction("append transaction")(Effect.gen(function* () {
-			const recordIds = request.records.map((record) => record.recordId);
-			if (new Set(recordIds).size !== recordIds.length) return yield* DoAppendConflict.make({
-				message: `Batch ${request.batchId} contains duplicate canonical record IDs.`,
-				reason: "record-identity"
-			});
-			const conversationRows = yield* sql`
-          SELECT
-            conversation_id,
-            created_at,
-            tail_sequence,
-            tail_digest,
-            producer_epoch
-          FROM effect_agent_conversations
-          WHERE conversation_id = ${request.conversationId}
-        `.pipe(Effect.mapError(storageError("read append tail")));
-			const conversation = yield* decodeSingleRow(Schema.Array(ConversationRow), "effect_agent_conversations", request.conversationId, conversationRows);
-			if (request.producerEpoch !== conversation.producer_epoch) return yield* DoFenceRejected.make({
-				producerEpoch: request.producerEpoch,
-				actualEpoch: conversation.producer_epoch,
-				message: `Producer epoch ${request.producerEpoch} is not the current epoch ${conversation.producer_epoch}.`
-			});
-			const batchRows = yield* sql`
-          SELECT
-            conversation_id,
-            batch_id,
-            first_sequence,
-            last_sequence,
-            batch_digest,
-            tail_digest,
-            batch_json
-          FROM effect_agent_canonical_batches
-          WHERE conversation_id = ${request.conversationId}
-            AND batch_id = ${request.batchId}
-        `.pipe(Effect.mapError(storageError("read idempotent batch")));
-			const batches = yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${request.conversationId}/${request.batchId}`, batchRows);
-			if (batches.length > 1) return yield* DoStorageCorruptionError.make({
-				table: "effect_agent_canonical_batches",
-				rowKey: `${request.conversationId}/${request.batchId}`,
-				message: "A canonical batch primary key returned more than one row."
-			});
-			if (batches.length === 1) {
-				const existing = batches[0];
-				if (existing.batch_digest !== request.batchDigest) return yield* DoAppendConflict.make({
-					message: `Batch ${request.batchId} already exists with different canonical content.`,
-					reason: "batch-digest"
-				});
-				return RawAppendResult.make({
-					firstSequence: existing.first_sequence,
-					lastSequence: existing.last_sequence,
-					replayed: true,
-					tailDigest: existing.tail_digest
-				});
-			}
-			if (request.expectedTailSequence !== conversation.tail_sequence || request.expectedTailDigest !== conversation.tail_digest) return yield* DoAppendConflict.make({
-				message: `Expected tail ${request.expectedTailSequence}/${request.expectedTailDigest} but found ${conversation.tail_sequence}/${conversation.tail_digest}.`,
-				reason: "tail",
-				actualTailSequence: conversation.tail_sequence,
-				actualTailDigest: conversation.tail_digest
-			});
-			if (conversation.tail_sequence + request.records.length > MAX_RECORDS_PER_CONVERSATION) return yield* DoStorageError.make({
-				operation: "append canonical batch",
-				message: `Conversation record limit ${MAX_RECORDS_PER_CONVERSATION} would be exceeded.`
-			});
-			const existingRecords = [];
-			for (const chunk of chunked(recordIds, MAX_BOUND_PARAMETERS - 10)) {
-				const existingRecordRows = yield* sql`
-            SELECT
-              conversation_id,
-              sequence,
-              record_id,
-              batch_id,
-              record_json
-            FROM effect_agent_canonical_records
-            WHERE conversation_id = ${request.conversationId}
-              AND record_id IN ${sql.in([...chunk])}
-            ORDER BY sequence
-          `.pipe(Effect.mapError(storageError("check canonical record identities")));
-				existingRecords.push(...yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}/record_ids`, existingRecordRows));
-			}
-			if (existingRecords.length > 0) return yield* DoAppendConflict.make({
-				message: `Canonical record ID ${existingRecords[0].record_id} already exists.`,
-				reason: "record-identity"
-			});
-			const firstSequence = yield* Schema.decodeUnknownEffect(CanonicalSequence)(conversation.tail_sequence + 1).pipe(Effect.mapError((error) => DoStorageError.make({
-				cause: error,
-				operation: "append canonical batch",
-				message: error.message
-			})));
-			const lastSequence = yield* Schema.decodeUnknownEffect(CanonicalSequence)(firstSequence + request.records.length - 1).pipe(Effect.mapError((error) => DoStorageError.make({
-				cause: error,
-				operation: "append canonical batch",
-				message: error.message
-			})));
-			yield* sql`
-          INSERT INTO effect_agent_canonical_batches (
-            conversation_id,
-            batch_id,
-            first_sequence,
-            last_sequence,
-            batch_digest,
-            tail_digest,
-            batch_json
-          ) VALUES (
-            ${request.conversationId},
-            ${request.batchId},
-            ${firstSequence},
-            ${lastSequence},
-            ${request.batchDigest},
-            ${request.tailDigest},
-            ${request.batchJson}
-          )
-        `.pipe(Effect.mapError(storageError("insert canonical batch")));
-			yield* failpoint("append:after-batch-insert");
-			yield* Effect.forEach(request.records, (record, index) => Effect.gen(function* () {
-				yield* sql`
-                  INSERT INTO effect_agent_canonical_records (
-                    conversation_id,
-                    sequence,
-                    record_id,
-                    batch_id,
-                    record_json
-                  ) VALUES (
-                    ${request.conversationId},
-                    ${firstSequence + index},
-                    ${record.recordId},
-                    ${request.batchId},
-                    ${record.recordJson}
-                  )
-                `.pipe(Effect.mapError(storageError("insert canonical record")));
-				yield* failpoint("append:after-record-insert");
-			}), { discard: true });
-			yield* sql`
-          UPDATE effect_agent_conversations
-          SET
-            tail_sequence = ${lastSequence},
-            tail_digest = ${request.tailDigest},
-            producer_epoch = ${request.producerEpoch}
-          WHERE conversation_id = ${request.conversationId}
-        `.pipe(Effect.mapError(storageError("advance conversation tail")));
-			yield* failpoint("append:after-tail-update");
-			return RawAppendResult.make({
-				firstSequence,
-				lastSequence,
-				replayed: false,
-				tailDigest: request.tailDigest
-			});
-		}));
-	});
-	const read = Effect.fn("DoJournal.read")(function* (request) {
-		const rows = yield* sql`
-      SELECT
-        conversation_id,
-        sequence,
-        record_id,
-        batch_id,
-        record_json
-      FROM effect_agent_canonical_records
-      WHERE conversation_id = ${request.conversationId}
-        AND sequence > ${request.fromSequenceExclusive}
-      ORDER BY sequence
-      LIMIT ${request.limit}
-    `.pipe(Effect.mapError(storageError("read canonical records")));
-		return yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}>${request.fromSequenceExclusive}`, rows);
-	});
-	const exportConversation = Effect.fn("DoJournal.exportConversation")(function* (conversationId) {
-		return yield* sql.withTransaction(Effect.gen(function* () {
-			const conversationRows = yield* sql`
-            SELECT
-              conversation_id,
-              created_at,
-              tail_sequence,
-              tail_digest,
-              producer_epoch
-            FROM effect_agent_conversations
-            WHERE conversation_id = ${conversationId}
-          `.pipe(Effect.mapError(storageError("export conversation")));
-			const conversation = yield* decodeSingleRow(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, conversationRows);
-			yield* failpoint("export:after-conversation-read");
-			const batchRows = yield* sql`
-            SELECT
-              conversation_id,
-              batch_id,
-              first_sequence,
-              last_sequence,
-              batch_digest,
-              tail_digest,
-              batch_json
-            FROM effect_agent_canonical_batches
-            WHERE conversation_id = ${conversationId}
-            ORDER BY first_sequence
-          `.pipe(Effect.mapError(storageError("export canonical batches")));
-			const recordRows = yield* sql`
-            SELECT
-              conversation_id,
-              sequence,
-              record_id,
-              batch_id,
-              record_json
-            FROM effect_agent_canonical_records
-            WHERE conversation_id = ${conversationId}
-            ORDER BY sequence
-          `.pipe(Effect.mapError(storageError("export canonical records")));
-			const checkpointRows = yield* sql`
-            SELECT
-              conversation_id,
-              through_sequence,
-              tail_digest,
-              checkpoint_json
-            FROM effect_agent_checkpoints
-            WHERE conversation_id = ${conversationId}
-            ORDER BY through_sequence
-          `.pipe(Effect.mapError(storageError("export checkpoints")));
-			return RawConversationExport.make({
-				conversation,
-				batches: yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", conversationId, batchRows),
-				records: yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", conversationId, recordRows),
-				checkpoints: yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", conversationId, checkpointRows)
-			});
-		})).pipe(Effect.catchTag("SqlError", (error) => Effect.fail(storageError("export transaction")(error))));
-	});
-	const saveCheckpoint = Effect.fn("DoJournal.saveCheckpoint")(function* (checkpoint) {
-		if (checkpoint.conversationId.length > MAX_IDENTIFIER_LENGTH$1) return yield* DoStorageError.make({
-			operation: "save checkpoint",
-			message: "Checkpoint identity exceeds the Durable Object storage bounds."
-		});
-		yield* checkValueBound("save checkpoint", checkpoint.checkpointJson);
-		yield* withWriteTransaction("checkpoint transaction")(Effect.gen(function* () {
-			const conversationRows = yield* sql`
-          SELECT
-            conversation_id,
-            created_at,
-            tail_sequence,
-            tail_digest,
-            producer_epoch
-          FROM effect_agent_conversations
-          WHERE conversation_id = ${checkpoint.conversationId}
-        `.pipe(Effect.mapError(storageError("read checkpoint tail")));
-			const conversation = yield* decodeSingleRow(Schema.Array(ConversationRow), "effect_agent_conversations", checkpoint.conversationId, conversationRows);
-			if (checkpoint.throughSequence > conversation.tail_sequence) return yield* DoCheckpointConflict.make({ message: `Checkpoint sequence ${checkpoint.throughSequence} is after canonical tail ${conversation.tail_sequence}.` });
-			const checkpointRows = yield* sql`
-          SELECT
-            conversation_id,
-            through_sequence,
-            tail_digest,
-            checkpoint_json
-          FROM effect_agent_checkpoints
-          WHERE conversation_id = ${checkpoint.conversationId}
-            AND through_sequence = ${checkpoint.throughSequence}
-        `.pipe(Effect.mapError(storageError("read idempotent checkpoint")));
-			const existing = yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${checkpoint.conversationId}/${checkpoint.throughSequence}`, checkpointRows);
-			if (existing.length > 1) return yield* DoStorageCorruptionError.make({
-				table: "effect_agent_checkpoints",
-				rowKey: `${checkpoint.conversationId}/${checkpoint.throughSequence}`,
-				message: "A checkpoint primary key returned more than one row."
-			});
-			if (existing.length === 1) {
-				if (existing[0].tail_digest !== checkpoint.tailDigest || existing[0].checkpoint_json !== checkpoint.checkpointJson) return yield* DoCheckpointConflict.make({ message: "A different checkpoint already exists at this canonical sequence." });
-				return;
-			}
-			yield* sql`
-          INSERT INTO effect_agent_checkpoints (
-            conversation_id,
-            through_sequence,
-            tail_digest,
-            checkpoint_json
-          ) VALUES (
-            ${checkpoint.conversationId},
-            ${checkpoint.throughSequence},
-            ${checkpoint.tailDigest},
-            ${checkpoint.checkpointJson}
-          )
-        `.pipe(Effect.mapError(storageError("insert checkpoint")));
-		}));
-	});
-	const loadCheckpoint = Effect.fn("DoJournal.loadCheckpoint")(function* (conversationId, atOrBeforeSequence) {
-		const rows = yield* sql`
-      SELECT
-        conversation_id,
-        through_sequence,
-        tail_digest,
-        checkpoint_json
-      FROM effect_agent_checkpoints
-      WHERE conversation_id = ${conversationId}
-        AND through_sequence <= ${atOrBeforeSequence}
-      ORDER BY through_sequence DESC
-      LIMIT 1
-    `.pipe(Effect.mapError(storageError("load checkpoint")));
-		return yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${conversationId}<=${atOrBeforeSequence}`, rows);
-	});
-	return {
-		append,
-		checkValueBound,
-		exportConversation,
-		getConversation,
-		getTailDigestAt: Effect.fn("DoJournal.getTailDigestAt")(function* (conversationId, sequence) {
-			if (sequence === 0) {
-				const conversations = yield* getConversation(conversationId);
-				return conversations.length === 0 ? [] : [conversations[0].tail_sequence === 0 ? conversations[0].tail_digest : void 0].filter((value) => value !== void 0);
-			}
-			const rows = yield* sql`
-      SELECT
-        conversation_id,
-        batch_id,
-        first_sequence,
-        last_sequence,
-        batch_digest,
-        tail_digest,
-        batch_json
-      FROM effect_agent_canonical_batches
-      WHERE conversation_id = ${conversationId}
-        AND last_sequence = ${sequence}
-    `.pipe(Effect.mapError(storageError("read canonical digest at sequence")));
-			return (yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${conversationId}/${sequence}`, rows)).map((batch) => batch.tail_digest);
-		}),
-		loadCheckpoint,
-		materialize,
-		read,
-		saveCheckpoint,
-		scanStoredPayloads: Effect.fn("DoJournal.scanStoredPayloads")(function* () {
-			return yield* sql.withTransaction(Effect.gen(function* () {
-				const conversations = yield* sql`
-            SELECT
-              conversation_id,
-              created_at,
-              tail_sequence,
-              tail_digest,
-              producer_epoch
-            FROM effect_agent_conversations
-            ORDER BY conversation_id
-          `.pipe(Effect.mapError(storageError("scan conversations")));
-				const batches = yield* sql`
-            SELECT
-              conversation_id,
-              batch_id,
-              first_sequence,
-              last_sequence,
-              batch_digest,
-              tail_digest,
-              batch_json
-            FROM effect_agent_canonical_batches
-            ORDER BY conversation_id, first_sequence
-          `.pipe(Effect.mapError(storageError("scan canonical batches")));
-				const records = yield* sql`
-            SELECT
-              conversation_id,
-              sequence,
-              record_id,
-              batch_id,
-              record_json
-            FROM effect_agent_canonical_records
-            ORDER BY conversation_id, sequence
-          `.pipe(Effect.mapError(storageError("scan canonical records")));
-				const checkpoints = yield* sql`
-            SELECT
-              conversation_id,
-              through_sequence,
-              tail_digest,
-              checkpoint_json
-            FROM effect_agent_checkpoints
-            ORDER BY conversation_id, through_sequence
-          `.pipe(Effect.mapError(storageError("scan checkpoints")));
-				return {
-					conversations: yield* decodeRows(Schema.Array(ConversationRow), "effect_agent_conversations", "startup_scan", conversations),
-					batches: yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", "startup_scan", batches),
-					records: yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
-					checkpoints: yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
-				};
-			})).pipe(Effect.catchTag("SqlError", (error) => Effect.fail(storageError("startup scan transaction")(error))));
-		}),
-		withWriteTransaction
-	};
-};
-const initializeDoJournal = ensureCurrentStorage;
-//#endregion
-//#region src/do-storage-config.ts
-const ObservationPollInterval = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-const OwnershipLeaseMillis = Schema.Int.check(Schema.isGreaterThan(0));
-/**
-* Default per-value byte bound, kept under the Durable Object platform's 2 MB SQLite value
-* limit with a safety margin. This is the DC analogue of Node's 16 MB `BoundedStoredText`
-* bound: both fail typed before mutating, only the threshold differs (a documented DN/DC
-* behavioral difference; Travel Planner payloads sit orders of magnitude below both).
-*/
-const DEFAULT_MAX_STORED_VALUE_BYTES = 19e5;
-/** The hard schema ceiling for the configurable bound: never at or above the platform limit. */
-const MaxStoredValueBytes = Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(2e6));
-/**
-* Validated construction configuration consumed by the Durable Object storage Layers. The
-* storage identity itself belongs to the SqlClient Layer (built from `ctx.storage`);
-* duplicating it here could silently diverge from the handle actually in use.
-*/
-var DoStorageConfigValue = class extends Schema.Class("@effect-agent/storage-cloudflare/DoStorageConfigValue")({
-	observationPollInterval: ObservationPollInterval,
-	/**
-	* Submission ownership lease duration in milliseconds (D5). Inside one Durable Object the
-	* object itself is the serialized owner, so the lease's primary DC role is fencing work
-	* across DO incarnations (an evicted incarnation's claim becomes reclaimable); correctness
-	* never depends on it because every canonical append is fenced by producer epoch.
-	*/
-	ownershipLeaseDuration: OwnershipLeaseMillis,
-	/**
-	* Maximum bytes for any single stored text value (canonical batch/record JSON, admission
-	* input payload, checkpoint JSON). Enforced typed BEFORE any write; must stay under the
-	* platform's 2 MB per-value limit.
-	*/
-	maxStoredValueBytes: MaxStoredValueBytes,
-	/**
-	* Re-verify every stored payload and digest chain while opening the store. Per-operation
-	* Schema decoding and the digest chain already fail clearly on corrupt rows, so the full
-	* scan is an explicit opt-in integrity audit rather than a startup requirement.
-	*/
-	verifyOnOpen: Schema.Boolean
-}) {};
-/** Explicit Durable Object storage configuration authority. */
-var DoStorageConfig = class extends Context.Service()("@effect-agent/storage-cloudflare/DoStorageConfig") {};
-//#endregion
-//#region src/do-storage-failpoint.ts
-const noFailpoint = () => Effect.void;
-/** Test-only control for replacing the active Durable Object failpoint handler. */
-var DoStorageFailpointTestControl = class extends Context.Service()("@effect-agent/storage-cloudflare/DoStorageFailpointTestControl") {};
-/** Explicit fault-injection authority used at Durable Object storage operation boundaries. */
-var DoStorageFailpoint = class DoStorageFailpoint extends Context.Service()("@effect-agent/storage-cloudflare/DoStorageFailpoint") {
-	/** Production default: no fault injection. */
-	static layer = Layer.succeed(this)({ hit: noFailpoint });
-	/** Reusable test Layer with a control service backed by the same handler Ref. */
-	static layerTest = Layer.effectContext(Effect.gen(function* () {
-		const handler = yield* Ref.make(noFailpoint);
-		return Context.make(DoStorageFailpoint, DoStorageFailpoint.of({ hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))) })).pipe(Context.add(DoStorageFailpointTestControl, DoStorageFailpointTestControl.of({
-			clear: Ref.set(handler, noFailpoint),
-			setHandler: (next) => Ref.set(handler, next)
-		})));
-	}));
-};
-/**
-* The DC-specific eviction failpoint mode: instead of failing typed, an armed hit evicts the
-* Durable Object through an injected `evict` thunk — in production-shaped harnesses that thunk
-* is `() => ctx.abort()`, the platform's real failure mode. `ctx.abort()` never returns (it
-* throws while destroying the in-memory instance and every in-flight implicit or explicit
-* storage transaction rolls back), so an armed hit ends the current Attempt exactly like an
-* unannounced platform eviction; DO storage — the only correctness-critical state — survives
-* for the next incarnation, which the persisted alarm wakes without any incoming request.
-*
-* The handles stay injected: this package never imports `cloudflare:workers`, so the harness
-* that owns a `DurableObjectState` supplies the thunk.
-*/
-const evictionFailpointHandler = (options) => (location) => options.isArmed(location).pipe(Effect.flatMap((armed) => armed ? Effect.sync(() => {
-	options.evict(location);
-	throw new Error(`Durable Object eviction did not interrupt execution at ${location}.`);
-}) : Effect.void));
-//#endregion
-//#region src/do-conversation-store.ts
-const OffsetText = Schema.String.check(Schema.isMaxLength(4 * 1024));
-const DO_OFFSET_PREFIX = "effect-agent-do@1:";
-const ZERO_CANONICAL_SEQUENCE = Schema.decodeSync(CanonicalSequence)(0);
-const isDigest = Schema.is(Digest);
-const storeError = (operation, error) => ConversationStoreError.make({
-	cause: error,
-	operation,
-	message: error.message
-});
-const schemaStoreError = (operation, error) => ConversationStoreError.make({
-	cause: error,
-	operation,
-	message: error.message
-});
-const makeOffset = Effect.fn("DoConversationStore.makeOffset")(function* (conversationId, sequence) {
-	return yield* Schema.decodeUnknownEffect(CanonicalSequence)(sequence).pipe(Effect.flatMap((validatedSequence) => Schema.decodeUnknownEffect(ObservationOffset)(`${DO_OFFSET_PREFIX}${encodeURIComponent(conversationId)}:${validatedSequence}`)), Effect.mapError((error) => schemaStoreError("encode observation offset", error)));
-});
-const parseOffset = Effect.fn("DoConversationStore.parseOffset")(function* (conversationId, offset) {
-	if (offset === void 0) return ZERO_CANONICAL_SEQUENCE;
-	const text = yield* Schema.decodeUnknownEffect(OffsetText)(offset).pipe(Effect.mapError((error) => schemaStoreError("decode observation offset", error)));
-	const conversationPrefix = `${DO_OFFSET_PREFIX}${encodeURIComponent(conversationId)}:`;
-	if (!text.startsWith(conversationPrefix)) return yield* ConversationStoreError.make({
-		operation: "decode observation offset",
-		message: "The observation offset belongs to a different adapter, storage version, or Conversation."
-	});
-	const sequenceText = text.slice(conversationPrefix.length);
-	if (!/^(0|[1-9][0-9]*)$/.test(sequenceText)) return yield* ConversationStoreError.make({
-		operation: "decode observation offset",
-		message: "The observation offset is malformed."
-	});
-	return yield* Schema.decodeUnknownEffect(CanonicalSequence)(Number(sequenceText)).pipe(Effect.mapError((error) => schemaStoreError("decode observation offset", error)));
-});
-const mapFence = (conversationId, error) => FenceRejected.make({
-	conversationId,
-	actualEpoch: error.actualEpoch,
-	attemptedEpoch: error.producerEpoch
-});
-const encodeCanonicalRecord = Effect.fn("DoConversationStore.encodeCanonicalRecord")(function* (record) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalRecord))(record).pipe(Effect.mapError((error) => schemaStoreError("encode canonical record", error)));
-});
-const encodeCanonicalBatch = Effect.fn("DoConversationStore.encodeCanonicalBatch")(function* (batch) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalBatch))(batch).pipe(Effect.mapError((error) => schemaStoreError("encode canonical batch", error)));
-});
-const encodeCheckpoint = Effect.fn("DoConversationStore.encodeCheckpoint")(function* (checkpoint) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(ConversationCheckpoint))(checkpoint).pipe(Effect.mapError((error) => schemaStoreError("encode checkpoint", error)));
-});
-const decodeEnvelope = Effect.fn("DoConversationStore.decodeEnvelope")(function* (row) {
-	const record = yield* Schema.decodeEffect(Schema.fromJsonString(CanonicalRecord))(row.record_json).pipe(Effect.mapError((error) => ConversationStoreError.make({
-		operation: "decode canonical record",
-		message: error.message
-	})));
-	const conversationId = yield* Schema.decodeUnknownEffect(CanonicalRecordEnvelope.fields.conversationId)(row.conversation_id).pipe(Effect.mapError((error) => schemaStoreError("decode conversation identity", error)));
-	const offset = yield* makeOffset(conversationId, row.sequence);
-	const batchId = yield* Schema.decodeUnknownEffect(CanonicalRecordEnvelope.fields.batchId)(row.batch_id).pipe(Effect.mapError((error) => schemaStoreError("decode batch identity", error)));
-	return CanonicalRecordEnvelope.make({
-		conversationId,
-		batchId,
-		sequence: row.sequence,
-		offset,
-		record
-	});
-});
-const decodeCheckpoint = Effect.fn("DoConversationStore.decodeCheckpoint")(function* (checkpointJson) {
-	return yield* Schema.decodeEffect(Schema.fromJsonString(ConversationCheckpoint))(checkpointJson).pipe(Effect.mapError((error) => schemaStoreError("decode checkpoint", error)));
-});
-const requireConversation = Effect.fn("DoConversationStore.requireConversation")(function* (journal, conversationId) {
-	const rows = yield* journal.getConversation(conversationId).pipe(Effect.mapError((error) => storeError("read conversation", error)));
-	if (rows.length === 0) return yield* ConversationNotMaterialized.make({ conversationId });
-	return rows[0];
-});
-const tailDigestAt = Effect.fn("DoConversationStore.tailDigestAt")(function* (journal, conversationId, sequence) {
-	if (sequence === 0) return EMPTY_TAIL_DIGEST;
-	const digests = yield* journal.getTailDigestAt(conversationId, sequence).pipe(Effect.mapError((error) => storeError("read checkpoint digest", error)));
-	if (digests.length !== 1) return yield* CheckpointRejected.make({
-		conversationId,
-		reason: "digest-mismatch"
-	});
-	return yield* Schema.decodeUnknownEffect(Digest)(digests[0]).pipe(Effect.mapError((error) => schemaStoreError("decode checkpoint digest", error)));
-});
-const groupByKey = (rows, key) => {
-	const grouped = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const existing = grouped.get(key(row));
-		if (existing === void 0) grouped.set(key(row), [row]);
-		else existing.push(row);
-	}
-	return grouped;
-};
-/**
-* Opt-in full integrity audit (`verifyOnOpen`). Every stored payload is decoded, re-encoded,
-* and re-digested against the canonical chain. Routine opens skip this scan: per-operation
-* Schema decoding plus the digest chain already fail clearly on corrupt rows.
-*/
-const decodeStartupPayloads = Effect.fn("DoConversationStore.decodeStartupPayloads")(function* (journal, crypto) {
-	const stored = yield* journal.scanStoredPayloads();
-	const batches = yield* Effect.forEach(stored.batches, (batch) => Schema.decodeEffect(Schema.fromJsonString(CanonicalBatch))(batch.batch_json).pipe(Effect.map((decoded) => ({
-		decoded,
-		row: batch
-	})), Effect.mapError((error) => DoStorageCorruptionError.make({
-		table: "effect_agent_canonical_batches",
-		rowKey: `${batch.conversation_id}/${batch.batch_id}`,
-		message: error.message
-	}))));
-	const records = yield* Effect.forEach(stored.records, (record) => Schema.decodeEffect(Schema.fromJsonString(CanonicalRecord))(record.record_json).pipe(Effect.map((decoded) => ({
-		decoded,
-		row: record
-	})), Effect.mapError((error) => DoStorageCorruptionError.make({
-		table: "effect_agent_canonical_records",
-		rowKey: `${record.conversation_id}/${record.sequence}`,
-		message: error.message
-	}))));
-	const checkpoints = yield* Effect.forEach(stored.checkpoints, (checkpoint) => Schema.decodeEffect(Schema.fromJsonString(ConversationCheckpoint))(checkpoint.checkpoint_json).pipe(Effect.map((decoded) => ({
-		decoded,
-		row: checkpoint
-	})), Effect.mapError((error) => DoStorageCorruptionError.make({
-		table: "effect_agent_checkpoints",
-		rowKey: `${checkpoint.conversation_id}/${checkpoint.through_sequence}`,
-		message: error.message
-	}))));
-	const batchesByConversation = groupByKey(batches, ({ row }) => row.conversation_id);
-	const recordsByConversation = groupByKey(records, ({ row }) => row.conversation_id);
-	const checkpointsByConversation = groupByKey(checkpoints, ({ row }) => row.conversation_id);
-	const materializedIds = new Set(stored.conversations.map((conversation) => conversation.conversation_id));
-	for (const conversation of stored.conversations) {
-		const conversationBatches = batchesByConversation.get(conversation.conversation_id) ?? [];
-		const conversationRecords = recordsByConversation.get(conversation.conversation_id) ?? [];
-		const conversationCheckpoints = checkpointsByConversation.get(conversation.conversation_id) ?? [];
-		const recordsByBatch = groupByKey(conversationRecords, ({ row }) => row.batch_id);
-		let previousDigest = EMPTY_TAIL_DIGEST;
-		let expectedSequence = 1;
-		const tailDigests = /* @__PURE__ */ new Map([[0, EMPTY_TAIL_DIGEST]]);
-		for (const { decoded: canonicalBatch, row: batchRow } of conversationBatches) {
-			const key = `${batchRow.conversation_id}/${batchRow.batch_id}`;
-			if (canonicalBatch.batchId !== batchRow.batch_id || batchRow.first_sequence !== expectedSequence || batchRow.last_sequence !== batchRow.first_sequence + canonicalBatch.records.length - 1) return yield* DoStorageCorruptionError.make({
-				table: "effect_agent_canonical_batches",
-				rowKey: key,
-				message: "Canonical batch identity, sequence, or record count is inconsistent."
-			});
-			const digest = yield* digestCanonicalBatch(previousDigest, canonicalBatch).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.mapError((error) => DoStorageCorruptionError.make({
-				table: "effect_agent_canonical_batches",
-				rowKey: key,
-				message: error.message
-			})));
-			if (batchRow.batch_digest !== digest || batchRow.tail_digest !== digest) return yield* DoStorageCorruptionError.make({
-				table: "effect_agent_canonical_batches",
-				rowKey: key,
-				message: "Canonical batch digest does not match its decoded content and prior tail."
-			});
-			const batchRecords = recordsByBatch.get(batchRow.batch_id) ?? [];
-			if (batchRecords.length !== canonicalBatch.records.length) return yield* DoStorageCorruptionError.make({
-				table: "effect_agent_canonical_records",
-				rowKey: key,
-				message: "Canonical batch and record-table counts differ."
-			});
-			for (let index = 0; index < canonicalBatch.records.length; index++) {
-				const expectedRecord = canonicalBatch.records[index];
-				const storedRecord = batchRecords[index];
-				const expectedJson = yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalRecord))(expectedRecord).pipe(Effect.mapError((error) => DoStorageCorruptionError.make({
-					table: "effect_agent_canonical_batches",
-					rowKey: key,
-					message: error.message
-				})));
-				const storedJson = yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalRecord))(storedRecord.decoded).pipe(Effect.mapError((error) => DoStorageCorruptionError.make({
-					table: "effect_agent_canonical_records",
-					rowKey: `${key}/${storedRecord.row.sequence}`,
-					message: error.message
-				})));
-				if (storedRecord.row.sequence !== batchRow.first_sequence + index || storedRecord.row.record_id !== expectedRecord.recordId || expectedJson !== storedJson) return yield* DoStorageCorruptionError.make({
-					table: "effect_agent_canonical_records",
-					rowKey: `${key}/${storedRecord.row.sequence}`,
-					message: "Canonical record identity, sequence, or payload differs from its batch."
-				});
-			}
-			previousDigest = digest;
-			expectedSequence = batchRow.last_sequence + 1;
-			tailDigests.set(batchRow.last_sequence, digest);
-		}
-		if (conversationRecords.length !== conversation.tail_sequence || conversation.tail_sequence !== expectedSequence - 1 || conversation.tail_digest !== previousDigest) return yield* DoStorageCorruptionError.make({
-			table: "effect_agent_conversations",
-			rowKey: conversation.conversation_id,
-			message: "Conversation tail does not match its canonical batch chain."
-		});
-		for (const checkpoint of conversationCheckpoints) if (checkpoint.decoded.conversationId !== conversation.conversation_id || checkpoint.decoded.throughSequence !== checkpoint.row.through_sequence || checkpoint.decoded.tailDigest !== checkpoint.row.tail_digest || tailDigests.get(checkpoint.row.through_sequence) !== checkpoint.row.tail_digest) return yield* DoStorageCorruptionError.make({
-			table: "effect_agent_checkpoints",
-			rowKey: `${conversation.conversation_id}/${checkpoint.row.through_sequence}`,
-			message: "Checkpoint identity or digest is not bound to a canonical batch tail."
-		});
-	}
-	if (batches.some(({ row }) => !materializedIds.has(row.conversation_id)) || records.some(({ row }) => !materializedIds.has(row.conversation_id)) || checkpoints.some(({ row }) => !materializedIds.has(row.conversation_id))) return yield* DoStorageCorruptionError.make({
-		table: "effect_agent_conversations",
-		rowKey: "startup_scan",
-		message: "Canonical rows exist without a materialized Conversation."
-	});
-});
-const makeServices$1 = Effect.fn("DoConversationStore.makeServices")(function* () {
-	const config = yield* DoStorageConfig;
-	const failpoint = yield* DoStorageFailpoint;
-	const sql = yield* SqlClient.SqlClient;
-	const crypto = yield* Crypto.Crypto;
-	const journal = yield* initializeDoJournal(sql, failpoint.hit, config.maxStoredValueBytes);
-	if (config.verifyOnOpen) yield* decodeStartupPayloads(journal, crypto);
-	const provideCrypto = (effect) => Effect.provideService(effect, Crypto.Crypto, crypto);
-	const hitFailpoint = Effect.fn("DoConversationStore.hitFailpoint")((location) => failpoint.hit(location).pipe(Effect.mapError((error) => storeError(`storage failpoint ${location}`, error))));
-	const materialize = Effect.fn("DoConversationStore.materialize")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ConversationMaterialization))(request).pipe(Effect.mapError((error) => schemaStoreError("validate materialization", error)));
-		const now = yield* Clock.currentTimeMillis;
-		yield* hitFailpoint("materialize:before");
-		yield* journal.materialize(validated.conversationId, new Date(now).toISOString(), EMPTY_TAIL_DIGEST, validated.producerEpoch).pipe(Effect.mapError((error) => error._tag === "DoFenceRejected" ? mapFence(validated.conversationId, error) : storeError("materialize conversation", error)));
-		yield* hitFailpoint("materialize:after");
-	});
-	const append = Effect.fn("DoConversationStore.append")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(FencedAppendRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate canonical append", error)));
-		yield* requireConversation(journal, validated.conversationId);
-		const tailDigest = yield* provideCrypto(digestCanonicalBatch(validated.expectedTailDigest, validated.batch)).pipe(Effect.mapError((error) => storeError("digest canonical append", error)));
-		const batchJson = yield* encodeCanonicalBatch(validated.batch);
-		const rawRecords = yield* Effect.forEach(validated.batch.records, (record) => encodeCanonicalRecord(record).pipe(Effect.map((recordJson) => ({
-			recordId: record.recordId,
-			recordJson
-		}))));
-		const rawRequest = yield* Schema.decodeUnknownEffect(RawAppendRequest)({
-			conversationId: validated.conversationId,
-			batchId: validated.batch.batchId,
-			batchDigest: tailDigest,
-			batchJson,
-			expectedTailSequence: validated.expectedTailSequence,
-			expectedTailDigest: validated.expectedTailDigest,
-			producerEpoch: validated.producerEpoch,
-			records: rawRecords,
-			tailDigest
-		}).pipe(Effect.mapError((error) => schemaStoreError("encode canonical append", error)));
-		yield* hitFailpoint("append:before");
-		const result = yield* journal.append(rawRequest).pipe(Effect.mapError((error) => {
-			if (error instanceof DoFenceRejected) return mapFence(validated.conversationId, error);
-			if (error instanceof DoAppendConflict) return error.actualTailSequence !== void 0 && isDigest(error.actualTailDigest) ? AppendConflict.make({
-				conversationId: validated.conversationId,
-				batchId: validated.batch.batchId,
-				reason: error.reason,
-				actualTailSequence: error.actualTailSequence,
-				actualTailDigest: error.actualTailDigest
-			}) : AppendConflict.make({
-				conversationId: validated.conversationId,
-				batchId: validated.batch.batchId,
-				reason: error.reason
-			});
-			return storeError("append canonical batch", error);
-		}), Effect.flatMap((result) => Schema.decodeUnknownEffect(AppendResult)(result).pipe(Effect.mapError((error) => schemaStoreError("decode append result", error)))));
-		yield* hitFailpoint("append:after");
-		return result;
-	});
-	const loadRecords = Effect.fn("DoConversationStore.loadRecords")(function* (request) {
-		const rows = yield* journal.read(request).pipe(Effect.mapError((error) => storeError("read canonical records", error)));
-		return yield* Effect.forEach(rows, decodeEnvelope);
-	});
-	const readEffect = Effect.fn("DoConversationStore.read")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ConversationRead))(request).pipe(Effect.mapError((error) => schemaStoreError("validate conversation read", error)));
-		yield* requireConversation(journal, validated.conversationId);
-		const records = yield* loadRecords(RawReadRequest.make({
-			conversationId: validated.conversationId,
-			fromSequenceExclusive: validated.afterSequence ?? ZERO_CANONICAL_SEQUENCE,
-			limit: validated.limit
-		}));
-		return Stream.fromIterable(records);
-	});
-	const read = (request) => Stream.unwrap(readEffect(request));
-	const observeEffect = Effect.fn("DoConversationStore.observe")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ConversationObservation))(request).pipe(Effect.mapError((error) => schemaStoreError("validate conversation observation", error)));
-		yield* requireConversation(journal, validated.conversationId);
-		const initialSequence = yield* parseOffset(validated.conversationId, validated.afterOffset);
-		const cursor = yield* Ref.make(initialSequence);
-		const poll = Effect.fn("DoConversationStore.observePoll")(function* () {
-			const fromSequenceExclusive = yield* Ref.get(cursor);
-			const records = yield* loadRecords(RawReadRequest.make({
-				conversationId: validated.conversationId,
-				fromSequenceExclusive,
-				limit: 1024
-			}));
-			if (records.length === 0) {
-				yield* Effect.sleep(config.observationPollInterval);
-				return [];
-			}
-			yield* Ref.set(cursor, records[records.length - 1].sequence);
-			return records;
-		});
-		return Stream.fromIterableEffectRepeat(poll());
-	});
-	const observe = (request) => Stream.unwrap(observeEffect(request));
-	const exportConversation = Effect.fn("DoConversationStore.export")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ConversationExportRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate conversation export", error)));
-		yield* requireConversation(journal, validated.conversationId);
-		const exported = yield* journal.exportConversation(validated.conversationId).pipe(Effect.mapError((error) => storeError("export conversation", error)));
-		const records = yield* Effect.forEach(exported.records, decodeEnvelope);
-		if (records.length > 65536) return yield* ConversationStoreError.make({
-			operation: "decode conversation export",
-			message: "The conversation exceeds the current export record limit."
-		});
-		const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(exported.conversation.tail_digest).pipe(Effect.mapError((error) => schemaStoreError("decode export tail digest", error)));
-		return ConversationExport.make({
-			format: "effect-agent/conversation@1",
-			conversationId: validated.conversationId,
-			tailSequence: exported.conversation.tail_sequence,
-			tailDigest,
-			records
-		});
-	});
-	const inspectTail = Effect.fn("DoConversationStore.inspectTail")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ConversationTailRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate tail inspection", error)));
-		const conversation = yield* requireConversation(journal, validated.conversationId);
-		const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(conversation.tail_digest).pipe(Effect.mapError((error) => schemaStoreError("decode tail digest", error)));
-		return ConversationTail.make({
-			conversationId: validated.conversationId,
-			tailSequence: conversation.tail_sequence,
-			tailDigest,
-			producerEpoch: conversation.producer_epoch
-		});
-	});
-	const saveCheckpoint = Effect.fn("DoConversationStore.saveCheckpoint")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SaveCheckpointRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint", error)));
-		const conversation = yield* requireConversation(journal, validated.checkpoint.conversationId);
-		if (validated.checkpoint.throughSequence > conversation.tail_sequence) return yield* CheckpointRejected.make({
-			conversationId: validated.checkpoint.conversationId,
-			reason: "ahead-of-tail"
-		});
-		if ((yield* tailDigestAt(journal, validated.checkpoint.conversationId, validated.checkpoint.throughSequence)) !== validated.checkpoint.tailDigest) return yield* CheckpointRejected.make({
-			conversationId: validated.checkpoint.conversationId,
-			reason: "digest-mismatch"
-		});
-		const checkpointJson = yield* encodeCheckpoint(validated.checkpoint);
-		const raw = RawCheckpoint.make({
-			conversationId: validated.checkpoint.conversationId,
-			throughSequence: validated.checkpoint.throughSequence,
-			tailDigest: validated.checkpoint.tailDigest,
-			checkpointJson
-		});
-		yield* hitFailpoint("save-checkpoint:before");
-		yield* journal.saveCheckpoint(raw).pipe(Effect.mapError((error) => error instanceof DoCheckpointConflict ? CheckpointRejected.make({
-			conversationId: validated.checkpoint.conversationId,
-			reason: "digest-mismatch"
-		}) : storeError("save checkpoint", error)));
-		yield* hitFailpoint("save-checkpoint:after");
-	});
-	const loadCheckpoint = Effect.fn("DoConversationStore.loadCheckpoint")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(LoadCheckpointRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint lookup", error)));
-		const conversation = yield* requireConversation(journal, validated.conversationId);
-		const rows = yield* journal.loadCheckpoint(validated.conversationId, validated.atOrBeforeSequence ?? conversation.tail_sequence).pipe(Effect.mapError((error) => storeError("load checkpoint", error)));
-		if (rows.length === 0) return Option.none();
-		if (rows.length !== 1) return yield* ConversationStoreError.make({
-			operation: "load checkpoint",
-			message: `Expected at most one checkpoint row but found ${rows.length}.`
-		});
-		const checkpoint = yield* decodeCheckpoint(rows[0].checkpoint_json);
-		if ((yield* tailDigestAt(journal, checkpoint.conversationId, checkpoint.throughSequence)) !== checkpoint.tailDigest) return yield* CheckpointRejected.make({
-			conversationId: checkpoint.conversationId,
-			reason: "digest-mismatch"
-		});
-		return Option.some(checkpoint);
-	});
-	const conversationStore = ConversationStore.of({
-		append,
-		export: exportConversation,
-		inspectTail,
-		loadCheckpoint,
-		materialize,
-		observe,
-		read,
-		saveCheckpoint
-	});
-	return Context.make(ConversationStore, conversationStore);
-});
-/**
-* Durable Object Conversation Store implementation with configuration, failpoint, SQL, and
-* Crypto authority kept visible in its input channel.
-*/
-const conversationStoreLayer = Layer.effectContext(makeServices$1());
-/**
-* Validated Durable Object storage configuration Layer with the documented defaults applied.
-* Shared by the ConversationStore and SubmissionLedger convenience layers so their defaults
-* cannot drift.
-*/
-const storageConfigLayer = (options) => Layer.effect(DoStorageConfig)(Schema.decodeUnknownEffect(DoStorageConfigValue)({
-	observationPollInterval: options.observationPollInterval ?? 25,
-	ownershipLeaseDuration: options.ownershipLeaseDuration ?? Duration.toMillis(DEFAULT_OWNERSHIP_LEASE_DURATION),
-	maxStoredValueBytes: options.maxStoredValueBytes ?? 19e5,
-	verifyOnOpen: options.verifyOnOpen ?? false
-}).pipe(Effect.mapError((error) => DoStorageError.make({
-	cause: error,
-	operation: "configure Durable Object storage",
-	message: error.message
-}))));
-/** The failpoint Layer selected by convenience options: explicit handler or the no-op default. */
-const storageFailpointLayer = (options) => options.failpoint === void 0 ? DoStorageFailpoint.layer : Layer.succeed(DoStorageFailpoint)({ hit: options.failpoint });
-/**
-* A composition-root convenience Layer for canonical Conversations inside one Durable Object,
-* built over `ctx.storage`. Durable accepted work is served by the separate SubmissionLedger
-* port; point both at the SAME `ctx.storage` so claims fence the same producer epochs
-* (ADR-0011 D7's "same file" rule, transposed to one object's private database).
-*/
-const layer = (options) => {
-	const sqlLayer = SqliteClient.layer({ storage: options.storage });
-	return conversationStoreLayer.pipe(Layer.provide(Layer.mergeAll(storageConfigLayer(options), storageFailpointLayer(options), sqlLayer, BrowserCrypto.layer)));
-};
-/** Create an adapter-owned resumable observation offset for a known canonical sequence. */
-const observationOffsetAt = makeOffset;
-//#endregion
-//#region src/do-ledger.ts
-/**
-* Static decode-side ceiling; writes are bounded in bytes by the configured
-* `maxStoredValueBytes` (see do-journal.ts).
-*/
-const BoundedStoredText = Schema.String.check(Schema.isMaxLength(2e6));
-const BoundedIdentifier = Schema.NonEmptyString.check(Schema.isMaxLength(1024));
-const BoundedTimestamp = Schema.NonEmptyString.check(Schema.isMaxLength(128));
-const SCAN_PAGE_SIZE = 256;
-const EPOCH_ZERO = Schema.decodeSync(ProducerEpoch)(0);
-const MAX_IDENTIFIER_LENGTH = 1024;
-var SubmissionRow = class extends Schema.Class("SubmissionRow")({
-	submission_id: BoundedIdentifier,
-	conversation_id: BoundedIdentifier,
-	queue_sequence: QueueSequence,
-	principal: BoundedIdentifier,
-	idempotency_key: BoundedIdentifier,
-	agent_id: BoundedIdentifier,
-	agent_digests_json: BoundedStoredText,
-	deployment_id: BoundedIdentifier,
-	input_json: BoundedStoredText,
-	input_digest: Digest,
-	receipt_id: BoundedIdentifier,
-	state: SubmissionState,
-	settled_outcome: Schema.NullOr(SettlementOutcome),
-	created_at: BoundedTimestamp,
-	ready_at: Schema.NullOr(BoundedTimestamp),
-	input_applied_record_id: Schema.NullOr(BoundedIdentifier),
-	input_applied_sequence: Schema.NullOr(CanonicalSequence),
-	joined_host_submission_id: Schema.NullOr(BoundedIdentifier),
-	suspended_reason_json: Schema.NullOr(BoundedStoredText),
-	suspended_at: Schema.NullOr(BoundedTimestamp),
-	unknown_reason: Schema.NullOr(BoundedStoredText),
-	unknown_tool_call_ids_json: Schema.NullOr(BoundedStoredText),
-	parent_submission_id: Schema.NullOr(BoundedIdentifier),
-	parent_tool_call_id: Schema.NullOr(BoundedIdentifier)
-}) {};
-var ChildReservationRow = class extends Schema.Class("ChildReservationRow")({
-	reservation_id: BoundedIdentifier,
-	parent_submission_id: BoundedIdentifier,
-	parent_tool_call_id: BoundedIdentifier,
-	child_submission_id: Schema.NullOr(BoundedIdentifier),
-	status: ChildReservationStatus,
-	allocation_json: BoundedStoredText,
-	allocation_digest: Digest,
-	accounting_json: Schema.NullOr(BoundedStoredText),
-	reserved_at: BoundedTimestamp,
-	release_began_at: Schema.NullOr(BoundedTimestamp),
-	released_at: Schema.NullOr(BoundedTimestamp)
-}) {};
-var ChildSettlementMarkerRow = class extends Schema.Class("ChildSettlementMarkerRow")({
-	parent_submission_id: BoundedIdentifier,
-	child_submission_id: BoundedIdentifier,
-	child_outcome: Schema.NullOr(SettlementOutcome),
-	recorded_at: BoundedTimestamp
-}) {};
-var ApprovalDecisionRow = class extends Schema.Class("ApprovalDecisionRow")({
-	submission_id: BoundedIdentifier,
-	tool_call_id: BoundedIdentifier,
-	decision: ApprovalDecision,
-	resolver: BoundedIdentifier,
-	reason: BoundedStoredText,
-	decided_at: BoundedTimestamp
-}) {};
-var UnknownResolutionRow = class extends Schema.Class("UnknownResolutionRow")({
-	submission_id: BoundedIdentifier,
-	tool_call_id: BoundedIdentifier,
-	author: BoundedIdentifier,
-	reason: BoundedStoredText,
-	resolution_json: BoundedStoredText,
-	resolved_at: BoundedTimestamp
-}) {};
-var OwnershipRow = class extends Schema.Class("OwnershipRow")({
-	submission_id: BoundedIdentifier,
-	attempt_id: BoundedIdentifier,
-	ownership_token: BoundedIdentifier,
-	producer_epoch: ProducerEpoch,
-	owner_producer_id: BoundedIdentifier,
-	lease_expires_at: BoundedTimestamp
-}) {};
-var ReservationRow = class extends Schema.Class("ReservationRow")({
-	submission_id: BoundedIdentifier,
-	settlement_id: BoundedIdentifier,
-	outcome: SettlementOutcome,
-	record_id: BoundedIdentifier,
-	record_json: BoundedStoredText,
-	record_digest: Digest,
-	reserved_at: BoundedTimestamp,
-	finalized_at: Schema.NullOr(BoundedTimestamp)
-}) {};
-var AbortIntentRow = class extends Schema.Class("AbortIntentRow")({
-	submission_id: BoundedIdentifier,
-	author: BoundedIdentifier,
-	reason: BoundedStoredText,
-	requested_at: BoundedTimestamp,
-	canonical_record_id: Schema.NullOr(BoundedIdentifier)
-}) {};
-var MaxQueueSequenceRow = class extends Schema.Class("MaxQueueSequenceRow")({ max_queue_sequence: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) }) {};
-var CanonicalRecordIdRow = class extends Schema.Class("CanonicalRecordIdRow")({ record_id: BoundedIdentifier }) {};
-const SUBMISSION_COLUMNS = `
-  submission_id,
-  conversation_id,
-  queue_sequence,
-  principal,
-  idempotency_key,
-  agent_id,
-  agent_digests_json,
-  deployment_id,
-  input_json,
-  input_digest,
-  receipt_id,
-  state,
-  settled_outcome,
-  created_at,
-  ready_at,
-  input_applied_record_id,
-  input_applied_sequence,
-  joined_host_submission_id,
-  suspended_reason_json,
-  suspended_at,
-  unknown_reason,
-  unknown_tool_call_ids_json,
-  parent_submission_id,
-  parent_tool_call_id
-`;
-const CHILD_RESERVATION_COLUMNS = `
-  reservation_id,
-  parent_submission_id,
-  parent_tool_call_id,
-  child_submission_id,
-  status,
-  allocation_json,
-  allocation_digest,
-  accounting_json,
-  reserved_at,
-  release_began_at,
-  released_at
-`;
-/** The branded ToolCallId schema, reached through the session port so no core import is needed. */
-const ToolCallIdSchema = ApprovalDecisionCommand.fields.toolCallId;
-const ToolCallIdList = Schema.Array(ToolCallIdSchema);
-const encodePersistedJsonText = Schema.encodeEffect(Schema.fromJsonString(PersistedJson));
-const encodeDefinitionDigestsText = Schema.encodeEffect(Schema.fromJsonString(DefinitionDigests));
-const encodeRecordEnvelopeText = Schema.encodeEffect(Schema.fromJsonString(RecordEnvelope));
-const decodeRecordEnvelopeText = Schema.decodeEffect(Schema.fromJsonString(RecordEnvelope));
-const encodeSuspensionReasonText = Schema.encodeEffect(Schema.fromJsonString(SuspensionReason));
-const encodeUnknownResolutionText = Schema.encodeEffect(Schema.fromJsonString(UnknownResolution));
-const encodeToolCallIdsText = Schema.encodeEffect(Schema.fromJsonString(ToolCallIdList));
-const decodeToolCallIdsText = Schema.decodeEffect(Schema.fromJsonString(ToolCallIdList));
-const parseStoredJsonText = Schema.decodeEffect(Schema.fromJsonString(Schema.Json));
-const decodeAdmissionResult = Schema.decodeUnknownEffect(AdmissionResult);
-const decodeClaim = Schema.decodeUnknownEffect(Claim);
-const decodeOwnershipRenewal = Schema.decodeUnknownEffect(OwnershipRenewal);
-const decodeSettlement = Schema.decodeUnknownEffect(Settlement);
-const decodeAbortIntent = Schema.decodeUnknownEffect(AbortIntent);
-const decodeOwnershipSnapshot = Schema.decodeUnknownEffect(OwnershipSnapshot);
-const decodeInputAppliedMarker = Schema.decodeUnknownEffect(InputAppliedMarker);
-const decodeSubmissionSnapshotUnknown = Schema.decodeUnknownEffect(SubmissionSnapshot);
-const decodeSubmissionId = Schema.decodeUnknownEffect(SubmissionSnapshot.fields.submissionId);
-const decodeQueueSequence = Schema.decodeUnknownEffect(QueueSequence);
-const decodeUtcInstant = Schema.decodeUnknownEffect(Schema.DateTimeUtcFromString);
-const decodeJoiningClaim = Schema.decodeUnknownEffect(JoiningClaim);
-const decodeJoinSnapshot = Schema.decodeUnknownEffect(JoinSnapshot);
-const decodeSuspensionSnapshot = Schema.decodeUnknownEffect(SuspensionSnapshot);
-const decodeApprovalDecisionIntent = Schema.decodeUnknownEffect(ApprovalDecisionIntent);
-const decodeUnknownResolutionIntent = Schema.decodeUnknownEffect(UnknownResolutionIntent);
-const decodeParentLinkage = Schema.decodeUnknownEffect(ParentLinkage);
-const decodeChildReservationSnapshotUnknown = Schema.decodeUnknownEffect(ChildBudgetReservationSnapshot);
-const decodeChildAttachmentSnapshot = Schema.decodeUnknownEffect(ChildAttachmentSnapshot);
-/** Wrap an adapter-internal failure into the port's LedgerError without erasing its tag. */
-const internalFailure = (operation) => (error) => LedgerError.make({
-	operation,
-	message: error.message,
-	cause: error
-});
-/**
-* Classify raw SQL failures. Within one Durable Object there is exactly one writer, so the
-* Node adapter's retryable `SqliteWriteContention` classification has no analogue: every raw
-* failure is a `DoLedgerError` preserved as the LedgerError's cause.
-*/
-const sqlFailure = (operation) => (error) => internalFailure(operation)(DoLedgerError.make({
-	cause: error,
-	operation,
-	message: error.message
-}));
-const corruptionFailure = (operation, table, rowKey, message) => internalFailure(operation)(DoStorageCorruptionError.make({
-	table,
-	rowKey,
-	message
-}));
-const makeServices = Effect.fn("DoSubmissionLedger.makeServices")(function* () {
-	const config = yield* DoStorageConfig;
-	const failpoint = yield* DoStorageFailpoint;
-	const sql = yield* SqlClient.SqlClient;
-	const crypto = yield* Crypto.Crypto;
-	const journal = yield* initializeDoJournal(sql, failpoint.hit, config.maxStoredValueBytes);
-	const hitFailpoint = (location, operation) => failpoint.hit(location).pipe(Effect.mapError((error) => internalFailure(operation)(error)));
-	/**
-	* Run one ledger mutation under the journal's Durable Object storage-backed transaction so
-	* ownership-token and epoch checks are atomic with their writes (DUR-006). Transaction
-	* failures surface as LedgerError carrying the typed `DoStorageError` as cause.
-	*/
-	const inWriteTransaction = (operation, effect) => journal.withWriteTransaction(operation)(effect).pipe(Effect.mapError((error) => error instanceof DoStorageError ? internalFailure(operation)(error) : error));
-	const mintUuid = (operation) => crypto.randomUUIDv7.pipe(Effect.mapError((error) => internalFailure(operation)(error)));
-	const currentInstant = Effect.map(Clock.currentTimeMillis, (millis) => ({
-		millis,
-		iso: new Date(millis).toISOString()
-	}));
-	const timestampMillis = (operation, rowKey) => (timestamp) => decodeUtcInstant(timestamp).pipe(Effect.map(DateTime.toEpochMillis), Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submission_ownership", rowKey, error.message)));
-	const decodeSubmissionRows = (operation, rowKey, rows) => decodeRows(Schema.Array(SubmissionRow), "effect_agent_submissions", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
-	const readSubmission = Effect.fn("DoSubmissionLedger.readSubmission")(function* (operation, submissionId) {
-		const rows = yield* sql`
-      SELECT ${sql.literal(SUBMISSION_COLUMNS)}
-      FROM effect_agent_submissions
-      WHERE submission_id = ${submissionId}
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeSubmissionRows(operation, submissionId, rows);
-		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", submissionId, "A submission primary key returned more than one row.");
-		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
-	});
-	const requireSubmission = Effect.fn("DoSubmissionLedger.requireSubmission")(function* (operation, submissionId) {
-		const submission = yield* readSubmission(operation, submissionId);
-		if (Option.isNone(submission)) return yield* LedgerError.make({
-			operation,
-			message: `Unknown submission ${submissionId}.`
-		});
-		return submission.value;
-	});
-	const readOwnership = Effect.fn("DoSubmissionLedger.readOwnership")(function* (operation, submissionId) {
-		const rows = yield* sql`
-      SELECT
-        submission_id,
-        attempt_id,
-        ownership_token,
-        producer_epoch,
-        owner_producer_id,
-        lease_expires_at
-      FROM effect_agent_submission_ownership
-      WHERE submission_id = ${submissionId}
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows(Schema.Array(OwnershipRow), "effect_agent_submission_ownership", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
-		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submission_ownership", submissionId, "An ownership primary key returned more than one row.");
-		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
-	});
-	const conversationEpoch = Effect.fn("DoSubmissionLedger.conversationEpoch")(function* (operation, conversationId) {
-		const conversations = yield* journal.getConversation(conversationId).pipe(Effect.mapError(internalFailure(operation)));
-		return conversations.length === 0 ? EPOCH_ZERO : conversations[0].producer_epoch;
-	});
-	/**
-	* Verify inside the surrounding write transaction that the presented token still owns the
-	* Submission's lane; a superseded or missing token fails with OwnershipLost carrying the
-	* Conversation's current producer epoch (DUR-006).
-	*/
-	const requireOwnership = Effect.fn("DoSubmissionLedger.requireOwnership")(function* (operation, submission, ownershipToken) {
-		const ownership = yield* readOwnership(operation, submission.submission_id);
-		if (Option.isNone(ownership) || ownership.value.ownership_token !== ownershipToken) {
-			const actualEpoch = yield* conversationEpoch(operation, submission.conversation_id);
-			const submissionId = yield* Schema.decodeUnknownEffect(SubmissionSnapshot.fields.submissionId)(submission.submission_id).pipe(Effect.mapError(internalFailure(operation)));
-			return yield* OwnershipLost.make({
-				submissionId,
-				actualEpoch
-			});
-		}
-		return ownership.value;
-	});
-	const decodeSubmissionSnapshot = Effect.fn("DoSubmissionLedger.decodeSubmissionSnapshot")(function* (operation, row) {
-		const agentDigests = yield* parseStoredJsonText(row.agent_digests_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", row.submission_id, error.message)));
-		const inputPayload = yield* parseStoredJsonText(row.input_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", row.submission_id, error.message)));
-		if (row.parent_submission_id === null !== (row.parent_tool_call_id === null)) return yield* corruptionFailure(operation, "effect_agent_submissions", row.submission_id, "A parent linkage must record both the parent Submission and the parent Tool Call.");
-		return yield* decodeSubmissionSnapshotUnknown({
-			submissionId: row.submission_id,
-			conversationId: row.conversation_id,
-			queueSequence: row.queue_sequence,
-			principal: row.principal,
-			idempotencyKey: row.idempotency_key,
-			agentId: row.agent_id,
-			agentDigests,
-			deploymentId: row.deployment_id,
-			inputPayload,
-			inputDigest: row.input_digest,
-			receiptId: row.receipt_id,
-			state: row.state,
-			createdAt: row.created_at,
-			...row.settled_outcome === null ? {} : { settledOutcome: row.settled_outcome },
-			...row.ready_at === null ? {} : { readyAt: row.ready_at },
-			...row.parent_submission_id === null || row.parent_tool_call_id === null ? {} : { parentLinkage: {
-				parentSubmissionId: row.parent_submission_id,
-				parentToolCallId: row.parent_tool_call_id
-			} }
-		}).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", row.submission_id, error.message)));
-	});
-	const readReservation = Effect.fn("DoSubmissionLedger.readReservation")(function* (operation, submissionId) {
-		const rows = yield* sql`
-      SELECT
-        submission_id,
-        settlement_id,
-        outcome,
-        record_id,
-        record_json,
-        record_digest,
-        reserved_at,
-        finalized_at
-      FROM effect_agent_settlement_reservations
-      WHERE submission_id = ${submissionId}
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows(Schema.Array(ReservationRow), "effect_agent_settlement_reservations", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
-		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_settlement_reservations", submissionId, "A settlement reservation primary key returned more than one row.");
-		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
-	});
-	const readAbortIntent = Effect.fn("DoSubmissionLedger.readAbortIntent")(function* (operation, submissionId) {
-		const rows = yield* sql`
-      SELECT
-        submission_id,
-        author,
-        reason,
-        requested_at,
-        canonical_record_id
-      FROM effect_agent_abort_intents
-      WHERE submission_id = ${submissionId}
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows(Schema.Array(AbortIntentRow), "effect_agent_abort_intents", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
-		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_abort_intents", submissionId, "An abort intent primary key returned more than one row.");
-		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
-	});
-	/**
-	* Read the durable cross-store child-settlement markers recorded against one parent
-	* Submission (the DC realization of the port's "cross-store adapters record a durable
-	* notification marker" contract).
-	*/
-	const readChildSettlementMarkers = Effect.fn("DoSubmissionLedger.readChildSettlementMarkers")(function* (operation, parentSubmissionId) {
-		const rows = yield* sql`
-        SELECT
-          parent_submission_id,
-          child_submission_id,
-          child_outcome,
-          recorded_at
-        FROM effect_agent_child_settlements
-        WHERE parent_submission_id = ${parentSubmissionId}
-        ORDER BY child_submission_id ASC
-      `.pipe(Effect.mapError(sqlFailure(operation)));
-		return yield* decodeRows(Schema.Array(ChildSettlementMarkerRow), "effect_agent_child_settlements", parentSubmissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
-	});
-	/**
-	* Whether one listed child is provably settled from THIS store: either its own row lives
-	* here and is settled (single-store evidence, identical to the Node adapter), or a durable
-	* cross-store notification marker was recorded for it (the child's row lives in another
-	* Durable Object and its owner reported the settlement through `recordChildSettled`).
-	*/
-	const childProvablySettled = Effect.fn("DoSubmissionLedger.childProvablySettled")(function* (operation, markerChildren, childSubmissionId) {
-		if (markerChildren.has(childSubmissionId)) return true;
-		const childRow = yield* readSubmission(operation, childSubmissionId);
-		return Option.isSome(childRow) && childRow.value.state === "settled";
-	});
-	const decodeChildReservationRows = (operation, rowKey, rows) => decodeRows(Schema.Array(ChildReservationRow), "effect_agent_child_reservations", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
-	const readChildReservation = Effect.fn("DoSubmissionLedger.readChildReservation")(function* (operation, reservationId) {
-		const rows = yield* sql`
-      SELECT ${sql.literal(CHILD_RESERVATION_COLUMNS)}
-      FROM effect_agent_child_reservations
-      WHERE reservation_id = ${reservationId}
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeChildReservationRows(operation, reservationId, rows);
-		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_child_reservations", reservationId, "A child reservation primary key returned more than one row.");
-		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
-	});
-	const readChildReservationForCall = Effect.fn("DoSubmissionLedger.readChildReservationForCall")(function* (operation, parentSubmissionId, parentToolCallId) {
-		const rows = yield* sql`
-        SELECT ${sql.literal(CHILD_RESERVATION_COLUMNS)}
-        FROM effect_agent_child_reservations
-        WHERE parent_submission_id = ${parentSubmissionId}
-          AND parent_tool_call_id = ${parentToolCallId}
-      `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeChildReservationRows(operation, `${parentSubmissionId}/${parentToolCallId}`, rows);
-		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_child_reservations", `${parentSubmissionId}/${parentToolCallId}`, "A parent Tool Call returned more than one child reservation.");
-		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
-	});
-	const childReservationSnapshotFromRow = Effect.fn("DoSubmissionLedger.childReservationSnapshotFromRow")(function* (operation, row) {
-		const rowFailure = (error) => corruptionFailure(operation, "effect_agent_child_reservations", row.reservation_id, error.message);
-		const allocation = yield* parseStoredJsonText(row.allocation_json).pipe(Effect.mapError(rowFailure));
-		const accounting = row.accounting_json === null ? void 0 : yield* parseStoredJsonText(row.accounting_json).pipe(Effect.mapError(rowFailure));
-		return yield* decodeChildReservationSnapshotUnknown({
-			reservationId: row.reservation_id,
-			parentSubmissionId: row.parent_submission_id,
-			parentToolCallId: row.parent_tool_call_id,
-			status: row.status,
-			allocation,
-			allocationDigest: row.allocation_digest,
-			reservedAt: row.reserved_at,
-			...row.child_submission_id === null ? {} : { childSubmissionId: row.child_submission_id },
-			...accounting === void 0 ? {} : { accounting },
-			...row.release_began_at === null ? {} : { releaseBeganAt: row.release_began_at },
-			...row.released_at === null ? {} : { releasedAt: row.released_at }
-		}).pipe(Effect.mapError(rowFailure));
-	});
-	const readApprovalDecisions = Effect.fn("DoSubmissionLedger.readApprovalDecisions")(function* (operation, submissionId) {
-		const rows = yield* sql`
-      SELECT
-        submission_id,
-        tool_call_id,
-        decision,
-        resolver,
-        reason,
-        decided_at
-      FROM effect_agent_approval_decisions
-      WHERE submission_id = ${submissionId}
-      ORDER BY tool_call_id ASC
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-		return yield* decodeRows(Schema.Array(ApprovalDecisionRow), "effect_agent_approval_decisions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
-	});
-	const approvalIntentFromRow = Effect.fn("DoSubmissionLedger.approvalIntentFromRow")(function* (operation, row) {
-		return yield* decodeApprovalDecisionIntent({
-			submissionId: row.submission_id,
-			toolCallId: row.tool_call_id,
-			decision: row.decision,
-			resolver: row.resolver,
-			reason: row.reason,
-			decidedAt: row.decided_at
-		}).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_approval_decisions", `${row.submission_id}/${row.tool_call_id}`, error.message)));
-	});
-	const readUnknownResolutions = Effect.fn("DoSubmissionLedger.readUnknownResolutions")(function* (operation, submissionId) {
-		const rows = yield* sql`
-      SELECT
-        submission_id,
-        tool_call_id,
-        author,
-        reason,
-        resolution_json,
-        resolved_at
-      FROM effect_agent_unknown_resolutions
-      WHERE submission_id = ${submissionId}
-      ORDER BY tool_call_id ASC
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-		return yield* decodeRows(Schema.Array(UnknownResolutionRow), "effect_agent_unknown_resolutions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
-	});
-	const unknownResolutionIntentFromRow = Effect.fn("DoSubmissionLedger.unknownResolutionIntentFromRow")(function* (operation, row) {
-		const resolution = yield* parseStoredJsonText(row.resolution_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_unknown_resolutions", `${row.submission_id}/${row.tool_call_id}`, error.message)));
-		return yield* decodeUnknownResolutionIntent({
-			submissionId: row.submission_id,
-			toolCallId: row.tool_call_id,
-			author: row.author,
-			reason: row.reason,
-			resolution,
-			resolvedAt: row.resolved_at
-		}).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_unknown_resolutions", `${row.submission_id}/${row.tool_call_id}`, error.message)));
-	});
-	/** The Submission's marked-unknown open Tool Call identities, empty when never marked. */
-	const storedUnknownToolCallIds = Effect.fn("DoSubmissionLedger.storedUnknownToolCallIds")(function* (operation, submission) {
-		if (submission.unknown_tool_call_ids_json === null) return [];
-		return yield* decodeToolCallIdsText(submission.unknown_tool_call_ids_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", submission.submission_id, error.message)));
-	});
-	/**
-	* Canonical history is the abort authority (DUR-015): the intent's canonicalRecordId is
-	* derived from the shared canonical-records table using the deterministic abort record
-	* identity, never from a cached ledger marker.
-	*/
-	const canonicalAbortRecordId = Effect.fn("DoSubmissionLedger.canonicalAbortRecordId")(function* (operation, conversationId, submissionId) {
-		const recordId = submissionAbortRecordId(submissionId);
-		const rows = yield* sql`
-      SELECT record_id
-      FROM effect_agent_canonical_records
-      WHERE conversation_id = ${conversationId}
-        AND record_id = ${recordId}
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-		return (yield* decodeRows(Schema.Array(CanonicalRecordIdRow), "effect_agent_canonical_records", `${conversationId}/${recordId}`, rows).pipe(Effect.mapError(internalFailure(operation)))).length === 0 ? void 0 : recordId;
-	});
-	const abortIntentFromRow = Effect.fn("DoSubmissionLedger.abortIntentFromRow")(function* (operation, submission, submissionId, row) {
-		const canonicalRecordId = yield* canonicalAbortRecordId(operation, submission.conversation_id, submissionId);
-		return yield* decodeAbortIntent({
-			submissionId: row.submission_id,
-			author: row.author,
-			reason: row.reason,
-			requestedAt: row.requested_at,
-			...canonicalRecordId === void 0 ? {} : { canonicalRecordId }
-		}).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_abort_intents", row.submission_id, error.message)));
-	});
-	const capabilities = Effect.succeed(LedgerCapabilities.make({ durability: "durable-cloudflare" }));
-	const admit = Effect.fn("DoSubmissionLedger.admit")(function* (request) {
-		const operation = "ledger admit";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(AdmissionRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		const inputJson = yield* encodePersistedJsonText(validated.inputPayload).pipe(Effect.mapError(internalFailure(operation)));
-		yield* journal.checkValueBound(operation, inputJson).pipe(Effect.mapError(internalFailure(operation)));
-		const agentDigestsJson = yield* encodeDefinitionDigestsText(validated.agentDigests).pipe(Effect.mapError(internalFailure(operation)));
-		const mintedSubmissionId = `${yield* mintUuid(operation)}:${validated.conversationId}`;
-		if (mintedSubmissionId.length > MAX_IDENTIFIER_LENGTH) return yield* LedgerError.make({
-			operation,
-			message: `A routable Submission identity of ${mintedSubmissionId.length} characters exceeds the ${MAX_IDENTIFIER_LENGTH}-character ledger row bound; shorten the Conversation identity.`
-		});
-		const mintedReceiptId = `receipt-${yield* mintUuid(operation)}`;
-		yield* hitFailpoint("ledger:admit:before", operation);
-		const result = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const keyRowKey = `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`;
-			const existingRows = yield* sql`
-            SELECT ${sql.literal(SUBMISSION_COLUMNS)}
-            FROM effect_agent_submissions
-            WHERE conversation_id = ${validated.conversationId}
-              AND principal = ${validated.principal}
-              AND idempotency_key = ${validated.idempotencyKey}
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			const existing = yield* decodeSubmissionRows(operation, keyRowKey, existingRows);
-			if (existing.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", keyRowKey, "An admission idempotency key returned more than one row.");
-			if (existing.length === 1) {
-				const sameLinkage = validated.parentLinkage === void 0 ? existing[0].parent_submission_id === null && existing[0].parent_tool_call_id === null : existing[0].parent_submission_id === validated.parentLinkage.parentSubmissionId && existing[0].parent_tool_call_id === validated.parentLinkage.parentToolCallId;
-				if (existing[0].input_digest !== validated.inputDigest || !sameLinkage) return yield* AdmissionConflict.make({
-					conversationId: validated.conversationId,
-					principal: validated.principal,
-					idempotencyKey: validated.idempotencyKey,
-					existingInputDigest: existing[0].input_digest,
-					attemptedInputDigest: validated.inputDigest
-				});
-				return yield* decodeAdmissionResult({
-					submissionId: existing[0].submission_id,
-					receiptId: existing[0].receipt_id,
-					queueSequence: existing[0].queue_sequence,
-					state: existing[0].state,
-					replayed: true
-				}).pipe(Effect.mapError(internalFailure(operation)));
-			}
-			const maxRows = yield* sql`
-            SELECT COALESCE(MAX(queue_sequence), 0) AS max_queue_sequence
-            FROM effect_agent_submissions
-            WHERE conversation_id = ${validated.conversationId}
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			const decodedMax = yield* decodeRows(Schema.Array(MaxQueueSequenceRow), "effect_agent_submissions", validated.conversationId, maxRows).pipe(Effect.mapError(internalFailure(operation)));
-			const queueSequence = yield* decodeQueueSequence((decodedMax[0]?.max_queue_sequence ?? 0) + 1).pipe(Effect.mapError(internalFailure(operation)));
-			const now = yield* currentInstant;
-			yield* sql`
-            INSERT INTO effect_agent_submissions (
-              submission_id,
-              conversation_id,
-              queue_sequence,
-              principal,
-              idempotency_key,
-              agent_id,
-              agent_digests_json,
-              deployment_id,
-              input_json,
-              input_digest,
-              receipt_id,
-              state,
-              created_at,
-              parent_submission_id,
-              parent_tool_call_id
-            ) VALUES (
-              ${mintedSubmissionId},
-              ${validated.conversationId},
-              ${queueSequence},
-              ${validated.principal},
-              ${validated.idempotencyKey},
-              ${validated.agentId},
-              ${agentDigestsJson},
-              ${validated.deploymentId},
-              ${inputJson},
-              ${validated.inputDigest},
-              ${mintedReceiptId},
-              'admitted',
-              ${now.iso},
-              ${validated.parentLinkage?.parentSubmissionId ?? null},
-              ${validated.parentLinkage?.parentToolCallId ?? null}
-            )
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			return yield* decodeAdmissionResult({
-				submissionId: mintedSubmissionId,
-				receiptId: mintedReceiptId,
-				queueSequence,
-				state: "admitted",
-				replayed: false
-			}).pipe(Effect.mapError(internalFailure(operation)));
-		}));
-		yield* hitFailpoint("ledger:admit:after", operation);
-		return result;
-	});
-	const markReady = Effect.fn("DoSubmissionLedger.markReady")(function* (request) {
-		const operation = "ledger mark ready";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(MarkReadyRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:mark-ready:before", operation);
-		yield* inWriteTransaction(operation, Effect.gen(function* () {
-			if ((yield* requireSubmission(operation, validated.submissionId)).state !== "admitted") return;
-			const now = yield* currentInstant;
-			yield* sql`
-          UPDATE effect_agent_submissions
-          SET state = 'ready', ready_at = ${now.iso}
-          WHERE submission_id = ${validated.submissionId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-		}));
-		yield* hitFailpoint("ledger:mark-ready:after", operation);
-	});
-	const lookup = Effect.fn("DoSubmissionLedger.lookup")(function* (request) {
-		const operation = "ledger lookup";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SubmissionLookup))(request).pipe(Effect.mapError(internalFailure(operation)));
-		if (validated._tag === "SubmissionLookupById") {
-			const row = yield* readSubmission(operation, validated.submissionId);
-			if (Option.isNone(row)) return Option.none();
-			return Option.some(yield* decodeSubmissionSnapshot(operation, row.value));
-		}
-		const rows = yield* sql`
-      SELECT ${sql.literal(SUBMISSION_COLUMNS)}
-      FROM effect_agent_submissions
-      WHERE conversation_id = ${validated.conversationId}
-        AND principal = ${validated.principal}
-        AND idempotency_key = ${validated.idempotencyKey}
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeSubmissionRows(operation, `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`, rows);
-		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`, "An admission idempotency key returned more than one row.");
-		if (decoded.length === 0) return Option.none();
-		return Option.some(yield* decodeSubmissionSnapshot(operation, decoded[0]));
-	});
-	const resolveAdmission = Effect.fn("DoSubmissionLedger.resolveAdmission")(function* (request) {
-		const operation = "ledger resolve admission";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SubmissionLookupByKey))(request).pipe(Effect.mapError(internalFailure(operation)));
-		const rows = yield* sql`
-      SELECT ${sql.literal(SUBMISSION_COLUMNS)}
-      FROM effect_agent_submissions
-      WHERE conversation_id = ${validated.conversationId}
-        AND principal = ${validated.principal}
-        AND idempotency_key = ${validated.idempotencyKey}
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeSubmissionRows(operation, `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`, rows);
-		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`, "An admission idempotency key returned more than one row.");
-		if (decoded.length === 0) return AdmissionNotAdmitted.make();
-		return AdmissionAdmitted.make({ submission: yield* decodeSubmissionSnapshot(operation, decoded[0]) });
-	});
-	const claim = Effect.fn("DoSubmissionLedger.claim")(function* (request) {
-		const operation = "ledger claim";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ClaimRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		const attemptId = `attempt-${yield* mintUuid(operation)}`;
-		const ownershipToken = `owner-${yield* mintUuid(operation)}`;
-		yield* hitFailpoint("ledger:claim:before", operation);
-		const claimed = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const headRows = yield* sql`
-            SELECT ${sql.literal(SUBMISSION_COLUMNS)}
-            FROM effect_agent_submissions
-            WHERE conversation_id = ${validated.conversationId}
-              AND state <> 'settled'
-            ORDER BY queue_sequence ASC
-            LIMIT 1
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			const heads = yield* decodeSubmissionRows(operation, validated.conversationId, headRows);
-			if (heads.length === 0) return Option.none();
-			const head = heads[0];
-			if (head.state === "joining" || head.state === "joined" || head.state === "suspended" || head.state === "unknown") return Option.none();
-			const now = yield* currentInstant;
-			const ownership = yield* readOwnership(operation, head.submission_id);
-			if (Option.isSome(ownership)) {
-				if ((yield* timestampMillis(operation, head.submission_id)(ownership.value.lease_expires_at)) > now.millis) return Option.none();
-			}
-			const conversations = yield* journal.getConversation(head.conversation_id).pipe(Effect.mapError(internalFailure(operation)));
-			let producerEpoch;
-			if (conversations.length === 0) {
-				producerEpoch = 1;
-				yield* sql`
-              INSERT INTO effect_agent_conversations (
-                conversation_id,
-                created_at,
-                tail_sequence,
-                tail_digest,
-                producer_epoch
-              ) VALUES (
-                ${head.conversation_id},
-                ${now.iso},
-                0,
-                ${EMPTY_TAIL_DIGEST},
-                ${producerEpoch}
-              )
-            `.pipe(Effect.mapError(sqlFailure(operation)));
-			} else {
-				producerEpoch = conversations[0].producer_epoch + 1;
-				yield* sql`
-              UPDATE effect_agent_conversations
-              SET producer_epoch = ${producerEpoch}
-              WHERE conversation_id = ${head.conversation_id}
-            `.pipe(Effect.mapError(sqlFailure(operation)));
-			}
-			const leaseExpiresAt = new Date(now.millis + config.ownershipLeaseDuration).toISOString();
-			yield* sql`
-            INSERT INTO effect_agent_submission_ownership (
-              submission_id,
-              attempt_id,
-              ownership_token,
-              producer_epoch,
-              owner_producer_id,
-              lease_expires_at
-            ) VALUES (
-              ${head.submission_id},
-              ${attemptId},
-              ${ownershipToken},
-              ${producerEpoch},
-              ${validated.producerId},
-              ${leaseExpiresAt}
-            )
-            ON CONFLICT (submission_id) DO UPDATE SET
-              attempt_id = excluded.attempt_id,
-              ownership_token = excluded.ownership_token,
-              producer_epoch = excluded.producer_epoch,
-              owner_producer_id = excluded.owner_producer_id,
-              lease_expires_at = excluded.lease_expires_at
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			yield* sql`
-            INSERT INTO effect_agent_attempts (
-              attempt_id,
-              submission_id,
-              conversation_id,
-              owner_producer_id,
-              producer_epoch,
-              claimed_at
-            ) VALUES (
-              ${attemptId},
-              ${head.submission_id},
-              ${head.conversation_id},
-              ${validated.producerId},
-              ${producerEpoch},
-              ${now.iso}
-            )
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			if (head.state === "ready") yield* sql`
-              UPDATE effect_agent_submissions
-              SET state = 'running'
-              WHERE submission_id = ${head.submission_id}
-            `.pipe(Effect.mapError(sqlFailure(operation)));
-			const inputPayload = yield* parseStoredJsonText(head.input_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", head.submission_id, error.message)));
-			return Option.some(yield* decodeClaim({
-				submissionId: head.submission_id,
-				attemptId,
-				ownershipToken,
-				producerEpoch,
-				leaseExpiresAt,
-				inputPayload
-			}).pipe(Effect.mapError(internalFailure(operation))));
-		}));
-		yield* hitFailpoint("ledger:claim:after", operation);
-		return claimed;
-	});
-	const renewOwnership = Effect.fn("DoSubmissionLedger.renewOwnership")(function* (request) {
-		const operation = "ledger renew ownership";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(RenewOwnershipRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:renew:before", operation);
-		const renewal = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const submission = yield* requireSubmission(operation, validated.submissionId);
-			yield* requireOwnership(operation, submission, validated.ownershipToken);
-			const now = yield* currentInstant;
-			const leaseExpiresAt = new Date(now.millis + config.ownershipLeaseDuration).toISOString();
-			yield* sql`
-          UPDATE effect_agent_submission_ownership
-          SET lease_expires_at = ${leaseExpiresAt}
-          WHERE submission_id = ${validated.submissionId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			return yield* decodeOwnershipRenewal({
-				ownershipToken: validated.ownershipToken,
-				leaseExpiresAt
-			}).pipe(Effect.mapError(internalFailure(operation)));
-		}));
-		yield* hitFailpoint("ledger:renew:after", operation);
-		return renewal;
-	});
-	const releaseOwnership = Effect.fn("DoSubmissionLedger.releaseOwnership")(function* (request) {
-		const operation = "ledger release ownership";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ReleaseOwnershipRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:release:before", operation);
-		yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const submission = yield* requireSubmission(operation, validated.submissionId);
-			yield* requireOwnership(operation, submission, validated.ownershipToken);
-			yield* sql`
-          DELETE FROM effect_agent_submission_ownership
-          WHERE submission_id = ${validated.submissionId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			if (submission.state === "running") yield* sql`
-            UPDATE effect_agent_submissions
-            SET state = 'ready'
-            WHERE submission_id = ${validated.submissionId}
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-		}));
-		yield* hitFailpoint("ledger:release:after", operation);
-	});
-	const markInputApplied = Effect.fn("DoSubmissionLedger.markInputApplied")(function* (request) {
-		const operation = "ledger mark input applied";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(MarkInputAppliedRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:mark-input-applied:before", operation);
-		yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const submission = yield* requireSubmission(operation, validated.submissionId);
-			yield* requireOwnership(operation, submission, validated.ownershipToken);
-			if (submission.input_applied_record_id !== null) {
-				if (submission.input_applied_record_id === validated.recordId && submission.input_applied_sequence === validated.sequence) return;
-				return yield* corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, "A different canonical input marker is already recorded for this Submission.");
-			}
-			yield* sql`
-          UPDATE effect_agent_submissions
-          SET
-            input_applied_record_id = ${validated.recordId},
-            input_applied_sequence = ${validated.sequence},
-            state = CASE
-              WHEN state IN ('admitted', 'ready', 'running') THEN 'input-applied'
-              ELSE state
-            END
-          WHERE submission_id = ${validated.submissionId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-		}));
-		yield* hitFailpoint("ledger:mark-input-applied:after", operation);
-	});
-	const reserveSettlement = Effect.fn("DoSubmissionLedger.reserveSettlement")(function* (request) {
-		const operation = "ledger reserve settlement";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SettlementReservation))(request).pipe(Effect.mapError(internalFailure(operation)));
-		const recordJson = yield* encodeRecordEnvelopeText(validated.record).pipe(Effect.mapError(internalFailure(operation)));
-		yield* journal.checkValueBound(operation, recordJson).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:reserve-settlement:before", operation);
-		const reserved = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const existing = yield* readReservation(operation, validated.submissionId);
-			if (Option.isSome(existing)) {
-				if (!(existing.value.settlement_id === validated.settlementId && existing.value.outcome === validated.outcome && existing.value.record_digest === validated.recordDigest && existing.value.record_json === recordJson)) return yield* SettlementConflict.make({
-					submissionId: validated.submissionId,
-					existingOutcome: existing.value.outcome
-				});
-				const record = yield* decodeRecordEnvelopeText(existing.value.record_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, error.message)));
-				return ReservedSettlement.make({
-					submissionId: validated.submissionId,
-					settlementId: validated.settlementId,
-					outcome: validated.outcome,
-					record,
-					recordDigest: validated.recordDigest,
-					replayed: true
-				});
-			}
-			const submission = yield* requireSubmission(operation, validated.submissionId);
-			if (submission.state === "settled") {
-				if (submission.settled_outcome === null) return yield* corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, "A settled Submission carries no terminal outcome.");
-				return yield* SettlementConflict.make({
-					submissionId: validated.submissionId,
-					existingOutcome: submission.settled_outcome
-				});
-			}
-			if (!(submission.state === "joined" && submission.joined_host_submission_id !== null)) {
-				let queuedAbortSettlement = false;
-				if (validated.outcome === "aborted" && (submission.state === "ready" || submission.state === "terminalizing")) {
-					const abortIntent = yield* readAbortIntent(operation, validated.submissionId);
-					if (Option.isSome(abortIntent)) {
-						const ownership = yield* readOwnership(operation, validated.submissionId);
-						queuedAbortSettlement = Option.isNone(ownership);
-					}
-				}
-				if (!queuedAbortSettlement) yield* requireOwnership(operation, submission, validated.ownershipToken);
-			}
-			const now = yield* currentInstant;
-			yield* sql`
-          INSERT INTO effect_agent_settlement_reservations (
-            submission_id,
-            settlement_id,
-            outcome,
-            record_id,
-            record_json,
-            record_digest,
-            reserved_at
-          ) VALUES (
-            ${validated.submissionId},
-            ${validated.settlementId},
-            ${validated.outcome},
-            ${validated.record.recordId},
-            ${recordJson},
-            ${validated.recordDigest},
-            ${now.iso}
-          )
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			yield* sql`
-          UPDATE effect_agent_submissions
-          SET state = 'terminalizing'
-          WHERE submission_id = ${validated.submissionId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			return ReservedSettlement.make({
-				submissionId: validated.submissionId,
-				settlementId: validated.settlementId,
-				outcome: validated.outcome,
-				record: validated.record,
-				recordDigest: validated.recordDigest,
-				replayed: false
-			});
-		}));
-		yield* hitFailpoint("ledger:reserve-settlement:after", operation);
-		return reserved;
-	});
-	const finalizeSettlement = Effect.fn("DoSubmissionLedger.finalizeSettlement")(function* (request) {
-		const operation = "ledger finalize settlement";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SettlementFinalization))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:finalize-settlement:before", operation);
-		const settlement = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const reservation = yield* readReservation(operation, validated.submissionId);
-			if (Option.isNone(reservation)) return yield* LedgerError.make({
-				operation,
-				message: `No settlement reservation exists for submission ${validated.submissionId}.`
-			});
-			if (reservation.value.settlement_id !== validated.settlementId) return yield* SettlementConflict.make({
-				submissionId: validated.submissionId,
-				existingOutcome: reservation.value.outcome
-			});
-			const submission = yield* requireSubmission(operation, validated.submissionId);
-			if (submission.state === "settled") {
-				if (reservation.value.finalized_at === null) return yield* corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, "A settled Submission's reservation carries no finalization timestamp.");
-				return yield* decodeSettlement({
-					submissionId: validated.submissionId,
-					settlementId: validated.settlementId,
-					receiptId: submission.receipt_id,
-					outcome: reservation.value.outcome,
-					settledAt: reservation.value.finalized_at
-				}).pipe(Effect.mapError(internalFailure(operation)));
-			}
-			const now = yield* currentInstant;
-			yield* sql`
-          UPDATE effect_agent_submissions
-          SET state = 'settled', settled_outcome = ${reservation.value.outcome}
-          WHERE submission_id = ${validated.submissionId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			yield* sql`
-          UPDATE effect_agent_settlement_reservations
-          SET finalized_at = ${now.iso}
-          WHERE submission_id = ${validated.submissionId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			yield* sql`
-          DELETE FROM effect_agent_submission_ownership
-          WHERE submission_id = ${validated.submissionId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			return yield* decodeSettlement({
-				submissionId: validated.submissionId,
-				settlementId: validated.settlementId,
-				receiptId: submission.receipt_id,
-				outcome: reservation.value.outcome,
-				settledAt: now.iso
-			}).pipe(Effect.mapError(internalFailure(operation)));
-		}));
-		yield* hitFailpoint("ledger:finalize-settlement:after", operation);
-		return settlement;
-	});
-	const requestAbort = Effect.fn("DoSubmissionLedger.requestAbort")(function* (request) {
-		const operation = "ledger request abort";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(AbortCommand))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:request-abort:before", operation);
-		const intent = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const submission = yield* requireSubmission(operation, validated.submissionId);
-			if (submission.state === "settled") {
-				if (submission.settled_outcome === null) return yield* corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, "A settled Submission carries no terminal outcome.");
-				return yield* SettlementConflict.make({
-					submissionId: validated.submissionId,
-					existingOutcome: submission.settled_outcome
-				});
-			}
-			if (submission.state === "joined") {
-				if (submission.joined_host_submission_id === null) return yield* corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, "A joined Submission carries no host linkage.");
-				const hostSubmissionId = yield* decodeSubmissionId(submission.joined_host_submission_id).pipe(Effect.mapError(internalFailure(operation)));
-				return yield* JoinedToHost.make({
-					submissionId: validated.submissionId,
-					hostSubmissionId
-				});
-			}
-			const existing = yield* readAbortIntent(operation, validated.submissionId);
-			if (Option.isSome(existing)) return yield* abortIntentFromRow(operation, submission, validated.submissionId, existing.value);
-			const now = yield* currentInstant;
-			yield* sql`
-          INSERT INTO effect_agent_abort_intents (
-            submission_id,
-            author,
-            reason,
-            requested_at
-          ) VALUES (
-            ${validated.submissionId},
-            ${validated.author},
-            ${validated.reason},
-            ${now.iso}
-          )
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			const canonicalRecordId = yield* canonicalAbortRecordId(operation, submission.conversation_id, validated.submissionId);
-			return yield* decodeAbortIntent({
-				submissionId: validated.submissionId,
-				author: validated.author,
-				reason: validated.reason,
-				requestedAt: now.iso,
-				...canonicalRecordId === void 0 ? {} : { canonicalRecordId }
-			}).pipe(Effect.mapError(internalFailure(operation)));
-		}));
-		yield* hitFailpoint("ledger:request-abort:after", operation);
-		return intent;
-	});
-	const claimJoining = Effect.fn("DoSubmissionLedger.claimJoining")(function* (request) {
-		const operation = "ledger claim joining";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ClaimJoiningRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:claim-joining:before", operation);
-		const claims = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const host = yield* requireSubmission(operation, validated.hostSubmissionId);
-			if (host.conversation_id !== validated.conversationId) return yield* LedgerError.make({
-				operation,
-				message: `Host submission ${validated.hostSubmissionId} does not belong to conversation ${validated.conversationId}.`
-			});
-			yield* requireOwnership(operation, host, validated.ownershipToken);
-			const laterRows = yield* sql`
-          SELECT ${sql.literal(SUBMISSION_COLUMNS)}
-          FROM effect_agent_submissions
-          WHERE conversation_id = ${validated.conversationId}
-            AND queue_sequence > ${host.queue_sequence}
-          ORDER BY queue_sequence ASC
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			const later = yield* decodeSubmissionRows(operation, validated.conversationId, laterRows);
-			const claimed = [];
-			for (const row of later) {
-				if (claimed.length >= validated.maxCount) break;
-				if ((row.state === "joining" || row.state === "joined") && row.joined_host_submission_id === validated.hostSubmissionId) continue;
-				if (row.state === "settled" && row.settled_outcome === "aborted") continue;
-				if (row.state !== "ready") break;
-				yield* sql`
-            UPDATE effect_agent_submissions
-            SET state = 'joining', joined_host_submission_id = ${validated.hostSubmissionId}
-            WHERE submission_id = ${row.submission_id}
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-				const inputPayload = yield* parseStoredJsonText(row.input_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", row.submission_id, error.message)));
-				claimed.push(yield* decodeJoiningClaim({
-					submissionId: row.submission_id,
-					queueSequence: row.queue_sequence,
-					inputPayload
-				}).pipe(Effect.mapError(internalFailure(operation))));
-			}
-			return claimed;
-		}));
-		yield* hitFailpoint("ledger:claim-joining:after", operation);
-		return claims;
-	});
-	const markJoined = Effect.fn("DoSubmissionLedger.markJoined")(function* (request) {
-		const operation = "ledger mark joined";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(MarkJoinedRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:mark-joined:before", operation);
-		yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const submission = yield* requireSubmission(operation, validated.submissionId);
-			if (submission.joined_host_submission_id === null) return yield* LedgerError.make({
-				operation,
-				message: `Submission ${validated.submissionId} was never claimed for joining.`
-			});
-			const host = yield* requireSubmission(operation, submission.joined_host_submission_id);
-			yield* requireOwnership(operation, host, validated.ownershipToken);
-			if (submission.input_applied_record_id !== null) {
-				if (submission.input_applied_record_id === validated.recordId && submission.input_applied_sequence === validated.sequence) return;
-				return yield* corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, "A different join marker is already recorded for this Submission.");
-			}
-			if (submission.state !== "joining" && submission.state !== "joined") return yield* LedgerError.make({
-				operation,
-				message: `Cannot mark submission ${validated.submissionId} joined from state ${submission.state}.`
-			});
-			yield* sql`
-          UPDATE effect_agent_submissions
-          SET
-            input_applied_record_id = ${validated.recordId},
-            input_applied_sequence = ${validated.sequence},
-            state = 'joined'
-          WHERE submission_id = ${validated.submissionId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-		}));
-		yield* hitFailpoint("ledger:mark-joined:after", operation);
-	});
-	const revertJoining = Effect.fn("DoSubmissionLedger.revertJoining")(function* (request) {
-		const operation = "ledger revert joining";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(RevertJoiningRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:revert-joining:before", operation);
-		yield* inWriteTransaction(operation, Effect.gen(function* () {
-			if ((yield* requireSubmission(operation, validated.submissionId)).state !== "joining") return;
-			yield* sql`
-          UPDATE effect_agent_submissions
-          SET state = 'ready', joined_host_submission_id = NULL
-          WHERE submission_id = ${validated.submissionId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-		}));
-		yield* hitFailpoint("ledger:revert-joining:after", operation);
-	});
-	const suspend = Effect.fn("DoSubmissionLedger.suspend")(function* (request) {
-		const operation = "ledger suspend";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SuspendRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		const reasonJson = yield* encodeSuspensionReasonText(validated.reason).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:suspend:before", operation);
-		const outcome = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const submission = yield* requireSubmission(operation, validated.submissionId);
-			if (submission.state === "settled") {
-				if (submission.settled_outcome === null) return yield* corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, "A settled Submission carries no terminal outcome.");
-				return yield* SettlementConflict.make({
-					submissionId: validated.submissionId,
-					existingOutcome: submission.settled_outcome
-				});
-			}
-			const reservation = yield* readReservation(operation, validated.submissionId);
-			if (Option.isSome(reservation)) return yield* SettlementConflict.make({
-				submissionId: validated.submissionId,
-				existingOutcome: reservation.value.outcome
-			});
-			yield* requireOwnership(operation, submission, validated.ownershipToken);
-			if (validated.reason._tag === "ApprovalPending") {
-				const decisions = yield* readApprovalDecisions(operation, validated.submissionId);
-				const decided = new Set(decisions.map((row) => row.tool_call_id));
-				if (validated.reason.toolCallIds.every((toolCallId) => decided.has(toolCallId))) return "resume-immediately";
-			} else {
-				const markers = yield* readChildSettlementMarkers(operation, validated.submissionId);
-				const markerChildren = new Set(markers.map((row) => row.child_submission_id));
-				let allSettled = true;
-				for (const child of validated.reason.children) if (!(yield* childProvablySettled(operation, markerChildren, child.childSubmissionId))) {
-					allSettled = false;
-					break;
-				}
-				if (allSettled) return "resume-immediately";
-			}
-			const now = yield* currentInstant;
-			yield* sql`
-            UPDATE effect_agent_submissions
-            SET
-              state = 'suspended',
-              suspended_reason_json = ${reasonJson},
-              suspended_at = ${now.iso}
-            WHERE submission_id = ${validated.submissionId}
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			yield* sql`
-            DELETE FROM effect_agent_submission_ownership
-            WHERE submission_id = ${validated.submissionId}
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			return "suspended";
-		}));
-		yield* hitFailpoint("ledger:suspend:after", operation);
-		return outcome;
-	});
-	/**
-	* Once every pending call of a recorded ApprovalPending suspension has a decision intent,
-	* the lane wakes: suspended → input-applied, suspension cleared (plan §2.6). A
-	* WaitingForChild suspension wakes only through recordChildSettled. Runs inside the caller's
-	* write transaction.
-	*/
-	const wakeSuspendedIfCovered = Effect.fn("DoSubmissionLedger.wakeSuspendedIfCovered")(function* (operation, submission) {
-		if (submission.state !== "suspended" || submission.suspended_reason_json === null) return;
-		const reason = yield* Schema.decodeEffect(Schema.fromJsonString(SuspensionReason))(submission.suspended_reason_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", submission.submission_id, error.message)));
-		if (reason._tag !== "ApprovalPending") return;
-		const decisions = yield* readApprovalDecisions(operation, submission.submission_id);
-		const decided = new Set(decisions.map((row) => row.tool_call_id));
-		if (!reason.toolCallIds.every((toolCallId) => decided.has(toolCallId))) return;
-		yield* sql`
-      UPDATE effect_agent_submissions
-      SET
-        state = 'input-applied',
-        suspended_reason_json = NULL,
-        suspended_at = NULL
-      WHERE submission_id = ${submission.submission_id}
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-	});
-	const recordApprovalDecision = Effect.fn("DoSubmissionLedger.recordApprovalDecision")(function* (command) {
-		const operation = "ledger record approval decision";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ApprovalDecisionCommand))(command).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:approval-decision:before", operation);
-		const intent = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const submission = yield* requireSubmission(operation, validated.submissionId);
-			if (submission.state === "settled") {
-				if (submission.settled_outcome === null) return yield* corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, "A settled Submission carries no terminal outcome.");
-				return yield* SettlementConflict.make({
-					submissionId: validated.submissionId,
-					existingOutcome: submission.settled_outcome
-				});
-			}
-			const existing = (yield* readApprovalDecisions(operation, validated.submissionId)).find((row) => row.tool_call_id === validated.toolCallId);
-			if (existing !== void 0) {
-				if (existing.decision !== validated.decision) return yield* ApprovalConflict.make({
-					submissionId: validated.submissionId,
-					toolCallId: validated.toolCallId,
-					existingDecision: existing.decision
-				});
-				return yield* approvalIntentFromRow(operation, existing);
-			}
-			const now = yield* currentInstant;
-			yield* sql`
-          INSERT INTO effect_agent_approval_decisions (
-            submission_id,
-            tool_call_id,
-            decision,
-            resolver,
-            reason,
-            decided_at
-          ) VALUES (
-            ${validated.submissionId},
-            ${validated.toolCallId},
-            ${validated.decision},
-            ${validated.resolver},
-            ${validated.reason},
-            ${now.iso}
-          )
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			yield* wakeSuspendedIfCovered(operation, submission);
-			return yield* decodeApprovalDecisionIntent({
-				submissionId: validated.submissionId,
-				toolCallId: validated.toolCallId,
-				decision: validated.decision,
-				resolver: validated.resolver,
-				reason: validated.reason,
-				decidedAt: now.iso
-			}).pipe(Effect.mapError(internalFailure(operation)));
-		}));
-		yield* hitFailpoint("ledger:approval-decision:after", operation);
-		return intent;
-	});
-	const markUnknown = Effect.fn("DoSubmissionLedger.markUnknown")(function* (request) {
-		const operation = "ledger mark unknown";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(MarkUnknownRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:mark-unknown:before", operation);
-		yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const submission = yield* requireSubmission(operation, validated.submissionId);
-			if (submission.state === "settled") {
-				if (submission.settled_outcome === null) return yield* corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, "A settled Submission carries no terminal outcome.");
-				return yield* SettlementConflict.make({
-					submissionId: validated.submissionId,
-					existingOutcome: submission.settled_outcome
-				});
-			}
-			const reservation = yield* readReservation(operation, validated.submissionId);
-			if (Option.isSome(reservation)) return yield* SettlementConflict.make({
-				submissionId: validated.submissionId,
-				existingOutcome: reservation.value.outcome
-			});
-			const existingIds = yield* storedUnknownToolCallIds(operation, submission);
-			const known = new Set(existingIds);
-			const merged = [...existingIds, ...validated.toolCallIds.filter((toolCallId) => !known.has(toolCallId))];
-			const idsJson = yield* encodeToolCallIdsText(merged).pipe(Effect.mapError(internalFailure(operation)));
-			yield* sql`
-          UPDATE effect_agent_submissions
-          SET
-            state = 'unknown',
-            unknown_reason = ${submission.unknown_reason ?? validated.reason},
-            unknown_tool_call_ids_json = ${idsJson}
-          WHERE submission_id = ${validated.submissionId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-		}));
-		yield* hitFailpoint("ledger:mark-unknown:after", operation);
-	});
-	const recordUnknownResolution = Effect.fn("DoSubmissionLedger.recordUnknownResolution")(function* (command) {
-		const operation = "ledger record unknown resolution";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(UnknownResolutionCommand))(command).pipe(Effect.mapError(internalFailure(operation)));
-		const resolutionJson = yield* encodeUnknownResolutionText(validated.resolution).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:unknown-resolution:before", operation);
-		const intent = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const submission = yield* requireSubmission(operation, validated.submissionId);
-			if (submission.state === "settled") {
-				if (submission.settled_outcome === null) return yield* corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, "A settled Submission carries no terminal outcome.");
-				return yield* SettlementConflict.make({
-					submissionId: validated.submissionId,
-					existingOutcome: submission.settled_outcome
-				});
-			}
-			const existing = (yield* readUnknownResolutions(operation, validated.submissionId)).find((row) => row.tool_call_id === validated.toolCallId);
-			if (existing !== void 0 && existing.resolution_json !== resolutionJson) return yield* UnknownResolutionConflict.make({
-				submissionId: validated.submissionId,
-				toolCallId: validated.toolCallId
-			});
-			let resolved;
-			if (existing !== void 0) resolved = yield* unknownResolutionIntentFromRow(operation, existing);
-			else {
-				const now = yield* currentInstant;
-				yield* sql`
-            INSERT INTO effect_agent_unknown_resolutions (
-              submission_id,
-              tool_call_id,
-              author,
-              reason,
-              resolution_json,
-              resolved_at
-            ) VALUES (
-              ${validated.submissionId},
-              ${validated.toolCallId},
-              ${validated.author},
-              ${validated.reason},
-              ${resolutionJson},
-              ${now.iso}
-            )
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-				const resolution = yield* parseStoredJsonText(resolutionJson).pipe(Effect.mapError(internalFailure(operation)));
-				resolved = yield* decodeUnknownResolutionIntent({
-					submissionId: validated.submissionId,
-					toolCallId: validated.toolCallId,
-					author: validated.author,
-					reason: validated.reason,
-					resolution,
-					resolvedAt: now.iso
-				}).pipe(Effect.mapError(internalFailure(operation)));
-			}
-			if (submission.state === "unknown" && submission.unknown_tool_call_ids_json !== null) {
-				const markedIds = yield* storedUnknownToolCallIds(operation, submission);
-				const covering = yield* readUnknownResolutions(operation, validated.submissionId);
-				const coveredIds = new Set(covering.map((row) => row.tool_call_id));
-				if (markedIds.every((toolCallId) => coveredIds.has(toolCallId))) yield* sql`
-              UPDATE effect_agent_submissions
-              SET
-                state = 'input-applied',
-                unknown_reason = NULL,
-                unknown_tool_call_ids_json = NULL
-              WHERE submission_id = ${validated.submissionId}
-            `.pipe(Effect.mapError(sqlFailure(operation)));
-			}
-			return resolved;
-		}));
-		yield* hitFailpoint("ledger:unknown-resolution:after", operation);
-		return intent;
-	});
-	const recordChildSettled = Effect.fn("DoSubmissionLedger.recordChildSettled")(function* (request) {
-		const operation = "ledger record child settled";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ChildSettledNotification))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:child-settled:before", operation);
-		const outcome = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const parent = yield* requireSubmission(operation, validated.parentSubmissionId);
-			const child = yield* readSubmission(operation, validated.childSubmissionId);
-			if (Option.isSome(child) && child.value.state !== "settled") return yield* LedgerError.make({
-				operation,
-				message: `Child submission ${validated.childSubmissionId} has no recorded settlement.`
-			});
-			const now = yield* currentInstant;
-			yield* sql`
-          INSERT INTO effect_agent_child_settlements (
-            parent_submission_id,
-            child_submission_id,
-            child_outcome,
-            recorded_at
-          ) VALUES (
-            ${validated.parentSubmissionId},
-            ${validated.childSubmissionId},
-            ${Option.isSome(child) ? child.value.settled_outcome : null},
-            ${now.iso}
-          )
-          ON CONFLICT (parent_submission_id, child_submission_id) DO NOTHING
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			if (parent.state !== "suspended" || parent.suspended_reason_json === null) return "not-waiting";
-			const reason = yield* Schema.decodeEffect(Schema.fromJsonString(SuspensionReason))(parent.suspended_reason_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", parent.submission_id, error.message)));
-			if (reason._tag !== "WaitingForChild") return "not-waiting";
-			if (!reason.children.some((entry) => entry.childSubmissionId === validated.childSubmissionId)) return "not-waiting";
-			const markers = yield* readChildSettlementMarkers(operation, validated.parentSubmissionId);
-			const markerChildren = new Set(markers.map((row) => row.child_submission_id));
-			for (const entry of reason.children) if (!(yield* childProvablySettled(operation, markerChildren, entry.childSubmissionId))) return "still-waiting";
-			yield* sql`
-          UPDATE effect_agent_submissions
-          SET
-            state = 'input-applied',
-            suspended_reason_json = NULL,
-            suspended_at = NULL
-          WHERE submission_id = ${validated.parentSubmissionId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			return "woken";
-		}));
-		yield* hitFailpoint("ledger:child-settled:after", operation);
-		return outcome;
-	});
-	const reserveChildBudget = Effect.fn("DoSubmissionLedger.reserveChildBudget")(function* (request) {
-		const operation = "ledger reserve child budget";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ChildBudgetReservationRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		const allocationJson = yield* encodePersistedJsonText(validated.allocation).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:child-reservation:before", operation);
-		const reserved = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const existing = yield* readChildReservation(operation, validated.reservationId);
-			if (Option.isSome(existing)) {
-				if (!(existing.value.parent_submission_id === validated.parentSubmissionId && existing.value.parent_tool_call_id === validated.parentToolCallId && existing.value.allocation_digest === validated.allocationDigest && existing.value.allocation_json === allocationJson)) return yield* ChildReservationConflict.make({
-					reservationId: validated.reservationId,
-					status: existing.value.status,
-					message: "A reservation with this identity exists with a different parent Tool Call or allocation."
-				});
-				return ReservedChildBudget.make({
-					reservation: yield* childReservationSnapshotFromRow(operation, existing.value),
-					replayed: true
-				});
-			}
-			const collision = yield* readChildReservationForCall(operation, validated.parentSubmissionId, validated.parentToolCallId);
-			if (Option.isSome(collision)) return yield* ChildReservationConflict.make({
-				reservationId: validated.reservationId,
-				status: collision.value.status,
-				message: `Parent Tool Call ${validated.parentToolCallId} already owns reservation ${collision.value.reservation_id}.`
-			});
-			const parent = yield* requireSubmission(operation, validated.parentSubmissionId);
-			yield* requireOwnership(operation, parent, validated.ownershipToken);
-			const now = yield* currentInstant;
-			yield* sql`
-          INSERT INTO effect_agent_child_reservations (
-            reservation_id,
-            parent_submission_id,
-            parent_tool_call_id,
-            status,
-            allocation_json,
-            allocation_digest,
-            reserved_at
-          ) VALUES (
-            ${validated.reservationId},
-            ${validated.parentSubmissionId},
-            ${validated.parentToolCallId},
-            'reserved',
-            ${allocationJson},
-            ${validated.allocationDigest},
-            ${now.iso}
-          )
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			const inserted = yield* readChildReservation(operation, validated.reservationId);
-			if (Option.isNone(inserted)) return yield* corruptionFailure(operation, "effect_agent_child_reservations", validated.reservationId, "An inserted child reservation row is missing inside its own transaction.");
-			return ReservedChildBudget.make({
-				reservation: yield* childReservationSnapshotFromRow(operation, inserted.value),
-				replayed: false
-			});
-		}));
-		yield* hitFailpoint("ledger:child-reservation:after", operation);
-		return reserved;
-	});
-	const attachChildToReservation = Effect.fn("DoSubmissionLedger.attachChildToReservation")(function* (request) {
-		const operation = "ledger attach child to reservation";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(AttachChildToReservationRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:child-attach:before", operation);
-		const attached = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const existing = yield* readChildReservation(operation, validated.reservationId);
-			if (Option.isNone(existing)) return yield* LedgerError.make({
-				operation,
-				message: `Unknown child reservation ${validated.reservationId}.`
-			});
-			if (existing.value.child_submission_id !== null) {
-				if (existing.value.child_submission_id === validated.childSubmissionId) return yield* childReservationSnapshotFromRow(operation, existing.value);
-				return yield* ChildReservationConflict.make({
-					reservationId: validated.reservationId,
-					status: existing.value.status,
-					message: `Reservation ${validated.reservationId} already records child ${existing.value.child_submission_id}.`
-				});
-			}
-			const parent = yield* requireSubmission(operation, existing.value.parent_submission_id);
-			yield* requireOwnership(operation, parent, validated.ownershipToken);
-			if (existing.value.status !== "reserved") return yield* ChildReservationConflict.make({
-				reservationId: validated.reservationId,
-				status: existing.value.status,
-				message: `Cannot attach a child to a ${existing.value.status} reservation.`
-			});
-			yield* sql`
-            UPDATE effect_agent_child_reservations
-            SET child_submission_id = ${validated.childSubmissionId}
-            WHERE reservation_id = ${validated.reservationId}
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			const updated = yield* readChildReservation(operation, validated.reservationId);
-			if (Option.isNone(updated)) return yield* corruptionFailure(operation, "effect_agent_child_reservations", validated.reservationId, "An updated child reservation row is missing inside its own transaction.");
-			return yield* childReservationSnapshotFromRow(operation, updated.value);
-		}));
-		yield* hitFailpoint("ledger:child-attach:after", operation);
-		return attached;
-	});
-	const beginChildBudgetRelease = Effect.fn("DoSubmissionLedger.beginChildBudgetRelease")(function* (request) {
-		const operation = "ledger begin child budget release";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(BeginChildBudgetReleaseRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		const accountingJson = yield* encodePersistedJsonText(validated.accounting).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:child-release-pending:before", operation);
-		const frozen = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const existing = yield* readChildReservation(operation, validated.reservationId);
-			if (Option.isNone(existing)) return yield* LedgerError.make({
-				operation,
-				message: `Unknown child reservation ${validated.reservationId}.`
-			});
-			if (existing.value.status !== "reserved") {
-				if (existing.value.accounting_json === accountingJson) return yield* childReservationSnapshotFromRow(operation, existing.value);
-				return yield* ChildReservationConflict.make({
-					reservationId: validated.reservationId,
-					status: existing.value.status,
-					message: "A different accounting decision is already frozen for this reservation."
-				});
-			}
-			const now = yield* currentInstant;
-			yield* sql`
-          UPDATE effect_agent_child_reservations
-          SET
-            status = 'releasePending',
-            accounting_json = ${accountingJson},
-            release_began_at = ${now.iso}
-          WHERE reservation_id = ${validated.reservationId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			const updated = yield* readChildReservation(operation, validated.reservationId);
-			if (Option.isNone(updated)) return yield* corruptionFailure(operation, "effect_agent_child_reservations", validated.reservationId, "An updated child reservation row is missing inside its own transaction.");
-			return yield* childReservationSnapshotFromRow(operation, updated.value);
-		}));
-		yield* hitFailpoint("ledger:child-release-pending:after", operation);
-		return frozen;
-	});
-	const releaseChildBudget = Effect.fn("DoSubmissionLedger.releaseChildBudget")(function* (request) {
-		const operation = "ledger release child budget";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ReleaseChildBudgetRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		yield* hitFailpoint("ledger:child-release:before", operation);
-		const released = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const existing = yield* readChildReservation(operation, validated.reservationId);
-			if (Option.isNone(existing)) return yield* LedgerError.make({
-				operation,
-				message: `Unknown child reservation ${validated.reservationId}.`
-			});
-			if (existing.value.status === "released") return yield* childReservationSnapshotFromRow(operation, existing.value);
-			if (existing.value.status !== "releasePending") return yield* ChildReservationConflict.make({
-				reservationId: validated.reservationId,
-				status: existing.value.status,
-				message: "Cannot release a reservation whose accounting decision is not frozen."
-			});
-			const now = yield* currentInstant;
-			yield* sql`
-          UPDATE effect_agent_child_reservations
-          SET status = 'released', released_at = ${now.iso}
-          WHERE reservation_id = ${validated.reservationId}
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			const updated = yield* readChildReservation(operation, validated.reservationId);
-			if (Option.isNone(updated)) return yield* corruptionFailure(operation, "effect_agent_child_reservations", validated.reservationId, "An updated child reservation row is missing inside its own transaction.");
-			return yield* childReservationSnapshotFromRow(operation, updated.value);
-		}));
-		yield* hitFailpoint("ledger:child-release:after", operation);
-		return released;
-	});
-	const scanPage = Effect.fn("DoSubmissionLedger.scanPage")(function* (cursor) {
-		const operation = "ledger scan nonterminal";
-		const rows = yield* (cursor === void 0 ? sql`
-          SELECT ${sql.literal(SUBMISSION_COLUMNS)}
-          FROM effect_agent_submissions
-          WHERE state <> 'settled'
-          ORDER BY conversation_id ASC, queue_sequence ASC
-          LIMIT ${SCAN_PAGE_SIZE}
-        ` : sql`
-          SELECT ${sql.literal(SUBMISSION_COLUMNS)}
-          FROM effect_agent_submissions
-          WHERE state <> 'settled'
-            AND (
-              conversation_id > ${cursor.conversationId}
-              OR (
-                conversation_id = ${cursor.conversationId}
-                AND queue_sequence > ${cursor.queueSequence}
-              )
-            )
-          ORDER BY conversation_id ASC, queue_sequence ASC
-          LIMIT ${SCAN_PAGE_SIZE}
-        `).pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeSubmissionRows(operation, "nonterminal_scan", rows);
-		const snapshots = yield* Effect.forEach(decoded, (row) => decodeSubmissionSnapshot(operation, row));
-		const last = decoded[decoded.length - 1];
-		return [snapshots, last === void 0 || decoded.length < SCAN_PAGE_SIZE ? Option.none() : Option.some({
-			conversationId: last.conversation_id,
-			queueSequence: last.queue_sequence
-		})];
-	});
-	const scanNonterminal = Stream.paginate(void 0, scanPage);
-	const loadRecoverySnapshot = Effect.fn("DoSubmissionLedger.loadRecoverySnapshot")(function* (request) {
-		const operation = "ledger load recovery snapshot";
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(RecoverySnapshotRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
-		return yield* sql.withTransaction(Effect.gen(function* () {
-			const submissionRow = yield* requireSubmission(operation, validated.submissionId);
-			const submission = yield* decodeSubmissionSnapshot(operation, submissionRow);
-			let ownership;
-			const ownershipRow = yield* readOwnership(operation, validated.submissionId);
-			if (Option.isSome(ownershipRow)) ownership = yield* decodeOwnershipSnapshot({
-				attemptId: ownershipRow.value.attempt_id,
-				ownerProducerId: ownershipRow.value.owner_producer_id,
-				producerEpoch: ownershipRow.value.producer_epoch,
-				leaseExpiresAt: ownershipRow.value.lease_expires_at
-			}).pipe(Effect.mapError(internalFailure(operation)));
-			let inputApplied;
-			if (submissionRow.input_applied_record_id !== null && submissionRow.input_applied_sequence !== null) inputApplied = yield* decodeInputAppliedMarker({
-				recordId: submissionRow.input_applied_record_id,
-				sequence: submissionRow.input_applied_sequence
-			}).pipe(Effect.mapError(internalFailure(operation)));
-			let reservation;
-			const reservationRow = yield* readReservation(operation, validated.submissionId);
-			if (Option.isSome(reservationRow)) {
-				const record = yield* decodeRecordEnvelopeText(reservationRow.value.record_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, error.message)));
-				const settlementId = yield* Schema.decodeUnknownEffect(SettlementReservationSnapshot.fields.settlementId)(reservationRow.value.settlement_id).pipe(Effect.mapError(internalFailure(operation)));
-				reservation = SettlementReservationSnapshot.make({
-					settlementId,
-					outcome: reservationRow.value.outcome,
-					record,
-					recordDigest: reservationRow.value.record_digest,
-					finalized: reservationRow.value.finalized_at !== null
-				});
-			}
-			let abortIntent;
-			const abortRow = yield* readAbortIntent(operation, validated.submissionId);
-			if (Option.isSome(abortRow)) abortIntent = yield* abortIntentFromRow(operation, submissionRow, validated.submissionId, abortRow.value);
-			const joinRows = yield* sql`
-            SELECT ${sql.literal(SUBMISSION_COLUMNS)}
-            FROM effect_agent_submissions
-            WHERE joined_host_submission_id = ${validated.submissionId}
-            ORDER BY queue_sequence ASC
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			const joinSubmissions = yield* decodeSubmissionRows(operation, validated.submissionId, joinRows);
-			const joins = yield* Effect.forEach(joinSubmissions, (row) => decodeJoinSnapshot({
-				submissionId: row.submission_id,
-				state: row.state,
-				hostSubmissionId: validated.submissionId
-			}).pipe(Effect.mapError(internalFailure(operation))));
-			let hostSubmissionId;
-			if (submissionRow.joined_host_submission_id !== null) hostSubmissionId = yield* decodeSubmissionId(submissionRow.joined_host_submission_id).pipe(Effect.mapError(internalFailure(operation)));
-			let suspension;
-			if (submissionRow.suspended_reason_json !== null && submissionRow.suspended_at !== null) {
-				const reason = yield* parseStoredJsonText(submissionRow.suspended_reason_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, error.message)));
-				suspension = yield* decodeSuspensionSnapshot({
-					reason,
-					suspendedAt: submissionRow.suspended_at
-				}).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, error.message)));
-			}
-			const decisionRows = yield* readApprovalDecisions(operation, validated.submissionId);
-			const approvalDecisions = yield* Effect.forEach(decisionRows, (row) => approvalIntentFromRow(operation, row));
-			const resolutionRows = yield* readUnknownResolutions(operation, validated.submissionId);
-			const unknownResolutions = yield* Effect.forEach(resolutionRows, (row) => unknownResolutionIntentFromRow(operation, row));
-			const childReservationRows = yield* sql`
-            SELECT ${sql.literal(CHILD_RESERVATION_COLUMNS)}
-            FROM effect_agent_child_reservations
-            WHERE parent_submission_id = ${validated.submissionId}
-            ORDER BY parent_tool_call_id ASC
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			const decodedChildReservations = yield* decodeChildReservationRows(operation, validated.submissionId, childReservationRows);
-			const childReservations = yield* Effect.forEach(decodedChildReservations, (row) => childReservationSnapshotFromRow(operation, row));
-			const markers = yield* readChildSettlementMarkers(operation, validated.submissionId);
-			const markersByChild = new Map(markers.map((row) => [row.child_submission_id, row]));
-			const childAttachments = [];
-			for (const row of decodedChildReservations) {
-				if (row.child_submission_id === null) continue;
-				const child = yield* readSubmission(operation, row.child_submission_id);
-				if (Option.isSome(child)) {
-					childAttachments.push(yield* decodeChildAttachmentSnapshot({
-						toolCallId: row.parent_tool_call_id,
-						childSubmissionId: row.child_submission_id,
-						childState: child.value.state,
-						...child.value.settled_outcome === null ? {} : { childOutcome: child.value.settled_outcome }
-					}).pipe(Effect.mapError(internalFailure(operation))));
-					continue;
-				}
-				const marker = markersByChild.get(row.child_submission_id);
-				if (marker === void 0) continue;
-				childAttachments.push(yield* decodeChildAttachmentSnapshot({
-					toolCallId: row.parent_tool_call_id,
-					childSubmissionId: row.child_submission_id,
-					childState: "settled",
-					...marker.child_outcome === null ? {} : { childOutcome: marker.child_outcome }
-				}).pipe(Effect.mapError(internalFailure(operation))));
-			}
-			let parentLinkage;
-			if (submissionRow.parent_submission_id !== null && submissionRow.parent_tool_call_id !== null) parentLinkage = yield* decodeParentLinkage({
-				parentSubmissionId: submissionRow.parent_submission_id,
-				parentToolCallId: submissionRow.parent_tool_call_id
-			}).pipe(Effect.mapError(internalFailure(operation)));
-			return RecoverySnapshot.make({
-				submission,
-				joins,
-				approvalDecisions,
-				unknownResolutions,
-				childReservations,
-				childAttachments,
-				...parentLinkage === void 0 ? {} : { parentLinkage },
-				...hostSubmissionId === void 0 ? {} : { hostSubmissionId },
-				...suspension === void 0 ? {} : { suspension },
-				...ownership === void 0 ? {} : { ownership },
-				...inputApplied === void 0 ? {} : { inputApplied },
-				...reservation === void 0 ? {} : { reservation },
-				...abortIntent === void 0 ? {} : { abortIntent }
-			});
-		})).pipe(Effect.catchTag("SqlError", (error) => Effect.fail(sqlFailure(operation)(error))));
-	});
-	return Context.make(SubmissionLedger, 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
-	}));
-});
-/**
-* Durable Object SubmissionLedger implementation sharing the journal's private SQLite
-* database, storage-backed transaction discipline, and producer-epoch fencing substrate.
-* Configuration, failpoint, SQL, and Crypto authority stay visible in the input channel.
-*/
-const submissionLedgerLayer = Layer.effectContext(makeServices());
-/**
-* A composition-root convenience Layer for the durable Submission Ledger. Point it at the
-* same `ctx.storage` as the ConversationStore so claims fence the same producer epochs.
-*/
-const ledgerLayer = (options) => submissionLedgerLayer.pipe(Layer.provide(Layer.mergeAll(storageConfigLayer(options), storageFailpointLayer(options), SqliteClient.layer({ storage: options.storage }), BrowserCrypto.layer)));
-//#endregion
-//#region src/port-protocol.ts
-/**
-* The cross-Durable-Object port protocol (plan §1.3, D-P6-3): Schema request/response/error
-* envelopes for the CLOSED route-capable subset of the session ports. One Conversation's
-* Durable Object executes another Conversation's request against its OWN local facets; the
-* envelopes here are the only values that cross the Object boundary, and they are
-* transport-agnostic — native Durable Object JS RPC is the shipped carrier, fetch-with-JSON
-* the documented fallback, and both move the same Schema-encoded JSON.
-*
-* The closed subset is exactly the set of operations the durable coordinator performs against
-* a FOREIGN Conversation (parent/child establishment, status checks, abort propagation,
-* child-settlement notification, and the child-conversation store operations used by
-* establishment, `verifySettledChild`, and result projection):
-*
-* - ledger: `admit`, `markReady`, `lookup`, `resolveAdmission`, `requestAbort`,
-*   `recordChildSettled`;
-* - store: `materialize`, `append`, `read` (one page), `inspectTail`, `export`.
-*
-* Every other port operation is lane-local by construction and is NOT given an envelope:
-* honesty over accidental distribution — the routing layer fails such calls fast and typed
-* instead of quietly widening the distributed surface.
-*
-* Failures cross the boundary as the `PortFailure` union and re-decode on the caller side to
-* the SAME tagged error types the local facet would have produced, so routed calls keep
-* error-tag fidelity. `cause` chains inside `LedgerError`/`ConversationStoreError` travel as
-* Schema defects and do not claim instance fidelity across Objects (plan §2.8).
-*/
-/** Ceiling for protocol diagnostic strings; matches `AdmissionIndeterminate.reason`. */
-const MAX_PORT_DIAGNOSTIC_LENGTH = 4096;
-const BoundedDiagnostic = Schema.String.check(Schema.isMaxLength(MAX_PORT_DIAGNOSTIC_LENGTH));
-/** Truncate a diagnostic string to the protocol's bounded diagnostic length. */
-const boundPortDiagnostic = (value) => value.length > 4096 ? `${value.slice(0, MAX_PORT_DIAGNOSTIC_LENGTH - 3)}...` : value;
-/**
-* The envelope itself could not be honored: the receiving Object could not decode the
-* request, or a response could not be encoded/decoded. It never carries port semantics —
-* callers fold it into the operation's base error (`LedgerError`/`ConversationStoreError`),
-* except `resolveAdmission`, which folds it into `AdmissionIndeterminate` because a
-* non-answer is never proof of absence (SUB-031).
-*/
-var PortProtocolError = class extends Schema.TaggedError()("PortProtocolError", { message: BoundedDiagnostic }) {};
-/** Routed `SubmissionLedger.admit` — child establishment admits INTO the owning Object. */
-var LedgerAdmitCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerAdmitCall")("LedgerAdmit", { request: AdmissionRequest }) {};
-/** Routed `SubmissionLedger.markReady` for a Submission owned by another Object. */
-var LedgerMarkReadyCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerMarkReadyCall")("LedgerMarkReady", { request: MarkReadyRequest }) {};
-/** Routed `SubmissionLedger.lookup` (by identity or scoped idempotency key). */
-var LedgerLookupCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerLookupCall")("LedgerLookup", { request: SubmissionLookup }) {};
-/** Routed `SubmissionLedger.resolveAdmission` — the SUB-031 tri-state authority call. */
-var LedgerResolveAdmissionCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerResolveAdmissionCall")("LedgerResolveAdmission", { request: SubmissionLookupByKey }) {};
-/** Routed `SubmissionLedger.requestAbort` — abort propagation across Objects. */
-var LedgerRequestAbortCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerRequestAbortCall")("LedgerRequestAbort", { request: AbortCommand }) {};
-/** Routed `SubmissionLedger.recordChildSettled` — the child→parent durable notification. */
-var LedgerRecordChildSettledCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerRecordChildSettledCall")("LedgerRecordChildSettled", { request: ChildSettledNotification }) {};
-/** Routed `ConversationStore.materialize` against the owning Object. */
-var StoreMaterializeCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreMaterializeCall")("StoreMaterialize", { request: ConversationMaterialization }) {};
-/** Routed `ConversationStore.append` against the owning Object. */
-var StoreAppendCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreAppendCall")("StoreAppend", { request: FencedAppendRequest }) {};
-/** Routed one-page `ConversationStore.read`; the page bound is the request's own `limit`. */
-var StoreReadPageCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreReadPageCall")("StoreReadPage", { request: ConversationRead }) {};
-/** Routed `ConversationStore.inspectTail` against the owning Object. */
-var StoreInspectTailCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreInspectTailCall")("StoreInspectTail", { request: ConversationTailRequest }) {};
-/** Routed `ConversationStore.export` against the owning Object. */
-var StoreExportCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreExportCall")("StoreExport", { request: ConversationExportRequest }) {};
-/** Every request that may cross a Durable Object boundary — the CLOSED route-capable subset. */
-const PortRequest = Schema.Union([
-	LedgerAdmitCall,
-	LedgerMarkReadyCall,
-	LedgerLookupCall,
-	LedgerResolveAdmissionCall,
-	LedgerRequestAbortCall,
-	LedgerRecordChildSettledCall,
-	StoreMaterializeCall,
-	StoreAppendCall,
-	StoreReadPageCall,
-	StoreInspectTailCall,
-	StoreExportCall
-]);
-var LedgerAdmitResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerAdmitResult")("LedgerAdmitResult", { result: AdmissionResult }) {};
-var LedgerMarkReadyResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerMarkReadyResult")("LedgerMarkReadyResult", {}) {};
-/** `submission` is absent exactly when the lookup answered `Option.none`. */
-var LedgerLookupResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerLookupResult")("LedgerLookupResult", { submission: Schema.optionalKey(SubmissionSnapshot) }) {};
-var LedgerResolveAdmissionResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerResolveAdmissionResult")("LedgerResolveAdmissionResult", { resolution: AdmissionResolution }) {};
-var LedgerRequestAbortResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerRequestAbortResult")("LedgerRequestAbortResult", { intent: AbortIntent }) {};
-var LedgerRecordChildSettledResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerRecordChildSettledResult")("LedgerRecordChildSettledResult", { outcome: ChildSettledOutcome }) {};
-var StoreMaterializeResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreMaterializeResult")("StoreMaterializeResult", {}) {};
-var StoreAppendResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreAppendResult")("StoreAppendResult", { result: AppendResult }) {};
-/** One page of canonical records, bounded by the request's `limit` (≤ 1,024). */
-var StoreReadPageResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreReadPageResult")("StoreReadPageResult", { records: Schema.Array(CanonicalRecordEnvelope).check(Schema.isMaxLength(1024)) }) {};
-var StoreInspectTailResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreInspectTailResult")("StoreInspectTailResult", { tail: ConversationTail }) {};
-var StoreExportResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreExportResult")("StoreExportResult", { export: ConversationExport }) {};
-/** Every successful routed result. Callers narrow by the tag their request implies. */
-const PortResult = Schema.Union([
-	LedgerAdmitResult,
-	LedgerMarkReadyResult,
-	LedgerLookupResult,
-	LedgerResolveAdmissionResult,
-	LedgerRequestAbortResult,
-	LedgerRecordChildSettledResult,
-	StoreMaterializeResult,
-	StoreAppendResult,
-	StoreReadPageResult,
-	StoreInspectTailResult,
-	StoreExportResult
-]);
-/**
-* Every typed failure a route-capable operation can produce on its owning Object, plus the
-* protocol's own `PortProtocolError`. Members re-decode to the SAME tagged classes the
-* session ports declare, so a routed caller observes identical error tags and fields.
-*/
-const PortFailure = Schema.Union([
-	AdmissionConflict,
-	SettlementConflict,
-	JoinedToHost,
-	LedgerError,
-	ConversationStoreError,
-	ConversationNotMaterialized,
-	AppendConflict,
-	FenceRejected,
-	PortProtocolError
-]);
-/** The routed operation succeeded on its owning Object. */
-var PortSucceeded = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/PortSucceeded")("PortSucceeded", { result: PortResult }) {};
-/** The routed operation failed TYPED on its owning Object; the failure re-decodes verbatim. */
-var PortFailed = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/PortFailed")("PortFailed", { failure: PortFailure }) {};
-/** The uniform answer of one `portCall`: op-specific success or a re-decodable typed failure. */
-const PortResponse = Schema.Union([PortSucceeded, PortFailed]);
-const encodePortRequest = Schema.encodeEffect(PortRequest);
-const decodePortRequest = Schema.decodeUnknownEffect(PortRequest);
-const encodePortResponse = Schema.encodeEffect(PortResponse);
-const decodePortResponse = Schema.decodeUnknownEffect(PortResponse);
-//#endregion
-//#region src/routing.ts
-const ConversationIdSchema = ConversationMaterialization.fields.conversationId;
-const decodeConversationId = Schema.decodeUnknownEffect(ConversationIdSchema);
-/**
-* The ledger row bound routable Submission identities must respect (mirrors the local
-* facet's `MAX_IDENTIFIER_LENGTH`; the minting side already refuses longer identities typed
-* at admission, so a longer identity presented here cannot name any stored row).
-*/
-const MAX_ROUTABLE_SUBMISSION_ID_LENGTH = 1024;
-/** The `{uuidv7}` head of a DC-minted routable Submission identity. */
-const UUID_HEAD_PATTERN = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
-/**
-* A transport could not deliver a port request to (or an answer from) the owning
-* Conversation's Durable Object. `retryable` carries the platform's own stub signal when one
-* exists. This error never crosses the wire — it is the CALLER-side evidence that the
-* authority was unreachable, which is exactly the case `AdmissionIndeterminate` was
-* specified for (SUB-031).
-*/
-var PortTransportError = class extends Schema.TaggedError()("PortTransportError", {
-	target: Schema.String,
-	message: Schema.String,
-	retryable: Schema.optionalKey(Schema.Boolean),
-	cause: Schema.optionalKey(Schema.Defect())
-}) {};
-/**
-* Build a `PortTransportError` from an arbitrary thrown transport cause, preserving the
-* platform stub's own `retryable` signal when present.
-*/
-const portTransportFailure = (target, cause) => {
-	const message = cause instanceof Error ? cause.message : String(cause);
-	let retryable;
-	if (typeof cause === "object" && cause !== null && "retryable" in cause) {
-		const signal = cause.retryable;
-		if (typeof signal === "boolean") retryable = signal;
-	}
-	return PortTransportError.make({
-		target,
-		message: boundPortDiagnostic(message),
-		...retryable === void 0 ? {} : { retryable },
-		cause
-	});
-};
-/**
-* Delivery of Schema-encoded port envelopes to the Durable Object that owns a FOREIGN
-* Conversation (plan §1.3, D-P6-3). The shipped implementation (platform-cloudflare, WP3)
-* calls the owner's `portCall` over native Durable Object JS RPC via
-* `namespace.idFromName(conversationId)`; the protocol is transport-agnostic and any carrier
-* that moves the encoded envelopes verbatim satisfies this service. Implementations MUST
-* surface every delivery problem as `PortTransportError` and must never fabricate an answer.
-*/
-var ConversationPortTransport = class extends Context.Service()("@effect-agent/storage-cloudflare/ConversationPortTransport") {};
-const LOCAL = { _tag: "local" };
-/**
-* Parse a DC-minted routable Submission identity — `{uuidv7}:{conversationId}`, split at the
-* FIRST `:` because the Conversation tail may itself contain colons (D-P6-5). This adapter
-* minted the format at admission and is the ONLY component that parses it; identities that do
-* not carry the minted shape (no separator, non-UUID head, empty tail) fall back to the local
-* facet, which is the only authority this Object can consult without inventing an owner.
-* Identities beyond the ledger's 1,024-character row bound fail typed: the minting side
-* refused them at admission, so they cannot name any stored row anywhere.
-*/
-const routableSubmissionTarget = (localConversationId) => Effect.fn("DoPortRouting.routableSubmissionTarget")(function* (operation, submissionId) {
-	if (submissionId.length > MAX_ROUTABLE_SUBMISSION_ID_LENGTH) return yield* LedgerError.make({
-		operation,
-		message: `A Submission identity of ${submissionId.length} characters exceeds the ${MAX_ROUTABLE_SUBMISSION_ID_LENGTH}-character routable identity bound; admission refuses such identities, so it cannot name any stored row.`
-	});
-	const separator = submissionId.indexOf(":");
-	if (separator === -1) return LOCAL;
-	if (!UUID_HEAD_PATTERN.test(submissionId.slice(0, separator))) return LOCAL;
-	const tail = submissionId.slice(separator + 1);
-	if (tail === localConversationId) return LOCAL;
-	return yield* decodeConversationId(tail).pipe(Effect.map((conversationId) => ({
-		_tag: "foreign",
-		conversationId
-	})), Effect.orElseSucceed(() => LOCAL));
-});
-const isResultTag = (tag) => (result) => result._tag === tag;
-const isAdmitConflict = (failure) => failure._tag === "AdmissionConflict";
-const isAbortConflict = (failure) => failure._tag === "SettlementConflict" || failure._tag === "JoinedToHost";
-const noExtraFailure = (_failure) => false;
-const isFenceRejected = (failure) => failure._tag === "FenceRejected";
-const isAppendFailure = (failure) => failure._tag === "ConversationNotMaterialized" || failure._tag === "AppendConflict" || failure._tag === "FenceRejected";
-const isNotMaterialized = (failure) => failure._tag === "ConversationNotMaterialized";
-/**
-* The fail-fast refusal for any foreign operation OUTSIDE the closed route-capable subset
-* (plan §1.3): honesty over accidental distribution.
-*/
-const crossConversationLedgerError = (operation, target) => LedgerError.make({
-	operation,
-	message: `${operation} addressed to foreign Conversation ${target} is not route-capable; the closed cross-Object subset is admit, markReady, lookup, resolveAdmission, requestAbort, and recordChildSettled. Every other ledger operation is lane-local by construction and must execute inside the owning Conversation's Durable Object.`
-});
-const crossConversationStoreError = (operation, target) => ConversationStoreError.make({
-	operation,
-	message: `${operation} addressed to foreign Conversation ${target} is not route-capable; the closed cross-Object subset is materialize, append, read (paged), inspectTail, and export. Observation and checkpoints are lane-local by construction and must execute inside the owning Conversation's Durable Object.`
-});
-const makeTransportCall = (transport) => Effect.fn("DoPortRouting.transportCall")(function* (target, call) {
-	const encoded = yield* encodePortRequest(call).pipe(Effect.mapError((error) => PortProtocolError.make({ message: boundPortDiagnostic(`The port request could not be encoded: ${error.message}`) })));
-	return yield* decodePortResponse(yield* transport.call(target, encoded)).pipe(Effect.mapError((error) => PortProtocolError.make({ message: boundPortDiagnostic(`The port response could not be decoded: ${error.message}`) })));
-});
-const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServices")(function* (options) {
-	const local = yield* SubmissionLedger;
-	const transport = yield* ConversationPortTransport;
-	const transportCall = makeTransportCall(transport);
-	const submissionTarget = routableSubmissionTarget(options.localConversationId);
-	const routeFailure = (operation, target) => (error) => LedgerError.make({
-		operation,
-		message: boundPortDiagnostic(`Routed ${operation} to the Conversation Object owning ${target} failed: ${error.message}`),
-		cause: error
-	});
-	/**
-	* One routed ledger call: encode, deliver, decode, then narrow the uniform envelope to the
-	* operation's own result and failure surface. A foreign `LedgerError` is always in-channel;
-	* any failure outside the operation's declared surface — including protocol anomalies — is
-	* folded into a `LedgerError` naming the anomaly instead of being erased or re-thrown raw.
-	*/
-	const foreignLedgerCall = (operation, target, call, resultTag, isExpectedFailure) => transportCall(target, call).pipe(Effect.mapError(routeFailure(operation, target)), Effect.flatMap((response) => {
-		if (response._tag === "PortFailed") {
-			const failure = response.failure;
-			if (isExpectedFailure(failure)) return Effect.fail(failure);
-			if (failure._tag === "LedgerError") return Effect.fail(failure);
-			return Effect.fail(LedgerError.make({
-				operation,
-				message: boundPortDiagnostic(`The Conversation Object owning ${target} answered ${operation} with the out-of-contract failure ${failure._tag}: ${failure.message}`),
-				cause: failure
-			}));
-		}
-		const result = response.result;
-		if (!isResultTag(resultTag)(result)) return Effect.fail(LedgerError.make({
-			operation,
-			message: `The Conversation Object owning ${target} answered ${operation} with the mismatched result ${result._tag}; expected ${resultTag}.`
-		}));
-		return Effect.succeed(result);
-	}), Effect.withSpan("DoPortRouting.foreignLedgerCall", { attributes: {
-		operation,
-		target
-	} }));
-	/**
-	* Routed `resolveAdmission` — where the S2 tri-state becomes real (plan §1.3): when the
-	* owning Object cannot be reached, or its answer cannot be understood, the routed adapter
-	* answers `AdmissionIndeterminate{reason}` and NEVER `NotAdmitted` — an unreachable
-	* authority proves nothing, and only `NotAdmitted` permits an admission attempt (SUB-031).
-	* A typed `LedgerError` answered BY the authority still fails typed: the authority was
-	* reached and reported its own storage failure.
-	*/
-	const resolveForeignAdmission = (target, request) => transportCall(target, LedgerResolveAdmissionCall.make({ request })).pipe(Effect.flatMap((response) => {
-		if (response._tag === "PortFailed") {
-			if (response.failure._tag === "LedgerError") return Effect.fail(response.failure);
-			return Effect.succeed(AdmissionIndeterminate.make({ reason: boundPortDiagnostic(`The Conversation Object owning ${target} answered resolveAdmission with the out-of-contract failure ${response.failure._tag}: ${response.failure.message}`) }));
-		}
-		if (response.result._tag !== "LedgerResolveAdmissionResult") return Effect.succeed(AdmissionIndeterminate.make({ reason: boundPortDiagnostic(`The Conversation Object owning ${target} answered resolveAdmission with the mismatched result ${response.result._tag}.`) }));
-		return Effect.succeed(response.result.resolution);
-	}), Effect.catchTags({
-		PortTransportError: (error) => Effect.succeed(AdmissionIndeterminate.make({ reason: boundPortDiagnostic(`The Conversation Object owning ${target} is unreachable: ${error.message}`) })),
-		PortProtocolError: (error) => Effect.succeed(AdmissionIndeterminate.make({ reason: boundPortDiagnostic(`The answer of the Conversation Object owning ${target} could not be understood: ${error.message}`) }))
-	}), Effect.withSpan("DoPortRouting.resolveForeignAdmission", { attributes: { target } }));
-	const foreignLookupById = (operation, target, submissionId) => foreignLedgerCall(operation, target, LedgerLookupCall.make({ request: SubmissionLookupById.make({ submissionId }) }), "LedgerLookupResult", noExtraFailure).pipe(Effect.map((result) => result.submission === void 0 ? Option.none() : Option.some(result.submission)));
-	/**
-	* Enrich a LOCAL parent's recovery snapshot with the lane state of attached children whose
-	* rows live in other Durable Objects (plan §1.3): markers first (the local facet already
-	* consulted them), then a routed per-child `lookup` for any attached child that is neither
-	* local nor marker-settled. A transport failure surfaces as `LedgerError` so the alarm
-	* pass retries; the child's canonical Settlement remains the only authority (DUR-015).
-	*/
-	const enrichChildAttachments = Effect.fn("DoPortRouting.enrichChildAttachments")(function* (snapshot) {
-		const operation = "ledger load recovery snapshot";
-		const attachments = new Map(snapshot.childAttachments.map((attachment) => [attachment.childSubmissionId, attachment]));
-		let enriched = false;
-		for (const reservation of snapshot.childReservations) {
-			const childSubmissionId = reservation.childSubmissionId;
-			if (childSubmissionId === void 0 || attachments.has(childSubmissionId)) continue;
-			const target = yield* submissionTarget(operation, childSubmissionId);
-			if (target._tag !== "foreign") continue;
-			const child = yield* foreignLookupById(operation, target.conversationId, childSubmissionId);
-			if (Option.isNone(child)) continue;
-			attachments.set(childSubmissionId, ChildAttachmentSnapshot.make({
-				toolCallId: reservation.parentToolCallId,
-				childSubmissionId,
-				childState: child.value.state,
-				...child.value.settledOutcome === void 0 ? {} : { childOutcome: child.value.settledOutcome }
-			}));
-			enriched = true;
-		}
-		if (!enriched) return snapshot;
-		const ordered = [];
-		for (const reservation of snapshot.childReservations) {
-			if (reservation.childSubmissionId === void 0) continue;
-			const attachment = attachments.get(reservation.childSubmissionId);
-			if (attachment !== void 0) ordered.push(attachment);
-		}
-		return RecoverySnapshot.make({
-			...snapshot,
-			childAttachments: ordered
-		});
-	});
-	const routed = SubmissionLedger.of({
-		capabilities: local.capabilities,
-		admit: (request) => request.conversationId === options.localConversationId ? local.admit(request) : foreignLedgerCall("ledger admit", request.conversationId, LedgerAdmitCall.make({ request }), "LedgerAdmitResult", isAdmitConflict).pipe(Effect.map((reply) => reply.result)),
-		markReady: (request) => submissionTarget("ledger mark ready", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markReady(request) : foreignLedgerCall("ledger mark ready", target.conversationId, LedgerMarkReadyCall.make({ request }), "LedgerMarkReadyResult", noExtraFailure).pipe(Effect.asVoid))),
-		lookup: (request) => request._tag === "SubmissionLookupById" ? submissionTarget("ledger lookup", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.lookup(request) : foreignLookupById("ledger lookup", target.conversationId, request.submissionId))) : request.conversationId === options.localConversationId ? local.lookup(request) : foreignLedgerCall("ledger lookup", request.conversationId, LedgerLookupCall.make({ request }), "LedgerLookupResult", noExtraFailure).pipe(Effect.map((result) => result.submission === void 0 ? Option.none() : Option.some(result.submission))),
-		resolveAdmission: (request) => request.conversationId === options.localConversationId ? local.resolveAdmission(request) : resolveForeignAdmission(request.conversationId, request),
-		requestAbort: (request) => submissionTarget("ledger request abort", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.requestAbort(request) : foreignLedgerCall("ledger request abort", target.conversationId, LedgerRequestAbortCall.make({ request }), "LedgerRequestAbortResult", isAbortConflict).pipe(Effect.map((reply) => reply.intent)))),
-		recordChildSettled: (request) => submissionTarget("ledger record child settled", request.parentSubmissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.recordChildSettled(request) : foreignLedgerCall("ledger record child settled", target.conversationId, LedgerRecordChildSettledCall.make({ request }), "LedgerRecordChildSettledResult", noExtraFailure).pipe(Effect.map((reply) => reply.outcome)))),
-		claim: (request) => request.conversationId === options.localConversationId ? local.claim(request) : Effect.fail(crossConversationLedgerError("ledger claim", request.conversationId)),
-		claimJoining: (request) => request.conversationId === options.localConversationId ? local.claimJoining(request) : Effect.fail(crossConversationLedgerError("ledger claim joining", request.conversationId)),
-		renewOwnership: (request) => submissionTarget("ledger renew ownership", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.renewOwnership(request) : Effect.fail(crossConversationLedgerError("ledger renew ownership", target.conversationId)))),
-		releaseOwnership: (request) => submissionTarget("ledger release ownership", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.releaseOwnership(request) : Effect.fail(crossConversationLedgerError("ledger release ownership", target.conversationId)))),
-		markInputApplied: (request) => submissionTarget("ledger mark input applied", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markInputApplied(request) : Effect.fail(crossConversationLedgerError("ledger mark input applied", target.conversationId)))),
-		reserveSettlement: (request) => submissionTarget("ledger reserve settlement", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.reserveSettlement(request) : Effect.fail(crossConversationLedgerError("ledger reserve settlement", target.conversationId)))),
-		finalizeSettlement: (request) => submissionTarget("ledger finalize settlement", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.finalizeSettlement(request) : Effect.fail(crossConversationLedgerError("ledger finalize settlement", target.conversationId)))),
-		markJoined: (request) => submissionTarget("ledger mark joined", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markJoined(request) : Effect.fail(crossConversationLedgerError("ledger mark joined", target.conversationId)))),
-		revertJoining: (request) => submissionTarget("ledger revert joining", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.revertJoining(request) : Effect.fail(crossConversationLedgerError("ledger revert joining", target.conversationId)))),
-		suspend: (request) => submissionTarget("ledger suspend", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.suspend(request) : Effect.fail(crossConversationLedgerError("ledger suspend", target.conversationId)))),
-		recordApprovalDecision: (command) => submissionTarget("ledger record approval decision", command.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.recordApprovalDecision(command) : Effect.fail(crossConversationLedgerError("ledger record approval decision", target.conversationId)))),
-		markUnknown: (request) => submissionTarget("ledger mark unknown", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markUnknown(request) : Effect.fail(crossConversationLedgerError("ledger mark unknown", target.conversationId)))),
-		recordUnknownResolution: (command) => submissionTarget("ledger record unknown resolution", command.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.recordUnknownResolution(command) : Effect.fail(crossConversationLedgerError("ledger record unknown resolution", target.conversationId)))),
-		reserveChildBudget: (request) => submissionTarget("ledger reserve child budget", request.parentSubmissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.reserveChildBudget(request) : Effect.fail(crossConversationLedgerError("ledger reserve child budget", target.conversationId)))),
-		attachChildToReservation: local.attachChildToReservation,
-		beginChildBudgetRelease: local.beginChildBudgetRelease,
-		releaseChildBudget: local.releaseChildBudget,
-		scanNonterminal: local.scanNonterminal,
-		loadRecoverySnapshot: (request) => submissionTarget("ledger load recovery snapshot", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.loadRecoverySnapshot(request).pipe(Effect.flatMap(enrichChildAttachments)) : Effect.fail(crossConversationLedgerError("ledger load recovery snapshot", target.conversationId))))
-	});
-	return Context.make(SubmissionLedger, routed);
-});
-const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices")(function* (options) {
-	const local = yield* ConversationStore;
-	const transport = yield* ConversationPortTransport;
-	const transportCall = makeTransportCall(transport);
-	const routeFailure = (operation, target) => (error) => ConversationStoreError.make({
-		operation,
-		message: boundPortDiagnostic(`Routed ${operation} to the Conversation Object owning ${target} failed: ${error.message}`),
-		cause: error
-	});
-	/** The store twin of `foreignLedgerCall` with `ConversationStoreError` as the base error. */
-	const foreignStoreCall = (operation, target, call, resultTag, isExpectedFailure) => transportCall(target, call).pipe(Effect.mapError(routeFailure(operation, target)), Effect.flatMap((response) => {
-		if (response._tag === "PortFailed") {
-			const failure = response.failure;
-			if (isExpectedFailure(failure)) return Effect.fail(failure);
-			if (failure._tag === "ConversationStoreError") return Effect.fail(failure);
-			return Effect.fail(ConversationStoreError.make({
-				operation,
-				message: boundPortDiagnostic(`The Conversation Object owning ${target} answered ${operation} with the out-of-contract failure ${failure._tag}: ${failure.message}`),
-				cause: failure
-			}));
-		}
-		const result = response.result;
-		if (!isResultTag(resultTag)(result)) return Effect.fail(ConversationStoreError.make({
-			operation,
-			message: `The Conversation Object owning ${target} answered ${operation} with the mismatched result ${result._tag}; expected ${resultTag}.`
-		}));
-		return Effect.succeed(result);
-	}), Effect.withSpan("DoPortRouting.foreignStoreCall", { attributes: {
-		operation,
-		target
-	} }));
-	const routed = ConversationStore.of({
-		materialize: (request) => request.conversationId === options.localConversationId ? local.materialize(request) : foreignStoreCall("conversation materialize", request.conversationId, StoreMaterializeCall.make({ request }), "StoreMaterializeResult", isFenceRejected).pipe(Effect.asVoid),
-		append: (request) => request.conversationId === options.localConversationId ? local.append(request) : foreignStoreCall("conversation append", request.conversationId, StoreAppendCall.make({ request }), "StoreAppendResult", isAppendFailure).pipe(Effect.map((reply) => reply.result)),
-		read: (request) => request.conversationId === options.localConversationId ? local.read(request) : Stream.unwrap(foreignStoreCall("conversation read", request.conversationId, StoreReadPageCall.make({ request }), "StoreReadPageResult", isNotMaterialized).pipe(Effect.map((reply) => Stream.fromIterable(reply.records)))),
-		inspectTail: (request) => request.conversationId === options.localConversationId ? local.inspectTail(request) : foreignStoreCall("conversation inspect tail", request.conversationId, StoreInspectTailCall.make({ request }), "StoreInspectTailResult", isNotMaterialized).pipe(Effect.map((reply) => reply.tail)),
-		export: (request) => request.conversationId === options.localConversationId ? local.export(request) : foreignStoreCall("conversation export", request.conversationId, StoreExportCall.make({ request }), "StoreExportResult", isNotMaterialized).pipe(Effect.map((reply) => reply.export)),
-		observe: (request) => request.conversationId === options.localConversationId ? local.observe(request) : Stream.unwrap(Effect.fail(crossConversationStoreError("conversation observe", request.conversationId))),
-		saveCheckpoint: (request) => request.checkpoint.conversationId === options.localConversationId ? local.saveCheckpoint(request) : Effect.fail(crossConversationStoreError("conversation save checkpoint", request.checkpoint.conversationId)),
-		loadCheckpoint: (request) => request.conversationId === options.localConversationId ? local.loadCheckpoint(request) : Effect.fail(crossConversationStoreError("conversation load checkpoint", request.conversationId))
-	});
-	return Context.make(ConversationStore, routed);
-});
-/**
-* Routing decorator over the LOCAL `SubmissionLedger` facet (plan §1.3): a request addressing
-* this Object's Conversation executes locally; a route-capable request addressing another
-* Conversation is Schema-encoded onto the `ConversationPortTransport` and executed by the
-* owning Object's local facet; any other foreign request fails fast typed. Provide the WP1
-* local facet (`submissionLedgerLayer`/`ledgerLayer`) and a transport to close it.
-*/
-const routedSubmissionLedgerLayer = (options) => Layer.effectContext(makeRoutedLedgerServices(options));
-/**
-* Routing decorator over the LOCAL `ConversationStore` facet (plan §1.3): this-conversation
-* requests execute locally; foreign materialize/append/read/inspectTail/export travel the
-* transport; foreign observation and checkpoints fail fast typed.
-*/
-const routedConversationStoreLayer = (options) => Layer.effectContext(makeRoutedStoreServices(options));
-/** Fold one port operation's typed failures into the uniform response envelope. */
-const capture = (effect) => effect.pipe(Effect.map((result) => PortSucceeded.make({ result })), Effect.catch((failure) => Effect.succeed(PortFailed.make({ failure }))));
-/**
-* Execute one decoded port request against THIS Object's LOCAL facets — the owner-side half
-* of the routed ports (plan §1.3). Callers must provide the WP1 local facets, never the
-* routed decorators: the routing layer already established that this Object owns the
-* addressed Conversation, and re-routing here could bounce a request between Objects.
-* Failures never escape — every typed port failure becomes a `PortFailed` envelope that
-* re-decodes on the caller side.
-*/
-const executePortRequest = Effect.fn("DoPortRouting.executePortRequest")(function* (request) {
-	switch (request._tag) {
-		case "LedgerAdmit": {
-			const ledger = yield* SubmissionLedger;
-			return yield* capture(ledger.admit(request.request).pipe(Effect.map((result) => LedgerAdmitResult.make({ result }))));
-		}
-		case "LedgerMarkReady": {
-			const ledger = yield* SubmissionLedger;
-			return yield* capture(ledger.markReady(request.request).pipe(Effect.map(() => LedgerMarkReadyResult.make({}))));
-		}
-		case "LedgerLookup": {
-			const ledger = yield* SubmissionLedger;
-			return yield* capture(ledger.lookup(request.request).pipe(Effect.map((submission) => Option.isSome(submission) ? LedgerLookupResult.make({ submission: submission.value }) : LedgerLookupResult.make({}))));
-		}
-		case "LedgerResolveAdmission": {
-			const ledger = yield* SubmissionLedger;
-			return yield* capture(ledger.resolveAdmission(request.request).pipe(Effect.map((resolution) => LedgerResolveAdmissionResult.make({ resolution }))));
-		}
-		case "LedgerRequestAbort": {
-			const ledger = yield* SubmissionLedger;
-			return yield* capture(ledger.requestAbort(request.request).pipe(Effect.map((intent) => LedgerRequestAbortResult.make({ intent }))));
-		}
-		case "LedgerRecordChildSettled": {
-			const ledger = yield* SubmissionLedger;
-			return yield* capture(ledger.recordChildSettled(request.request).pipe(Effect.map((outcome) => LedgerRecordChildSettledResult.make({ outcome }))));
-		}
-		case "StoreMaterialize": {
-			const store = yield* ConversationStore;
-			return yield* capture(store.materialize(request.request).pipe(Effect.map(() => StoreMaterializeResult.make({}))));
-		}
-		case "StoreAppend": {
-			const store = yield* ConversationStore;
-			return yield* capture(store.append(request.request).pipe(Effect.map((result) => StoreAppendResult.make({ result }))));
-		}
-		case "StoreReadPage": {
-			const store = yield* ConversationStore;
-			return yield* capture(store.read(request.request).pipe(Stream.runCollect, Effect.map((records) => StoreReadPageResult.make({ records: [...records] }))));
-		}
-		case "StoreInspectTail": {
-			const store = yield* ConversationStore;
-			return yield* capture(store.inspectTail(request.request).pipe(Effect.map((tail) => StoreInspectTailResult.make({ tail }))));
-		}
-		case "StoreExport": {
-			const store = yield* ConversationStore;
-			return yield* capture(store.export(request.request).pipe(Effect.map((conversationExport) => StoreExportResult.make({ export: conversationExport }))));
-		}
-	}
-});
-/**
-* The last-resort wire fallback when even encoding a response fails: the literal encoded
-* form of `PortFailed(PortProtocolError)` — tagged classes of bounded strings encode to
-* exactly this shape, so no Schema round trip is needed to produce it.
-*/
-const encodedProtocolFailure = (message) => ({
-	_tag: "PortFailed",
-	failure: {
-		_tag: "PortProtocolError",
-		message: boundPortDiagnostic(message)
-	}
-});
-/**
-* The complete owner-side endpoint body for `portCall` (D-P6-3): decode the wire request,
-* execute it against this Object's LOCAL facets, and answer with the encoded response
-* envelope. Total by construction — a request that cannot be decoded, or a response that
-* cannot be encoded, answers `PortFailed(PortProtocolError)` instead of throwing, so the
-* transport never has to interpret exceptions as protocol answers.
-*/
-const handleEncodedPortRequest = Effect.fn("DoPortRouting.handleEncodedPortRequest")(function* (encoded) {
-	return yield* encodePortResponse(yield* decodePortRequest(encoded).pipe(Effect.flatMap(executePortRequest), Effect.catch((error) => Effect.succeed(PortFailed.make({ failure: PortProtocolError.make({ message: boundPortDiagnostic(`The port request could not be decoded: ${error.message}`) }) }))))).pipe(Effect.catch((error) => Effect.succeed(encodedProtocolFailure(`The port response could not be encoded: ${error.message}`))));
-});
-//#endregion
-export { ConversationPortTransport, CurrentDoStorageVersion, DEFAULT_MAX_STORED_VALUE_BYTES, DoAppendConflict, DoCheckpointConflict, DoFenceRejected, DoLedgerError, DoStorageCompatibilityError, DoStorageConfig, DoStorageConfigValue, DoStorageCorruptionError, DoStorageError, DoStorageFailpoint, DoStorageFailpointError, DoStorageFailpointLocation, DoStorageFailpointTestControl, DoValueBoundExceeded, LedgerAdmitCall, LedgerAdmitResult, LedgerLookupCall, LedgerLookupResult, LedgerMarkReadyCall, LedgerMarkReadyResult, LedgerRecordChildSettledCall, LedgerRecordChildSettledResult, LedgerRequestAbortCall, LedgerRequestAbortResult, LedgerResolveAdmissionCall, LedgerResolveAdmissionResult, MAX_PORT_DIAGNOSTIC_LENGTH, PortFailed, PortFailure, PortProtocolError, PortRequest, PortResponse, PortResult, PortSucceeded, PortTransportError, StoreAppendCall, StoreAppendResult, StoreExportCall, StoreExportResult, StoreInspectTailCall, StoreInspectTailResult, StoreMaterializeCall, StoreMaterializeResult, StoreReadPageCall, StoreReadPageResult, boundPortDiagnostic, conversationStoreLayer, decodePortRequest, decodePortResponse, doMigrations, encodePortRequest, encodePortResponse, evictionFailpointHandler, executePortRequest, handleEncodedPortRequest, layer, ledgerLayer, observationOffsetAt, portTransportFailure, routedConversationStoreLayer, routedSubmissionLedgerLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer };
-
-//# sourceMappingURL=index.mjs.map
+import { t as DoStorageConfig_exports } from "./DoStorageConfig.mjs";
+import { t as DoStorageFailpoint_exports } from "./DoStorageFailpoint.mjs";
+import { t as DoStorageError_exports } from "./DoStorageError.mjs";
+import { t as DoMessageDeliveryStore_exports } from "./DoMessageDeliveryStore.mjs";
+import { t as DoMemoryStore_exports } from "./DoMemoryStore.mjs";
+import { t as DoScheduleStore_exports } from "./DoScheduleStore.mjs";
+import { t as DoStorageVersion_exports } from "./DoStorageVersion.mjs";
+import { t as DoThreadStore_exports } from "./DoThreadStore.mjs";
+import { t as DoSubmissionLedger_exports } from "./DoSubmissionLedger.mjs";
+import { t as DoSubscriptionStore_exports } from "./DoSubscriptionStore.mjs";
+import { t as MemoryProtocol_exports } from "./MemoryProtocol.mjs";
+import { t as PortProtocol_exports } from "./PortProtocol.mjs";
+import { t as PortRouting_exports } from "./PortRouting.mjs";
+export { DoMemoryStore_exports as DoMemoryStore, DoMessageDeliveryStore_exports as DoMessageDeliveryStore, DoScheduleStore_exports as DoScheduleStore, DoStorageConfig_exports as DoStorageConfig, DoStorageError_exports as DoStorageError, DoStorageFailpoint_exports as DoStorageFailpoint, DoStorageVersion_exports as DoStorageVersion, DoSubmissionLedger_exports as DoSubmissionLedger, DoSubscriptionStore_exports as DoSubscriptionStore, DoThreadStore_exports as DoThreadStore, MemoryProtocol_exports as MemoryProtocol, PortProtocol_exports as PortProtocol, PortRouting_exports as PortRouting };