@effect-agent/storage-sqlite 0.0.1-beta.0

package/dist/index.mjs

@@ -0,0 +1,3063 @@
+import { AbortCommand, AbortIntent, AdmissionAdmitted, AdmissionConflict, AdmissionNotAdmitted, AdmissionRequest, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecision, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildReservationStatus, ChildSettledNotification, 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, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SuspendRequest, SuspensionReason, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, digestCanonicalBatch, submissionAbortRecordId } from "@effect-agent/session";
+import { Clock, Context, Crypto, DateTime, Duration, Effect, Exit, Layer, Option, Ref, Schema, Stream } from "effect";
+import { SqliteClient, SqliteMigrator } from "@effect/sql-sqlite-node";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import { NodeCrypto } from "@effect/platform-node";
+//#region src/errors.ts
+/** The SQLite file uses a private-development format this adapter cannot read. */
+var SqliteStorageCompatibilityError = class extends Schema.TaggedErrorClass()("SqliteStorageCompatibilityError", {
+	actualVersion: Schema.Int,
+	message: Schema.String,
+	supportedVersion: Schema.Int
+}) {};
+/** Stored bytes failed the current Schema and cannot be used as recovery truth. */
+var SqliteStorageCorruptionError = class extends Schema.TaggedErrorClass()("SqliteStorageCorruptionError", {
+	message: Schema.String,
+	rowKey: Schema.String,
+	table: Schema.String
+}) {};
+/** SQLite infrastructure failed while opening or operating the store. */
+var SqliteStorageError = class extends Schema.TaggedErrorClass()("SqliteStorageError", {
+	cause: Schema.optionalKey(Schema.Defect()),
+	message: Schema.String,
+	operation: Schema.String
+}) {};
+/**
+* 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 SqliteLedgerError = class extends Schema.TaggedErrorClass()("SqliteLedgerError", {
+	cause: Schema.optionalKey(Schema.Defect()),
+	message: Schema.String,
+	operation: Schema.String
+}) {};
+/**
+* A canonical batch retry conflicts with existing append state. Tail conflicts carry the
+* actual committed tail as a diagnostic resume hint.
+*/
+var SqliteAppendConflict = class extends Schema.TaggedErrorClass()("SqliteAppendConflict", {
+	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 SqliteFenceRejected = class extends Schema.TaggedErrorClass()("SqliteFenceRejected", {
+	actualEpoch: ProducerEpoch,
+	message: Schema.String,
+	producerEpoch: ProducerEpoch
+}) {};
+/**
+* A write transaction could not acquire the SQLite write lock within the configured busy
+* timeout (SQLITE_BUSY / SQLITE_LOCKED). Another transiently coexisting owner is writing;
+* the operation did not mutate canonical state and is safe to retry.
+*/
+var SqliteWriteContention = class extends Schema.TaggedErrorClass()("SqliteWriteContention", {
+	cause: Schema.optionalKey(Schema.Defect()),
+	message: Schema.String,
+	operation: Schema.String
+}) {};
+/** A checkpoint conflicts with a previously stored checkpoint at the same offset. */
+var SqliteCheckpointConflict = class extends Schema.TaggedErrorClass()("SqliteCheckpointConflict", { message: Schema.String }) {};
+const SqliteStorageFailpointLocation = 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 SQLite operation boundary. */
+var SqliteStorageFailpointError = class extends Schema.TaggedErrorClass()("SqliteStorageFailpointError", { location: SqliteStorageFailpointLocation }) {
+	get message() {
+		return `Injected SQLite storage failure at ${this.location}.`;
+	}
+};
+//#endregion
+//#region src/migrations.ts
+const CurrentSqliteStorageVersion = 4;
+const sqliteMigrations = SqliteMigrator.fromRecord({
+	"1_current_persistent_conversation_foundation": 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`PRAGMA user_version = 1`.withoutTransform;
+	}),
+	"2_durable_submission_ledger": Effect.gen(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		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,
+        UNIQUE (conversation_id, principal, idempotency_key),
+        UNIQUE (conversation_id, queue_sequence)
+      )
+    `.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`PRAGMA user_version = 2`.withoutTransform;
+	}),
+	"3_durable_tools_and_joined_input": Effect.gen(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		yield* sql`
+      ALTER TABLE effect_agent_submissions
+        ADD COLUMN joined_host_submission_id TEXT
+    `.withoutTransform;
+		yield* sql`
+      ALTER TABLE effect_agent_submissions
+        ADD COLUMN suspended_reason_json TEXT
+    `.withoutTransform;
+		yield* sql`
+      ALTER TABLE effect_agent_submissions
+        ADD COLUMN suspended_at TEXT
+    `.withoutTransform;
+		yield* sql`
+      ALTER TABLE effect_agent_submissions
+        ADD COLUMN unknown_reason TEXT
+    `.withoutTransform;
+		yield* sql`
+      ALTER TABLE effect_agent_submissions
+        ADD COLUMN unknown_tool_call_ids_json TEXT
+    `.withoutTransform;
+		yield* sql`
+      CREATE INDEX effect_agent_submissions_joined_host
+        ON effect_agent_submissions (joined_host_submission_id)
+    `.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`PRAGMA user_version = 3`.withoutTransform;
+	}),
+	"4_durable_subagents": Effect.gen(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		yield* sql`
+      ALTER TABLE effect_agent_submissions
+        ADD COLUMN parent_submission_id TEXT
+    `.withoutTransform;
+		yield* sql`
+      ALTER TABLE effect_agent_submissions
+        ADD COLUMN parent_tool_call_id TEXT
+    `.withoutTransform;
+		yield* sql`
+      CREATE INDEX effect_agent_submissions_parent
+        ON effect_agent_submissions (parent_submission_id)
+    `.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`PRAGMA user_version = 4`.withoutTransform;
+	})
+});
+//#endregion
+//#region src/sqlite-journal.ts
+const BoundedStoredText$1 = Schema.String.check(Schema.isMaxLength(16 * 1024 * 1024));
+const BoundedIdentifier$1 = Schema.NonEmptyString.check(Schema.isMaxLength(1024));
+const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const MAX_RECORDS_PER_CONVERSATION = 65536;
+const MAX_STORED_TEXT_BYTES = 16 * 1024 * 1024;
+const MAX_IDENTIFIER_LENGTH = 1024;
+const storedTextBytes = (value) => new TextEncoder().encode(value).byteLength;
+var SqliteVersionRow = class extends Schema.Class("SqliteVersionRow")({ user_version: NonNegativeInt }) {};
+var SqliteJournalModeRow = class extends Schema.Class("SqliteJournalModeRow")({ journal_mode: Schema.NonEmptyString.check(Schema.isMaxLength(32)) }) {};
+var SqliteNameRow = class extends Schema.Class("SqliteNameRow")({ 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-sqlite/RawRecord")({
+	recordId: BoundedIdentifier$1,
+	recordJson: BoundedStoredText$1
+}) {};
+var RawAppendRequest = class extends Schema.Class("@effect-agent/storage-sqlite/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-sqlite/RawAppendResult")({
+	firstSequence: CanonicalSequence,
+	lastSequence: CanonicalSequence,
+	replayed: Schema.Boolean,
+	tailDigest: BoundedStoredText$1
+}) {};
+var RawReadRequest = class extends Schema.Class("@effect-agent/storage-sqlite/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-sqlite/RawCheckpoint")({
+	checkpointJson: BoundedStoredText$1,
+	conversationId: BoundedIdentifier$1,
+	tailDigest: BoundedStoredText$1,
+	throughSequence: CanonicalSequence
+}) {};
+var RawConversationExport = class extends Schema.Class("@effect-agent/storage-sqlite/RawConversationExport")({
+	batches: Schema.Array(BatchRow),
+	checkpoints: Schema.Array(CheckpointRow),
+	conversation: ConversationRow,
+	records: Schema.Array(RecordRow)
+}) {};
+const noFailpoint$1 = () => Effect.void;
+const storageError = (operation) => (error) => SqliteStorageError.make({
+	cause: error,
+	operation,
+	message: error.message
+});
+/** Decode raw SQLite rows against a Schema, reporting failures as typed corruption. */
+const decodeRows = Effect.fn("SqliteJournal.decodeRows")((schema, table, rowKey, rows) => Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError((error) => SqliteStorageCorruptionError.make({
+	table,
+	rowKey,
+	message: String(error)
+}))));
+/** Decode exactly one raw SQLite row against a Schema, reporting failures as typed corruption. */
+const decodeSingleRow = Effect.fn("SqliteJournal.decodeSingleRow")((schema, table, rowKey, rows) => decodeRows(schema, table, rowKey, rows).pipe(Effect.flatMap((decoded) => decoded.length === 1 ? Effect.succeed(decoded[0]) : Effect.fail(SqliteStorageCorruptionError.make({
+	table,
+	rowKey,
+	message: `Expected exactly one row but found ${decoded.length}.`
+})))));
+const ensureCurrentStorage = Effect.fn("SqliteJournal.ensureCurrentStorage")(function* (sql, failpoint = noFailpoint$1, busyTimeoutMillis = 5e3) {
+	yield* sql`PRAGMA foreign_keys = ON`.pipe(Effect.mapError(storageError("enable foreign keys")));
+	yield* sql.unsafe(`PRAGMA busy_timeout = ${busyTimeoutMillis}`).pipe(Effect.mapError(storageError("configure busy timeout")));
+	const journalModeRows = yield* sql`PRAGMA journal_mode`.pipe(Effect.mapError(storageError("read journal mode")));
+	const journalMode = yield* decodeSingleRow(Schema.Array(SqliteJournalModeRow), "pragma_journal_mode", "singleton", journalModeRows);
+	if (journalMode.journal_mode.toLowerCase() !== "wal") return yield* SqliteStorageCompatibilityError.make({
+		actualVersion: 0,
+		supportedVersion: 4,
+		message: `SQLite WAL mode is required; the database reported ${journalMode.journal_mode}.`
+	});
+	const versionRows = yield* sql`PRAGMA user_version`.pipe(Effect.mapError(storageError("read storage version")));
+	const version = yield* decodeSingleRow(Schema.Array(SqliteVersionRow), "pragma_user_version", "singleton", versionRows);
+	if (version.user_version !== 0 && version.user_version !== 4) return yield* SqliteStorageCompatibilityError.make({
+		actualVersion: version.user_version,
+		supportedVersion: 4,
+		message: `The SQLite file uses private-development storage version ${version.user_version}; this build supports exactly version 4. Reset the database file explicitly; automatic stored-data migrations are not provided during private development.`
+	});
+	if (version.user_version === 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(SqliteNameRow), "sqlite_master", "effect_agent_%", existingRows)).length > 0) return yield* SqliteStorageCompatibilityError.make({
+			actualVersion: 0,
+			supportedVersion: 4,
+			message: "The SQLite file contains unversioned Effect Agent tables. Reset it explicitly; refusing to mutate ambiguous stored data."
+		});
+		yield* SqliteMigrator.run({ loader: sqliteMigrations }).pipe(Effect.provideService(SqlClient.SqlClient, sql), Effect.mapError((error) => SqliteStorageError.make({
+			cause: error,
+			operation: "initialize current storage",
+			message: error.message
+		})));
+	}
+	const requiredRows = yield* sql`
+    SELECT name
+    FROM sqlite_master
+    WHERE type = 'table'
+      AND name IN (
+        'effect_agent_conversations',
+        'effect_agent_canonical_batches',
+        'effect_agent_canonical_records',
+        'effect_agent_checkpoints',
+        'effect_agent_submissions',
+        'effect_agent_submission_ownership',
+        'effect_agent_attempts',
+        'effect_agent_settlement_reservations',
+        'effect_agent_abort_intents',
+        'effect_agent_approval_decisions',
+        'effect_agent_unknown_resolutions'
+      )
+    ORDER BY name
+  `.pipe(Effect.mapError(storageError("verify storage tables")));
+	if ((yield* decodeRows(Schema.Array(SqliteNameRow), "sqlite_master", "required_tables", requiredRows)).length !== 11) return yield* SqliteStorageCompatibilityError.make({
+		actualVersion: 4,
+		supportedVersion: 4,
+		message: "The SQLite file claims the current format but is missing required tables. Reset the corrupt private-development data."
+	});
+	return makeJournal(sql, failpoint);
+});
+const makeJournal = (sql, failpoint) => {
+	const classifyWriteFailure = (operation) => (error) => error.reason._tag === "LockTimeoutError" ? SqliteWriteContention.make({
+		cause: error,
+		operation,
+		message: `Another producer holds the SQLite write lock; ${operation} is safe to retry.`
+	}) : storageError(operation)(error);
+	/**
+	* Runs one journal write transaction under `BEGIN IMMEDIATE`. SQLite's deferred `BEGIN`
+	* would let a read-then-write transaction start as a reader and fail with
+	* SQLITE_BUSY_SNAPSHOT on upgrade, which `busy_timeout` never retries. Taking the write
+	* lock up front keeps cross-owner contention inside the bounded busy retry; a lock
+	* timeout is classified as the retryable SqliteWriteContention. A failed `BEGIN` leaves
+	* no transaction, so no rollback is attempted for it.
+	*
+	* Journal write transactions are always top level. Nesting one inside another would
+	* deadlock the single-connection client, so new journal operations must not wrap this
+	* helper inside another transaction.
+	*/
+	const withWriteTransaction = (operation) => (effect) => Effect.uninterruptibleMask((restore) => Effect.scoped(Effect.gen(function* () {
+		const connection = yield* sql.reserve.pipe(Effect.mapError(classifyWriteFailure(operation)));
+		yield* connection.executeUnprepared("BEGIN IMMEDIATE", [], void 0).pipe(Effect.mapError(classifyWriteFailure(operation)));
+		const exit = yield* restore(Effect.provideService(effect, sql.transactionService, [connection, 0])).pipe(Effect.exit);
+		if (Exit.isSuccess(exit)) {
+			yield* connection.executeUnprepared("COMMIT", [], void 0).pipe(Effect.mapError(classifyWriteFailure(operation)));
+			return exit.value;
+		}
+		yield* Effect.orDie(connection.executeUnprepared("ROLLBACK", [], void 0));
+		return yield* exit;
+	})).pipe(Effect.withSpan("SqliteJournal.withWriteTransaction", { attributes: { operation } })));
+	const materialize = Effect.fn("SqliteJournal.materialize")(function* (conversationId, createdAt, emptyTailDigest, producerEpoch) {
+		if (conversationId.length > MAX_IDENTIFIER_LENGTH || storedTextBytes(emptyTailDigest) > MAX_STORED_TEXT_BYTES) return yield* SqliteStorageError.make({
+			operation: "materialize conversation",
+			message: "Conversation identity or initial digest exceeds the SQLite storage bounds."
+		});
+		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* SqliteStorageCorruptionError.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* SqliteFenceRejected.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("SqliteJournal.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("SqliteJournal.append")(function* (request) {
+		if (request.conversationId.length > MAX_IDENTIFIER_LENGTH || request.batchId.length > MAX_IDENTIFIER_LENGTH || storedTextBytes(request.batchJson) > MAX_STORED_TEXT_BYTES || storedTextBytes(request.batchDigest) > MAX_STORED_TEXT_BYTES || storedTextBytes(request.tailDigest) > MAX_STORED_TEXT_BYTES || request.records.some((record) => record.recordId.length > MAX_IDENTIFIER_LENGTH || storedTextBytes(record.recordJson) > MAX_STORED_TEXT_BYTES)) return yield* SqliteStorageError.make({
+			operation: "append canonical batch",
+			message: "Canonical identifiers or encoded JSON exceed the SQLite storage bounds."
+		});
+		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* SqliteAppendConflict.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* SqliteFenceRejected.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* SqliteStorageCorruptionError.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* SqliteAppendConflict.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* SqliteAppendConflict.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* SqliteStorageError.make({
+				operation: "append canonical batch",
+				message: `Conversation record limit ${MAX_RECORDS_PER_CONVERSATION} would be exceeded.`
+			});
+			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(recordIds)}
+          ORDER BY sequence
+        `.pipe(Effect.mapError(storageError("check canonical record identities")));
+			const existingRecords = yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}/record_ids`, existingRecordRows);
+			if (existingRecords.length > 0) return yield* SqliteAppendConflict.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) => SqliteStorageError.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) => SqliteStorageError.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("SqliteJournal.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("SqliteJournal.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("SqliteJournal.saveCheckpoint")(function* (checkpoint) {
+		if (checkpoint.conversationId.length > MAX_IDENTIFIER_LENGTH || storedTextBytes(checkpoint.checkpointJson) > MAX_STORED_TEXT_BYTES) return yield* SqliteStorageError.make({
+			operation: "save checkpoint",
+			message: "Checkpoint identity or encoded JSON exceeds the SQLite storage bounds."
+		});
+		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* SqliteCheckpointConflict.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* SqliteStorageCorruptionError.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* SqliteCheckpointConflict.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("SqliteJournal.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,
+		exportConversation,
+		getConversation,
+		getTailDigestAt: Effect.fn("SqliteJournal.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("SqliteJournal.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 initializeSqliteJournal = ensureCurrentStorage;
+//#endregion
+//#region src/sqlite-storage-config.ts
+const ObservationPollInterval = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const BusyTimeoutMillis = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const OwnershipLeaseMillis = Schema.Int.check(Schema.isGreaterThan(0));
+/**
+* Validated construction configuration consumed by the SQLite storage Layer. The database
+* identity itself belongs to the SqlClient Layer; duplicating it here could silently diverge
+* from the connection actually in use.
+*/
+var SqliteStorageConfigValue = class extends Schema.Class("@effect-agent/storage-sqlite/SqliteStorageConfigValue")({
+	observationPollInterval: ObservationPollInterval,
+	/** Bounded SQLITE_BUSY retry window for write-lock acquisition, in milliseconds. */
+	busyTimeout: BusyTimeoutMillis,
+	/**
+	* Submission ownership lease duration in milliseconds (D5). The lease is a liveness hint
+	* that makes an abandoned claim reclaimable; correctness never depends on it because every
+	* canonical append is fenced by producer epoch. Convenience layers default this to
+	* `DEFAULT_OWNERSHIP_LEASE_DURATION` from `@effect-agent/session`.
+	*/
+	ownershipLeaseDuration: OwnershipLeaseMillis,
+	/**
+	* 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 SQLite storage configuration authority. */
+var SqliteStorageConfig = class extends Context.Service()("@effect-agent/storage-sqlite/SqliteStorageConfig") {};
+//#endregion
+//#region src/sqlite-storage-failpoint.ts
+const noFailpoint = () => Effect.void;
+/** Test-only control for replacing the active SQLite failpoint handler. */
+var SqliteStorageFailpointTestControl = class extends Context.Service()("@effect-agent/storage-sqlite/SqliteStorageFailpointTestControl") {};
+/** Explicit fault-injection authority used at SQLite operation boundaries. */
+var SqliteStorageFailpoint = class SqliteStorageFailpoint extends Context.Service()("@effect-agent/storage-sqlite/SqliteStorageFailpoint") {
+	/** 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(SqliteStorageFailpoint, SqliteStorageFailpoint.of({ hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))) })).pipe(Context.add(SqliteStorageFailpointTestControl, SqliteStorageFailpointTestControl.of({
+			clear: Ref.set(handler, noFailpoint),
+			setHandler: (next) => Ref.set(handler, next)
+		})));
+	}));
+};
+//#endregion
+//#region src/sqlite-conversation-store.ts
+const OffsetText = Schema.String.check(Schema.isMaxLength(4 * 1024));
+const SQLITE_OFFSET_PREFIX = "effect-agent-sqlite@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("SqliteConversationStore.makeOffset")(function* (conversationId, sequence) {
+	return yield* Schema.decodeUnknownEffect(CanonicalSequence)(sequence).pipe(Effect.flatMap((validatedSequence) => Schema.decodeUnknownEffect(ObservationOffset)(`${SQLITE_OFFSET_PREFIX}${encodeURIComponent(conversationId)}:${validatedSequence}`)), Effect.mapError((error) => schemaStoreError("encode observation offset", error)));
+});
+const parseOffset = Effect.fn("SqliteConversationStore.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 = `${SQLITE_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("SqliteConversationStore.encodeCanonicalRecord")(function* (record) {
+	return yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalRecord))(record).pipe(Effect.mapError((error) => schemaStoreError("encode canonical record", error)));
+});
+const encodeCanonicalBatch = Effect.fn("SqliteConversationStore.encodeCanonicalBatch")(function* (batch) {
+	return yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalBatch))(batch).pipe(Effect.mapError((error) => schemaStoreError("encode canonical batch", error)));
+});
+const encodeCheckpoint = Effect.fn("SqliteConversationStore.encodeCheckpoint")(function* (checkpoint) {
+	return yield* Schema.encodeEffect(Schema.fromJsonString(ConversationCheckpoint))(checkpoint).pipe(Effect.mapError((error) => schemaStoreError("encode checkpoint", error)));
+});
+const decodeEnvelope = Effect.fn("SqliteConversationStore.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("SqliteConversationStore.decodeCheckpoint")(function* (checkpointJson) {
+	return yield* Schema.decodeEffect(Schema.fromJsonString(ConversationCheckpoint))(checkpointJson).pipe(Effect.mapError((error) => schemaStoreError("decode checkpoint", error)));
+});
+const requireConversation = Effect.fn("SqliteConversationStore.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("SqliteConversationStore.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("SqliteConversationStore.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) => SqliteStorageCorruptionError.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) => SqliteStorageCorruptionError.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) => SqliteStorageCorruptionError.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* SqliteStorageCorruptionError.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) => SqliteStorageCorruptionError.make({
+				table: "effect_agent_canonical_batches",
+				rowKey: key,
+				message: error.message
+			})));
+			if (batchRow.batch_digest !== digest || batchRow.tail_digest !== digest) return yield* SqliteStorageCorruptionError.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* SqliteStorageCorruptionError.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) => SqliteStorageCorruptionError.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) => SqliteStorageCorruptionError.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* SqliteStorageCorruptionError.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* SqliteStorageCorruptionError.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* SqliteStorageCorruptionError.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* SqliteStorageCorruptionError.make({
+		table: "effect_agent_conversations",
+		rowKey: "startup_scan",
+		message: "Canonical rows exist without a materialized Conversation."
+	});
+});
+const makeServices$1 = Effect.fn("SqliteConversationStore.makeServices")(function* () {
+	const config = yield* SqliteStorageConfig;
+	const failpoint = yield* SqliteStorageFailpoint;
+	const sql = yield* SqlClient.SqlClient;
+	const crypto = yield* Crypto.Crypto;
+	const journal = yield* initializeSqliteJournal(sql, failpoint.hit, config.busyTimeout);
+	if (config.verifyOnOpen) yield* decodeStartupPayloads(journal, crypto);
+	const provideCrypto = (effect) => Effect.provideService(effect, Crypto.Crypto, crypto);
+	const hitFailpoint = Effect.fn("SqliteConversationStore.hitFailpoint")((location) => failpoint.hit(location).pipe(Effect.mapError((error) => storeError(`storage failpoint ${location}`, error))));
+	const materialize = Effect.fn("SqliteConversationStore.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 === "SqliteFenceRejected" ? mapFence(validated.conversationId, error) : storeError("materialize conversation", error)));
+		yield* hitFailpoint("materialize:after");
+	});
+	const append = Effect.fn("SqliteConversationStore.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 SqliteFenceRejected) return mapFence(validated.conversationId, error);
+			if (error instanceof SqliteAppendConflict) 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("SqliteConversationStore.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("SqliteConversationStore.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("SqliteConversationStore.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("SqliteConversationStore.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("SqliteConversationStore.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("SqliteConversationStore.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("SqliteConversationStore.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 SqliteCheckpointConflict ? CheckpointRejected.make({
+			conversationId: validated.checkpoint.conversationId,
+			reason: "digest-mismatch"
+		}) : storeError("save checkpoint", error)));
+		yield* hitFailpoint("save-checkpoint:after");
+	});
+	const loadCheckpoint = Effect.fn("SqliteConversationStore.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);
+});
+/**
+* SQLite Conversation Store implementation with configuration, failpoint, SQL, and Crypto
+* authority kept visible in its input channel.
+*/
+const conversationStoreLayer = Layer.effectContext(makeServices$1());
+/**
+* Validated SQLite 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(SqliteStorageConfig)(Schema.decodeUnknownEffect(SqliteStorageConfigValue)({
+	observationPollInterval: options.observationPollInterval ?? 25,
+	busyTimeout: options.busyTimeout ?? 5e3,
+	ownershipLeaseDuration: options.ownershipLeaseDuration ?? Duration.toMillis(DEFAULT_OWNERSHIP_LEASE_DURATION),
+	verifyOnOpen: options.verifyOnOpen ?? false
+}).pipe(Effect.mapError((error) => SqliteStorageError.make({
+	cause: error,
+	operation: "configure SQLite 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 ? SqliteStorageFailpoint.layer : Layer.succeed(SqliteStorageFailpoint)({ hit: options.failpoint });
+/**
+* A composition-root convenience Layer for canonical Conversations. Durable accepted work is
+* served by the separate SubmissionLedger port.
+*/
+const layer = (options) => {
+	const sqlLayer = SqliteClient.layer({ filename: options.filename });
+	return conversationStoreLayer.pipe(Layer.provide(Layer.mergeAll(storageConfigLayer(options), storageFailpointLayer(options), sqlLayer, NodeCrypto.layer)));
+};
+/** Create an adapter-owned resumable observation offset for a known canonical sequence. */
+const observationOffsetAt = makeOffset;
+//#endregion
+//#region src/sqlite-ledger.ts
+const BoundedStoredText = Schema.String.check(Schema.isMaxLength(16 * 1024 * 1024));
+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);
+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 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: write-lock timeouts stay retryable typed contention. */
+const sqlFailure = (operation) => (error) => {
+	const internal = error.reason._tag === "LockTimeoutError" ? SqliteWriteContention.make({
+		cause: error,
+		operation,
+		message: `Another producer holds the SQLite write lock; ${operation} is safe to retry.`
+	}) : SqliteLedgerError.make({
+		cause: error,
+		operation,
+		message: error.message
+	});
+	return internalFailure(operation)(internal);
+};
+const corruptionFailure = (operation, table, rowKey, message) => internalFailure(operation)(SqliteStorageCorruptionError.make({
+	table,
+	rowKey,
+	message
+}));
+const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function* () {
+	const config = yield* SqliteStorageConfig;
+	const failpoint = yield* SqliteStorageFailpoint;
+	const sql = yield* SqlClient.SqlClient;
+	const crypto = yield* Crypto.Crypto;
+	const journal = yield* initializeSqliteJournal(sql, failpoint.hit, config.busyTimeout);
+	const hitFailpoint = (location, operation) => failpoint.hit(location).pipe(Effect.mapError((error) => internalFailure(operation)(error)));
+	/**
+	* Run one ledger mutation under the journal's `BEGIN IMMEDIATE` write transaction so
+	* ownership-token and epoch checks are atomic with their writes (DUR-006). Transaction
+	* acquisition failures surface as LedgerError carrying the typed retryable
+	* SqliteWriteContention (or SqliteStorageError) as cause.
+	*/
+	const inWriteTransaction = (operation, effect) => journal.withWriteTransaction(operation)(effect).pipe(Effect.mapError((error) => error instanceof SqliteStorageError || error instanceof SqliteWriteContention ? internalFailure(operation)(error) : error));
+	const mintIdentifier = (prefix, operation) => crypto.randomUUIDv7.pipe(Effect.map((uuid) => `${prefix}-${uuid}`), 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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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]);
+	});
+	const decodeChildReservationRows = (operation, rowKey, rows) => decodeRows(Schema.Array(ChildReservationRow), "effect_agent_child_reservations", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
+	const readChildReservation = Effect.fn("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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-node" }));
+	const admit = Effect.fn("SqliteSubmissionLedger.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)));
+		const agentDigestsJson = yield* encodeDefinitionDigestsText(validated.agentDigests).pipe(Effect.mapError(internalFailure(operation)));
+		const mintedSubmissionId = yield* mintIdentifier("submission", operation);
+		const mintedReceiptId = yield* mintIdentifier("receipt", 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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.claim")(function* (request) {
+		const operation = "ledger claim";
+		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ClaimRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
+		const attemptId = yield* mintIdentifier("attempt", operation);
+		const ownershipToken = yield* mintIdentifier("owner", 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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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* 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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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 {
+				let allSettled = true;
+				for (const child of validated.reason.children) {
+					const childRow = yield* readSubmission(operation, child.childSubmissionId);
+					if (Option.isNone(childRow) || childRow.value.state !== "settled") {
+						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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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.isNone(child) || child.value.state !== "settled") return yield* LedgerError.make({
+				operation,
+				message: `Child submission ${validated.childSubmissionId} has no recorded settlement.`
+			});
+			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";
+			for (const entry of reason.children) {
+				const listed = yield* readSubmission(operation, entry.childSubmissionId);
+				if (Option.isNone(listed) || listed.value.state !== "settled") 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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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.`
+			});
+			const child = yield* readSubmission(operation, validated.childSubmissionId);
+			if (Option.isNone(child)) return yield* LedgerError.make({
+				operation,
+				message: `Unknown child submission ${validated.childSubmissionId}.`
+			});
+			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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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("SqliteSubmissionLedger.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 childAttachments = [];
+			for (const row of decodedChildReservations) {
+				if (row.child_submission_id === null) continue;
+				const child = yield* readSubmission(operation, row.child_submission_id);
+				if (Option.isNone(child)) continue;
+				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))));
+			}
+			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
+	}));
+});
+/**
+* SQLite SubmissionLedger implementation sharing the journal's database file, write
+* 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 database file 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({ filename: options.filename }), NodeCrypto.layer)));
+//#endregion
+export { CurrentSqliteStorageVersion, SqliteAppendConflict, SqliteCheckpointConflict, SqliteFenceRejected, SqliteLedgerError, SqliteStorageCompatibilityError, SqliteStorageConfig, SqliteStorageConfigValue, SqliteStorageCorruptionError, SqliteStorageError, SqliteStorageFailpoint, SqliteStorageFailpointError, SqliteStorageFailpointLocation, SqliteStorageFailpointTestControl, SqliteWriteContention, conversationStoreLayer, layer, ledgerLayer, observationOffsetAt, sqliteMigrations, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer };
+
+//# sourceMappingURL=index.mjs.map