@effect-agent/storage-sqlite 0.1.0-beta.45 → 0.1.0-beta.46

package/dist/index.mjs

@@ -1,4265 +1,10 @@
-import { t as SqliteStorageFailpoint } from "./sqlite-storage-failpoint-DIwWk5dw.mjs";
-import { AbortCommand, AbortIntent, AcceptedEvent, ActivityBusy, ActivityClaim, ActivityClaimRequest, ActivityMutationFailpoint, ActivityOwnershipLost, ActivityProcessorKey, ActivityProcessorStore, ActivityProgress, ActivityStoreError, ActivityWorkConflict, 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, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, DeliveryChange, Digest, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, ParentLinkage, PersistedJson, PreparedActivity, ProducerEpoch, QueueSequence, RecordEnvelope, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleId, ScheduleInstant, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, Settlement, SettlementConflict, SettlementFinalization, SettlementOutcome, SettlementReservation, SettlementReservationSnapshot, SourcePartition, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SubscriptionDelivery, SubscriptionDeliveryKey, SubscriptionError, SubscriptionFailpoint, SubscriptionKey, SubscriptionLimits, SubscriptionName, SubscriptionRecord, SubscriptionScanCursors, SubscriptionStore, SuspendRequest, SuspensionReason, SuspensionSnapshot, ThreadCheckpoint, ThreadExport, ThreadExportRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadRead, ThreadStore, ThreadStoreError, ThreadTail, ThreadTailRequest, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, applyScheduleChange, applySubscriptionDeliveryChange, defaultSchedulingLimits, digestCanonicalBatch, sameAcceptedEventIdentity, sameSourcePartition, scheduleDeadline, scheduleUsesCapacity, settlementFailureFromRecord, submissionAbortRecordId, subscriptionCanSelect, subscriptionDeliveryCanSelect, subscriptionDeliveryKeyString } from "@effect-agent/thread";
-import { Clock, Context, Crypto, DateTime, Duration, Effect, Exit, Layer, Option, Ref, Result, 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";
-import { memoryReaderLayer, memoryStoreLayer, memoryStoreLayerWithFailpoints } from "@effect-agent/thread/sql-memory";
-//#region src/errors.ts
-/** The SQLite file uses a private-development format this adapter cannot read. */
-var SqliteStorageCompatibilityError = class extends Schema.TaggedError()("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.TaggedError()("SqliteStorageCorruptionError", {
-	message: Schema.String,
-	rowKey: Schema.String,
-	table: Schema.String
-}) {};
-/** SQLite infrastructure failed while opening or operating the store. */
-var SqliteStorageError = class extends Schema.TaggedError()("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.TaggedError()("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.TaggedError()("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 Thread'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.TaggedError()("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.TaggedError()("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.TaggedError()("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-thread-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.TaggedError()("SqliteStorageFailpointError", { location: SqliteStorageFailpointLocation }) {
-	get message() {
-		return `Injected SQLite storage failure at ${this.location}.`;
-	}
-};
-//#endregion
-//#region src/migrations.ts
-const CurrentSqliteStorageVersion = 7;
-/** Initialize empty storage with the complete current schema. */
-const sqliteMigrations = SqliteMigrator.fromRecord({ "1_current_thread_storage": Effect.gen(function* () {
-	const sql = yield* SqlClient.SqlClient;
-	yield* sql`
-      CREATE TABLE effect_agent_threads (
-        thread_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 (
-        thread_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 (thread_id, batch_id),
-        FOREIGN KEY (thread_id)
-          REFERENCES effect_agent_threads(thread_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_canonical_records (
-        thread_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 (thread_id, sequence),
-        UNIQUE (thread_id, record_id),
-        FOREIGN KEY (thread_id, batch_id)
-          REFERENCES effect_agent_canonical_batches(thread_id, batch_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE INDEX effect_agent_canonical_records_batch
-        ON effect_agent_canonical_records (thread_id, batch_id, sequence)
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_checkpoints (
-        thread_id TEXT NOT NULL,
-        through_sequence INTEGER NOT NULL,
-        tail_digest TEXT NOT NULL,
-        checkpoint_json TEXT NOT NULL,
-        PRIMARY KEY (thread_id, through_sequence),
-        FOREIGN KEY (thread_id)
-          REFERENCES effect_agent_threads(thread_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_submissions (
-        submission_id TEXT PRIMARY KEY NOT NULL,
-        thread_id TEXT NOT NULL,
-        queue_sequence INTEGER NOT NULL,
-        principal TEXT NOT NULL,
-        idempotency_key TEXT NOT NULL,
-        agent_id TEXT NOT NULL,
-        agent_digests_json TEXT NOT NULL,
-        deployment_id TEXT NOT NULL,
-        input_json TEXT NOT NULL,
-        input_digest TEXT NOT NULL,
-        receipt_id TEXT NOT NULL,
-        state TEXT NOT NULL,
-        settled_outcome TEXT,
-        created_at TEXT NOT NULL,
-        ready_at TEXT,
-        input_applied_record_id TEXT,
-        input_applied_sequence INTEGER,
-        joined_host_submission_id TEXT,
-        suspended_reason_json TEXT,
-        suspended_at TEXT,
-        unknown_reason TEXT,
-        unknown_tool_call_ids_json TEXT,
-        parent_submission_id TEXT,
-        parent_tool_call_id TEXT,
-        UNIQUE (thread_id, principal, idempotency_key),
-        UNIQUE (thread_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,
-        thread_id TEXT NOT NULL,
-        owner_producer_id TEXT NOT NULL,
-        producer_epoch INTEGER NOT NULL,
-        claimed_at TEXT NOT NULL,
-        FOREIGN KEY (submission_id)
-          REFERENCES effect_agent_submissions(submission_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_settlement_reservations (
-        submission_id TEXT PRIMARY KEY NOT NULL,
-        settlement_id TEXT NOT NULL,
-        outcome TEXT NOT NULL,
-        record_id TEXT NOT NULL,
-        record_json TEXT NOT NULL,
-        record_digest TEXT NOT NULL,
-        reserved_at TEXT NOT NULL,
-        finalized_at TEXT,
-        FOREIGN KEY (submission_id)
-          REFERENCES effect_agent_submissions(submission_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_abort_intents (
-        submission_id TEXT PRIMARY KEY NOT NULL,
-        author TEXT NOT NULL,
-        reason TEXT NOT NULL,
-        requested_at TEXT NOT NULL,
-        canonical_record_id TEXT,
-        FOREIGN KEY (submission_id)
-          REFERENCES effect_agent_submissions(submission_id)
-          ON DELETE RESTRICT
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE 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`
-      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`
-      CREATE TABLE effect_agent_schedules (
-        tenant_id TEXT NOT NULL,
-        owner_id TEXT NOT NULL,
-        schedule_id TEXT NOT NULL,
-        deadline_at_millis INTEGER,
-        record_json TEXT NOT NULL,
-        PRIMARY KEY (tenant_id, owner_id, schedule_id)
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE INDEX effect_agent_schedules_deadline
-        ON effect_agent_schedules (deadline_at_millis, tenant_id, owner_id, schedule_id)
-        WHERE deadline_at_millis IS NOT NULL
-    `.withoutTransform;
-	yield* sql`
-      CREATE INDEX effect_agent_schedules_owner_deadline
-        ON effect_agent_schedules (tenant_id, owner_id, deadline_at_millis, schedule_id)
-        WHERE deadline_at_millis IS NOT NULL
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_subscription_sequences (
-        tenant_id TEXT NOT NULL,
-        source_address TEXT NOT NULL,
-        sequence INTEGER NOT NULL,
-        event_scan_cursor TEXT NOT NULL,
-        delivery_scan_cursor TEXT NOT NULL,
-        recovery_scan_cursor INTEGER NOT NULL,
-        PRIMARY KEY (tenant_id, source_address)
-      )
-    `.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_subscriptions (
-        tenant_id TEXT NOT NULL,
-        source_address TEXT NOT NULL,
-        owner_id TEXT NOT NULL,
-        subscription_id TEXT NOT NULL,
-        ordinal INTEGER NOT NULL,
-        source_name TEXT NOT NULL,
-        source_version TEXT NOT NULL,
-        matching_key TEXT NOT NULL,
-        state TEXT NOT NULL,
-        expires_at_millis INTEGER NOT NULL,
-        recovery_at_millis INTEGER,
-        record_json TEXT NOT NULL,
-        PRIMARY KEY (tenant_id, source_address, owner_id, subscription_id),
-        UNIQUE (tenant_id, source_address, ordinal)
-      )
-    `.withoutTransform;
-	yield* sql`CREATE INDEX effect_agent_subscriptions_owner ON effect_agent_subscriptions (tenant_id, source_address, owner_id, ordinal)`.withoutTransform;
-	yield* sql`CREATE INDEX effect_agent_subscriptions_candidates ON effect_agent_subscriptions (tenant_id, source_address, source_name, source_version, matching_key, ordinal)`.withoutTransform;
-	yield* sql`CREATE INDEX effect_agent_subscriptions_recovery ON effect_agent_subscriptions (tenant_id, source_address, recovery_at_millis, ordinal) WHERE recovery_at_millis IS NOT NULL`.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_subscription_events (
-        tenant_id TEXT NOT NULL,
-        source_address TEXT NOT NULL,
-        event_id TEXT NOT NULL,
-        source_name TEXT NOT NULL,
-        source_version TEXT NOT NULL,
-        matching_key TEXT NOT NULL,
-        payload_digest TEXT NOT NULL,
-        cutoff INTEGER NOT NULL,
-        cursor INTEGER NOT NULL,
-        routing_complete INTEGER NOT NULL,
-        next_attempt_at_millis INTEGER NOT NULL,
-        record_json TEXT NOT NULL,
-        PRIMARY KEY (tenant_id, source_address, event_id)
-      )
-    `.withoutTransform;
-	yield* sql`CREATE INDEX effect_agent_subscription_events_pending ON effect_agent_subscription_events (tenant_id, source_address, routing_complete, next_attempt_at_millis, event_id)`.withoutTransform;
-	yield* sql`
-      CREATE TABLE effect_agent_subscription_deliveries (
-        tenant_id TEXT NOT NULL,
-        source_address TEXT NOT NULL,
-        owner_id TEXT NOT NULL,
-        subscription_id TEXT NOT NULL,
-        event_id TEXT NOT NULL,
-        delivery_key TEXT NOT NULL,
-        state TEXT NOT NULL,
-        next_attempt_at_millis INTEGER NOT NULL,
-        record_json TEXT NOT NULL,
-        PRIMARY KEY (tenant_id, source_address, owner_id, subscription_id, event_id),
-        UNIQUE (tenant_id, source_address, delivery_key)
-      )
-    `.withoutTransform;
-	yield* sql`CREATE INDEX effect_agent_subscription_deliveries_pending ON effect_agent_subscription_deliveries (tenant_id, source_address, state, next_attempt_at_millis, delivery_key)`.withoutTransform;
-	yield* sql`CREATE INDEX effect_agent_subscription_deliveries_registration ON effect_agent_subscription_deliveries (tenant_id, source_address, owner_id, subscription_id, delivery_key)`.withoutTransform;
-	yield* sql`PRAGMA user_version = 7`.withoutTransform;
-}) });
-//#endregion
-//#region src/sqlite-activity-store.ts
-const STORAGE_VERSION = 1;
-const METADATA_COMPONENT = "activity";
-const STATE_TABLE = "effect_agent_activity_processor_state_v1";
-const StoredJson$1 = Schema.String.check(Schema.isMaxLength(16777216));
-const sameKey = Schema.toEquivalence(ActivityProcessorKey);
-const sameWork = Schema.toEquivalence(PreparedActivity);
-var ActivityMetadataRow = class extends Schema.Class("@effect-agent/storage-sqlite/ActivityMetadataRow")({ version: Schema.Int }) {};
-var ActivityTableRow = class extends Schema.Class("@effect-agent/storage-sqlite/ActivityTableRow")({ name: Schema.NonEmptyString }) {};
-var ActivityStateRow = class extends Schema.Class("@effect-agent/storage-sqlite/ActivityStateRow")({
-	processor_id: ActivityProcessorKey.fields.processorId,
-	processor_version: ActivityProcessorKey.fields.processorVersion,
-	thread_id: ActivityProcessorKey.fields.threadId,
-	format_version: Schema.Int,
-	through_sequence: ActivityProgress.fields.throughSequence,
-	epoch: ActivityProgress.fields.epoch,
-	owner: ActivityProgress.fields.owner,
-	lease_expires_at: ActivityProgress.fields.leaseExpiresAt,
-	progress_json: StoredJson$1
-}) {};
-var ActivityChangeCountRow = class extends Schema.Class("@effect-agent/storage-sqlite/ActivityChangeCountRow")({ changed: Schema.Int }) {};
-const StoredVersionHeader = Schema.Struct({ version: Schema.Int });
-const storeError$1 = (operation, reason = "unavailable") => ActivityStoreError.make({
-	operation,
-	reason
-});
-const query = (effect, operation) => effect.pipe(Effect.mapError(() => storeError$1(operation)));
-const decodeRows$3 = Effect.fn("SqliteActivityStore.decodeRows")(function* (schema, rows, operation) {
-	return yield* Schema.decodeUnknownEffect(Schema.Array(schema))(rows).pipe(Effect.mapError(() => storeError$1(operation, "corrupt")));
-});
-const decodeInput$1 = Effect.fn("SqliteActivityStore.decodeInput")(function* (schema, value, operation) {
-	return yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => storeError$1(operation, "invalid-input")));
-});
-const encodeProgress = Effect.fn("SqliteActivityStore.encodeProgress")(function* (progress, operation) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(ActivityProgress))(progress).pipe(Effect.mapError(() => storeError$1(operation, "corrupt")), Effect.flatMap((encoded) => Schema.decodeEffect(StoredJson$1)(encoded).pipe(Effect.mapError(() => storeError$1(operation, "invalid-input")))));
-});
-const decodeProgress = Effect.fn("SqliteActivityStore.decodeProgress")(function* (value, operation) {
-	if ((yield* Schema.decodeEffect(Schema.fromJsonString(StoredVersionHeader))(value).pipe(Effect.mapError(() => storeError$1(operation, "corrupt")))).version !== STORAGE_VERSION) return yield* storeError$1(operation, "incompatible");
-	const progress = yield* Schema.decodeEffect(Schema.fromJsonString(ActivityProgress))(value).pipe(Effect.mapError(() => storeError$1(operation, "corrupt")));
-	if ((yield* encodeProgress(progress, operation)) !== value) return yield* storeError$1(operation, "corrupt");
-	return progress;
-});
-const validateProgress = Effect.fn("SqliteActivityStore.validateProgress")(function* (progress, operation) {
-	if (progress.epoch < 1 || progress.owner === null && progress.leaseExpiresAt !== 0 || progress.pending !== null && (!sameKey(progress.pending.key, progress.key) || progress.pending.sequence !== progress.throughSequence + 1)) return yield* storeError$1(operation, "corrupt");
-	return progress;
-});
-const makeClaim = (progress) => progress.owner === null ? null : ActivityClaim.make({
-	key: progress.key,
-	owner: progress.owner,
-	epoch: progress.epoch,
-	throughSequence: progress.throughSequence,
-	leaseExpiresAt: progress.leaseExpiresAt,
-	pending: progress.pending
-});
-const ownershipLost = (claim) => ActivityOwnershipLost.make({
-	key: claim.key,
-	owner: claim.owner,
-	epoch: claim.epoch
-});
-const makeActivityStore = Effect.fn("SqliteActivityStore.make")(function* () {
-	const sql = yield* SqlClient.SqlClient;
-	const failpoint = yield* ActivityMutationFailpoint;
-	yield* failpoint.hit("activity:initialize:before");
-	yield* sql.withTransaction(Effect.gen(function* () {
-		yield* sql`
-          CREATE TABLE IF NOT EXISTS effect_agent_activity_metadata (
-            component TEXT PRIMARY KEY NOT NULL,
-            version INTEGER NOT NULL
-          )
-        `;
-		const metadataRows = yield* sql`
-          SELECT version FROM effect_agent_activity_metadata
-          WHERE component = ${METADATA_COMPONENT}
-        `;
-		const metadata = yield* decodeRows$3(ActivityMetadataRow, metadataRows, "decode activity schema version");
-		if (metadata.length > 1) return yield* storeError$1("decode activity schema version", "corrupt");
-		const currentVersion = metadata[0]?.version;
-		if (currentVersion !== void 0 && currentVersion !== STORAGE_VERSION) return yield* storeError$1("initialize activity schema", "incompatible");
-		if (currentVersion === void 0) {
-			const tableRows = yield* sql`
-            SELECT name FROM sqlite_master
-            WHERE type = 'table' AND name = ${STATE_TABLE}
-          `;
-			if ((yield* decodeRows$3(ActivityTableRow, tableRows, "inspect activity schema")).length > 0) return yield* storeError$1("initialize activity schema", "incompatible");
-			yield* sql`
-            CREATE TABLE effect_agent_activity_processor_state_v1 (
-              processor_id TEXT NOT NULL,
-              processor_version TEXT NOT NULL,
-              thread_id TEXT NOT NULL,
-              format_version INTEGER NOT NULL,
-              through_sequence INTEGER NOT NULL,
-              epoch INTEGER NOT NULL,
-              owner TEXT,
-              lease_expires_at REAL NOT NULL,
-              progress_json TEXT NOT NULL,
-              PRIMARY KEY (processor_id, processor_version, thread_id)
-            )
-          `;
-			yield* sql`
-            INSERT INTO effect_agent_activity_metadata (component, version)
-            VALUES (${METADATA_COMPONENT}, ${STORAGE_VERSION})
-          `;
-		}
-		yield* sql`
-          SELECT processor_id, processor_version, thread_id, format_version,
-            through_sequence, epoch, owner, lease_expires_at, progress_json
-          FROM effect_agent_activity_processor_state_v1
-          LIMIT 0
-        `;
-	})).pipe(Effect.catchTag("SqlError", () => Effect.fail(storeError$1("initialize activity schema"))));
-	yield* failpoint.hit("activity:initialize:after");
-	const readProgress = Effect.fn("SqliteActivityStore.readProgress")(function* (key, operation) {
-		const rawRows = yield* query(sql`
-        SELECT processor_id, processor_version, thread_id, format_version,
-          through_sequence, epoch, owner, lease_expires_at, progress_json
-        FROM effect_agent_activity_processor_state_v1
-        WHERE processor_id = ${key.processorId}
-          AND processor_version = ${key.processorVersion}
-          AND thread_id = ${key.threadId}
-      `, operation);
-		const rows = yield* decodeRows$3(ActivityStateRow, rawRows, operation);
-		if (rows.length === 0) return null;
-		if (rows.length !== 1) return yield* storeError$1(operation, "corrupt");
-		const row = rows[0];
-		if (row.format_version !== STORAGE_VERSION) return yield* storeError$1(operation, "incompatible");
-		const progress = yield* decodeProgress(row.progress_json, operation);
-		yield* validateProgress(progress, operation);
-		if (!sameKey(progress.key, key) || row.processor_id !== key.processorId || row.processor_version !== key.processorVersion || row.thread_id !== key.threadId || row.through_sequence !== progress.throughSequence || row.epoch !== progress.epoch || row.owner !== progress.owner || row.lease_expires_at !== progress.leaseExpiresAt) return yield* storeError$1(operation, "corrupt");
-		return progress;
-	});
-	const checkChanged = Effect.fn("SqliteActivityStore.checkChanged")(function* (operation) {
-		const rawRows = yield* query(sql`SELECT changes() AS changed`, operation);
-		const rows = yield* decodeRows$3(ActivityChangeCountRow, rawRows, operation);
-		if (rows.length !== 1 || rows[0].changed !== 1) return yield* storeError$1(operation, "corrupt");
-	});
-	const insertProgress = Effect.fn("SqliteActivityStore.insertProgress")(function* (progress, operation) {
-		const progressJson = yield* encodeProgress(progress, operation);
-		yield* sql`
-      INSERT INTO effect_agent_activity_processor_state_v1 (
-        processor_id, processor_version, thread_id, format_version, through_sequence,
-        epoch, owner, lease_expires_at, progress_json
-      ) VALUES (
-        ${progress.key.processorId}, ${progress.key.processorVersion}, ${progress.key.threadId},
-        ${STORAGE_VERSION}, ${progress.throughSequence}, ${progress.epoch}, ${progress.owner},
-        ${progress.leaseExpiresAt}, ${progressJson}
-      )
-    `;
-		yield* checkChanged(operation);
-	});
-	const updateProgress = Effect.fn("SqliteActivityStore.updateProgress")(function* (current, next, operation) {
-		const progressJson = yield* encodeProgress(next, operation);
-		yield* sql`
-      UPDATE effect_agent_activity_processor_state_v1
-      SET format_version = ${STORAGE_VERSION},
-          through_sequence = ${next.throughSequence},
-          epoch = ${next.epoch},
-          owner = ${next.owner},
-          lease_expires_at = ${next.leaseExpiresAt},
-          progress_json = ${progressJson}
-      WHERE processor_id = ${current.key.processorId}
-        AND processor_version = ${current.key.processorVersion}
-        AND thread_id = ${current.key.threadId}
-        AND through_sequence = ${current.throughSequence}
-        AND epoch = ${current.epoch}
-    `;
-		yield* checkChanged(operation);
-	});
-	const requireLive = Effect.fn("SqliteActivityStore.requireLive")(function* (progress, claim, requireSequence) {
-		const now = yield* Clock.currentTimeMillis;
-		if (progress === null || !sameKey(progress.key, claim.key) || progress.owner !== claim.owner || progress.epoch !== claim.epoch || progress.leaseExpiresAt <= now || requireSequence && progress.throughSequence !== claim.throughSequence) return yield* ownershipLost(claim);
-		return progress;
-	});
-	const inspect = Effect.fn("SqliteActivityStore.inspect")(function* (key) {
-		const decodedKey = yield* decodeInput$1(ActivityProcessorKey, key, "inspect activity progress");
-		return yield* readProgress(decodedKey, "inspect activity progress");
-	});
-	const claim = Effect.fn("SqliteActivityStore.claim")(function* (request) {
-		const operation = "claim activity progress";
-		const decoded = yield* decodeInput$1(ActivityClaimRequest, request, operation);
-		yield* failpoint.hit("activity:claim:before");
-		const claimed = yield* sql.withTransaction(Effect.gen(function* () {
-			const current = yield* readProgress(decoded.key, operation);
-			const now = yield* Clock.currentTimeMillis;
-			if (current !== null && current.owner !== null && current.leaseExpiresAt > now) return yield* ActivityBusy.make({
-				key: decoded.key,
-				leaseExpiresAt: current.leaseExpiresAt
-			});
-			const next = yield* Schema.decodeUnknownEffect(ActivityProgress)({
-				version: STORAGE_VERSION,
-				key: decoded.key,
-				throughSequence: current?.throughSequence ?? 0,
-				epoch: (current?.epoch ?? 0) + 1,
-				owner: decoded.owner,
-				leaseExpiresAt: now + decoded.leaseMillis,
-				pending: current?.pending ?? null,
-				advancedAt: current?.advancedAt ?? null
-			}).pipe(Effect.mapError(() => storeError$1(operation, "corrupt")));
-			if (current === null) yield* insertProgress(next, operation);
-			else yield* updateProgress(current, next, operation);
-			yield* failpoint.hit("activity:claim:after-state");
-			const result = makeClaim(next);
-			if (result === null) return yield* storeError$1(operation, "corrupt");
-			return result;
-		})).pipe(Effect.catchTag("SqlError", () => Effect.fail(storeError$1(operation))));
-		yield* failpoint.hit("activity:claim:after");
-		return claimed;
-	});
-	const prepare = Effect.fn("SqliteActivityStore.prepare")(function* (request) {
-		const operation = "prepare activity output";
-		const claim = yield* decodeInput$1(ActivityClaim, request.claim, operation);
-		const work = yield* decodeInput$1(PreparedActivity, request.work, operation);
-		yield* failpoint.hit("activity:prepare:before");
-		const result = yield* sql.withTransaction(Effect.gen(function* () {
-			const current = yield* requireLive(yield* readProgress(claim.key, operation), claim, true);
-			if (current.pending !== null) {
-				if (sameWork(current.pending, work)) return {
-					work: current.pending,
-					changed: false
-				};
-				return yield* ActivityWorkConflict.make({
-					key: claim.key,
-					workId: work.workId
-				});
-			}
-			if (!sameKey(work.key, claim.key) || work.sequence !== current.throughSequence + 1) return yield* ActivityWorkConflict.make({
-				key: claim.key,
-				workId: work.workId
-			});
-			const next = ActivityProgress.make({
-				...current,
-				pending: work
-			});
-			yield* updateProgress(current, next, operation);
-			yield* failpoint.hit("activity:prepare:after-state");
-			return {
-				work,
-				changed: true
-			};
-		})).pipe(Effect.catchTag("SqlError", () => Effect.fail(storeError$1(operation))));
-		if (result.changed) yield* failpoint.hit("activity:prepare:after");
-		return result.work;
-	});
-	const advance = Effect.fn("SqliteActivityStore.advance")(function* (request) {
-		const operation = "advance activity progress";
-		const claim = yield* decodeInput$1(ActivityClaim, request.claim, operation);
-		const workId = yield* decodeInput$1(Digest, request.workId, operation);
-		yield* failpoint.hit("activity:advance:before");
-		const nextClaim = yield* sql.withTransaction(Effect.gen(function* () {
-			const current = yield* requireLive(yield* readProgress(claim.key, operation), claim, true);
-			if (current.pending === null || current.pending.workId !== workId) return yield* ActivityWorkConflict.make({
-				key: claim.key,
-				workId
-			});
-			const next = ActivityProgress.make({
-				...current,
-				throughSequence: current.pending.sequence,
-				pending: null,
-				advancedAt: yield* Clock.currentTimeMillis
-			});
-			yield* updateProgress(current, next, operation);
-			yield* failpoint.hit("activity:advance:after-state");
-			const result = makeClaim(next);
-			if (result === null) return yield* storeError$1(operation, "corrupt");
-			return result;
-		})).pipe(Effect.catchTag("SqlError", () => Effect.fail(storeError$1(operation))));
-		yield* failpoint.hit("activity:advance:after");
-		return nextClaim;
-	});
-	const release = Effect.fn("SqliteActivityStore.release")(function* (claim) {
-		const operation = "release activity claim";
-		const decoded = yield* decodeInput$1(ActivityClaim, claim, operation);
-		yield* failpoint.hit("activity:release:before");
-		yield* sql.withTransaction(Effect.gen(function* () {
-			const current = yield* readProgress(decoded.key, operation);
-			if (current === null || current.owner !== decoded.owner || current.epoch !== decoded.epoch) return yield* ownershipLost(decoded);
-			const next = ActivityProgress.make({
-				...current,
-				owner: null,
-				leaseExpiresAt: 0
-			});
-			yield* updateProgress(current, next, operation);
-			yield* failpoint.hit("activity:release:after-state");
-		})).pipe(Effect.catchTag("SqlError", () => Effect.fail(storeError$1(operation))));
-		yield* failpoint.hit("activity:release:after");
-	});
-	return ActivityProcessorStore.of({
-		inspect,
-		claim,
-		prepare,
-		advance,
-		release
-	});
-});
-/** SQLite activity progress with mutation failpoints kept injectable for recovery tests. */
-const activityProcessorStoreLayerWithFailpoints = Layer.effect(ActivityProcessorStore, makeActivityStore());
-/** SQLite activity progress with the production no-op mutation failpoint. */
-const activityProcessorStoreLayer = activityProcessorStoreLayerWithFailpoints.pipe(Layer.provide(ActivityMutationFailpoint.layer));
-//#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/thread`.
-	*/
-	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-journal.ts
-const BoundedStoredText$1 = Schema.String.check(Schema.isMaxLength(16777216));
-const BoundedIdentifier$1 = Schema.NonEmptyString.check(Schema.isMaxLength(1024));
-const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-const MAX_RECORDS_PER_THREAD = 65536;
-const MAX_STORED_TEXT_BYTES = 16777216;
-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 ThreadRow = class extends Schema.Class("ThreadRow")({
-	thread_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,
-	thread_id: BoundedIdentifier$1,
-	first_sequence: CanonicalSequence,
-	last_sequence: CanonicalSequence,
-	tail_digest: BoundedStoredText$1
-}) {};
-var RecordRow = class extends Schema.Class("RecordRow")({
-	batch_id: BoundedIdentifier$1,
-	thread_id: BoundedIdentifier$1,
-	record_id: BoundedIdentifier$1,
-	record_json: BoundedStoredText$1,
-	sequence: CanonicalSequence
-}) {};
-var CheckpointRow = class extends Schema.Class("CheckpointRow")({
-	checkpoint_json: BoundedStoredText$1,
-	thread_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,
-	threadId: 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")({
-	threadId: 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,
-	threadId: BoundedIdentifier$1,
-	tailDigest: BoundedStoredText$1,
-	throughSequence: CanonicalSequence
-}) {};
-var RawThreadExport = class extends Schema.Class("@effect-agent/storage-sqlite/RawThreadExport")({
-	batches: Schema.Array(BatchRow),
-	checkpoints: Schema.Array(CheckpointRow),
-	thread: ThreadRow,
-	records: Schema.Array(RecordRow)
-}) {};
-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$2 = 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$2(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 initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function* () {
-	const sql = yield* SqlClient.SqlClient;
-	const { hit: failpoint } = yield* SqliteStorageFailpoint;
-	const { busyTimeout } = yield* SqliteStorageConfig;
-	yield* sql`PRAGMA foreign_keys = ON`.pipe(Effect.mapError(storageError("enable foreign keys")));
-	yield* sql.unsafe(`PRAGMA busy_timeout = ${busyTimeout}`).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: 7,
-		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 !== 7) return yield* SqliteStorageCompatibilityError.make({
-		actualVersion: version.user_version,
-		supportedVersion: 7,
-		message: `The SQLite file uses private-development storage version ${version.user_version}; this build supports exactly version 7. 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$2(Schema.Array(SqliteNameRow), "sqlite_master", "effect_agent_%", existingRows)).length > 0) return yield* SqliteStorageCompatibilityError.make({
-			actualVersion: 0,
-			supportedVersion: 7,
-			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.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_threads',
-        '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',
-        'effect_agent_schedules'
-      )
-    ORDER BY name
-  `.pipe(Effect.mapError(storageError("verify storage tables")));
-	if ((yield* decodeRows$2(Schema.Array(SqliteNameRow), "sqlite_master", "required_tables", requiredRows)).length !== 12) return yield* SqliteStorageCompatibilityError.make({
-		actualVersion: 7,
-		supportedVersion: 7,
-		message: "The SQLite file claims the current format but is missing required tables. Reset the corrupt private-development data."
-	});
-	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 } })));
-	/**
-	* Runs a read-only snapshot under a deferred transaction. Effect's SQLite client now
-	* starts every writable-client `withTransaction` with `BEGIN IMMEDIATE`, which is the
-	* right default for mutations but would make exports take the write lock and block a
-	* concurrent append. Reserving the connection and beginning explicitly preserves the
-	* adapter's snapshot-with-concurrent-writer contract. As with the write helper, a failed
-	* `BEGIN` is reported directly because there is no transaction to roll back.
-	*/
-	const withReadTransaction = (operation) => (effect) => Effect.uninterruptibleMask((restore) => Effect.scoped(Effect.gen(function* () {
-		const connection = yield* sql.reserve.pipe(Effect.mapError(storageError(operation)));
-		yield* connection.executeUnprepared("BEGIN", [], void 0).pipe(Effect.mapError(storageError(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(storageError(operation)));
-			return exit.value;
-		}
-		yield* Effect.orDie(connection.executeUnprepared("ROLLBACK", [], void 0));
-		return yield* exit;
-	})).pipe(Effect.withSpan("SqliteJournal.withReadTransaction", { attributes: { operation } })));
-	const materialize = Effect.fn("SqliteJournal.materialize")(function* (threadId, createdAt, emptyTailDigest, producerEpoch) {
-		if (threadId.length > MAX_IDENTIFIER_LENGTH || storedTextBytes(emptyTailDigest) > MAX_STORED_TEXT_BYTES) return yield* SqliteStorageError.make({
-			operation: "materialize thread",
-			message: "Thread identity or initial digest exceeds the SQLite storage bounds."
-		});
-		yield* withWriteTransaction("materialize transaction")(Effect.gen(function* () {
-			const existingRows = yield* sql`
-          SELECT
-            thread_id,
-            created_at,
-            tail_sequence,
-            tail_digest,
-            producer_epoch
-          FROM effect_agent_threads
-          WHERE thread_id = ${threadId}
-        `.pipe(Effect.mapError(storageError("read materialized thread")));
-			const existing = yield* decodeRows$2(Schema.Array(ThreadRow), "effect_agent_threads", threadId, existingRows);
-			if (existing.length > 1) return yield* SqliteStorageCorruptionError.make({
-				table: "effect_agent_threads",
-				rowKey: threadId,
-				message: "A thread primary key returned more than one row."
-			});
-			if (existing.length === 0) {
-				yield* sql`
-            INSERT INTO effect_agent_threads (
-              thread_id,
-              created_at,
-              tail_sequence,
-              tail_digest,
-              producer_epoch
-            ) VALUES (
-              ${threadId},
-              ${createdAt},
-              0,
-              ${emptyTailDigest},
-              ${producerEpoch}
-            )
-          `.pipe(Effect.mapError(storageError("materialize thread")));
-				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_threads
-            SET producer_epoch = ${producerEpoch}
-            WHERE thread_id = ${threadId}
-          `.pipe(Effect.mapError(storageError("advance materialization epoch")));
-		}));
-	});
-	const getThread = Effect.fn("SqliteJournal.getThread")(function* (threadId) {
-		const rows = yield* sql`
-      SELECT
-        thread_id,
-        created_at,
-        tail_sequence,
-        tail_digest,
-        producer_epoch
-      FROM effect_agent_threads
-      WHERE thread_id = ${threadId}
-    `.pipe(Effect.mapError(storageError("read thread")));
-		return yield* decodeRows$2(Schema.Array(ThreadRow), "effect_agent_threads", threadId, rows);
-	});
-	const append = Effect.fn("SqliteJournal.append")(function* (request) {
-		if (request.threadId.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 threadRows = yield* sql`
-          SELECT
-            thread_id,
-            created_at,
-            tail_sequence,
-            tail_digest,
-            producer_epoch
-          FROM effect_agent_threads
-          WHERE thread_id = ${request.threadId}
-        `.pipe(Effect.mapError(storageError("read append tail")));
-			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", request.threadId, threadRows);
-			if (request.producerEpoch !== thread.producer_epoch) return yield* SqliteFenceRejected.make({
-				producerEpoch: request.producerEpoch,
-				actualEpoch: thread.producer_epoch,
-				message: `Producer epoch ${request.producerEpoch} is not the current epoch ${thread.producer_epoch}.`
-			});
-			const batchRows = yield* sql`
-          SELECT
-            thread_id,
-            batch_id,
-            first_sequence,
-            last_sequence,
-            batch_digest,
-            tail_digest,
-            batch_json
-          FROM effect_agent_canonical_batches
-          WHERE thread_id = ${request.threadId}
-            AND batch_id = ${request.batchId}
-        `.pipe(Effect.mapError(storageError("read idempotent batch")));
-			const batches = yield* decodeRows$2(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${request.threadId}/${request.batchId}`, batchRows);
-			if (batches.length > 1) return yield* SqliteStorageCorruptionError.make({
-				table: "effect_agent_canonical_batches",
-				rowKey: `${request.threadId}/${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 !== thread.tail_sequence || request.expectedTailDigest !== thread.tail_digest) return yield* SqliteAppendConflict.make({
-				message: `Expected tail ${request.expectedTailSequence}/${request.expectedTailDigest} but found ${thread.tail_sequence}/${thread.tail_digest}.`,
-				reason: "tail",
-				actualTailSequence: thread.tail_sequence,
-				actualTailDigest: thread.tail_digest
-			});
-			if (thread.tail_sequence + request.records.length > MAX_RECORDS_PER_THREAD) return yield* SqliteStorageError.make({
-				operation: "append canonical batch",
-				message: `Thread record limit ${MAX_RECORDS_PER_THREAD} would be exceeded.`
-			});
-			const existingRecordRows = yield* sql`
-          SELECT
-            thread_id,
-            sequence,
-            record_id,
-            batch_id,
-            record_json
-          FROM effect_agent_canonical_records
-          WHERE thread_id = ${request.threadId}
-            AND record_id IN ${sql.in(recordIds)}
-          ORDER BY sequence
-        `.pipe(Effect.mapError(storageError("check canonical record identities")));
-			const existingRecords = yield* decodeRows$2(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.threadId}/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)(thread.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 (
-            thread_id,
-            batch_id,
-            first_sequence,
-            last_sequence,
-            batch_digest,
-            tail_digest,
-            batch_json
-          ) VALUES (
-            ${request.threadId},
-            ${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 (
-                    thread_id,
-                    sequence,
-                    record_id,
-                    batch_id,
-                    record_json
-                  ) VALUES (
-                    ${request.threadId},
-                    ${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_threads
-          SET
-            tail_sequence = ${lastSequence},
-            tail_digest = ${request.tailDigest},
-            producer_epoch = ${request.producerEpoch}
-          WHERE thread_id = ${request.threadId}
-        `.pipe(Effect.mapError(storageError("advance thread 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
-        thread_id,
-        sequence,
-        record_id,
-        batch_id,
-        record_json
-      FROM effect_agent_canonical_records
-      WHERE thread_id = ${request.threadId}
-        AND sequence > ${request.fromSequenceExclusive}
-      ORDER BY sequence
-      LIMIT ${request.limit}
-    `.pipe(Effect.mapError(storageError("read canonical records")));
-		return yield* decodeRows$2(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.threadId}>${request.fromSequenceExclusive}`, rows);
-	});
-	const exportThread = Effect.fn("SqliteJournal.exportThread")(function* (threadId) {
-		return yield* withReadTransaction("export transaction")(Effect.gen(function* () {
-			const threadRows = yield* sql`
-            SELECT
-              thread_id,
-              created_at,
-              tail_sequence,
-              tail_digest,
-              producer_epoch
-            FROM effect_agent_threads
-            WHERE thread_id = ${threadId}
-          `.pipe(Effect.mapError(storageError("export thread")));
-			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", threadId, threadRows);
-			yield* failpoint("export:after-thread-read");
-			const batchRows = yield* sql`
-            SELECT
-              thread_id,
-              batch_id,
-              first_sequence,
-              last_sequence,
-              batch_digest,
-              tail_digest,
-              batch_json
-            FROM effect_agent_canonical_batches
-            WHERE thread_id = ${threadId}
-            ORDER BY first_sequence
-          `.pipe(Effect.mapError(storageError("export canonical batches")));
-			const recordRows = yield* sql`
-            SELECT
-              thread_id,
-              sequence,
-              record_id,
-              batch_id,
-              record_json
-            FROM effect_agent_canonical_records
-            WHERE thread_id = ${threadId}
-            ORDER BY sequence
-          `.pipe(Effect.mapError(storageError("export canonical records")));
-			const checkpointRows = yield* sql`
-            SELECT
-              thread_id,
-              through_sequence,
-              tail_digest,
-              checkpoint_json
-            FROM effect_agent_checkpoints
-            WHERE thread_id = ${threadId}
-            ORDER BY through_sequence
-          `.pipe(Effect.mapError(storageError("export checkpoints")));
-			return RawThreadExport.make({
-				thread,
-				batches: yield* decodeRows$2(Schema.Array(BatchRow), "effect_agent_canonical_batches", threadId, batchRows),
-				records: yield* decodeRows$2(Schema.Array(RecordRow), "effect_agent_canonical_records", threadId, recordRows),
-				checkpoints: yield* decodeRows$2(Schema.Array(CheckpointRow), "effect_agent_checkpoints", threadId, checkpointRows)
-			});
-		}));
-	});
-	const saveCheckpoint = Effect.fn("SqliteJournal.saveCheckpoint")(function* (checkpoint) {
-		if (checkpoint.threadId.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 threadRows = yield* sql`
-          SELECT
-            thread_id,
-            created_at,
-            tail_sequence,
-            tail_digest,
-            producer_epoch
-          FROM effect_agent_threads
-          WHERE thread_id = ${checkpoint.threadId}
-        `.pipe(Effect.mapError(storageError("read checkpoint tail")));
-			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", checkpoint.threadId, threadRows);
-			if (checkpoint.throughSequence > thread.tail_sequence) return yield* SqliteCheckpointConflict.make({ message: `Checkpoint sequence ${checkpoint.throughSequence} is after canonical tail ${thread.tail_sequence}.` });
-			const checkpointRows = yield* sql`
-          SELECT
-            thread_id,
-            through_sequence,
-            tail_digest,
-            checkpoint_json
-          FROM effect_agent_checkpoints
-          WHERE thread_id = ${checkpoint.threadId}
-            AND through_sequence = ${checkpoint.throughSequence}
-        `.pipe(Effect.mapError(storageError("read idempotent checkpoint")));
-			const existing = yield* decodeRows$2(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${checkpoint.threadId}/${checkpoint.throughSequence}`, checkpointRows);
-			if (existing.length > 1) return yield* SqliteStorageCorruptionError.make({
-				table: "effect_agent_checkpoints",
-				rowKey: `${checkpoint.threadId}/${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 (
-            thread_id,
-            through_sequence,
-            tail_digest,
-            checkpoint_json
-          ) VALUES (
-            ${checkpoint.threadId},
-            ${checkpoint.throughSequence},
-            ${checkpoint.tailDigest},
-            ${checkpoint.checkpointJson}
-          )
-        `.pipe(Effect.mapError(storageError("insert checkpoint")));
-		}));
-	});
-	const loadCheckpoint = Effect.fn("SqliteJournal.loadCheckpoint")(function* (threadId, atOrBeforeSequence) {
-		const rows = yield* sql`
-      SELECT
-        thread_id,
-        through_sequence,
-        tail_digest,
-        checkpoint_json
-      FROM effect_agent_checkpoints
-      WHERE thread_id = ${threadId}
-        AND through_sequence <= ${atOrBeforeSequence}
-      ORDER BY through_sequence DESC
-      LIMIT 1
-    `.pipe(Effect.mapError(storageError("load checkpoint")));
-		return yield* decodeRows$2(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${threadId}<=${atOrBeforeSequence}`, rows);
-	});
-	return {
-		append,
-		exportThread,
-		getThread,
-		getTailDigestAt: Effect.fn("SqliteJournal.getTailDigestAt")(function* (threadId, sequence) {
-			if (sequence === 0) {
-				const threads = yield* getThread(threadId);
-				return threads.length === 0 ? [] : [threads[0].tail_sequence === 0 ? threads[0].tail_digest : void 0].filter((value) => value !== void 0);
-			}
-			const rows = yield* sql`
-      SELECT
-        thread_id,
-        batch_id,
-        first_sequence,
-        last_sequence,
-        batch_digest,
-        tail_digest,
-        batch_json
-      FROM effect_agent_canonical_batches
-      WHERE thread_id = ${threadId}
-        AND last_sequence = ${sequence}
-    `.pipe(Effect.mapError(storageError("read canonical digest at sequence")));
-			return (yield* decodeRows$2(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${threadId}/${sequence}`, rows)).map((batch) => batch.tail_digest);
-		}),
-		loadCheckpoint,
-		materialize,
-		read,
-		saveCheckpoint,
-		scanStoredPayloads: Effect.fn("SqliteJournal.scanStoredPayloads")(function* () {
-			return yield* withReadTransaction("startup scan transaction")(Effect.gen(function* () {
-				const threads = yield* sql`
-            SELECT
-              thread_id,
-              created_at,
-              tail_sequence,
-              tail_digest,
-              producer_epoch
-            FROM effect_agent_threads
-            ORDER BY thread_id
-          `.pipe(Effect.mapError(storageError("scan threads")));
-				const batches = yield* sql`
-            SELECT
-              thread_id,
-              batch_id,
-              first_sequence,
-              last_sequence,
-              batch_digest,
-              tail_digest,
-              batch_json
-            FROM effect_agent_canonical_batches
-            ORDER BY thread_id, first_sequence
-          `.pipe(Effect.mapError(storageError("scan canonical batches")));
-				const records = yield* sql`
-            SELECT
-              thread_id,
-              sequence,
-              record_id,
-              batch_id,
-              record_json
-            FROM effect_agent_canonical_records
-            ORDER BY thread_id, sequence
-          `.pipe(Effect.mapError(storageError("scan canonical records")));
-				const checkpoints = yield* sql`
-            SELECT
-              thread_id,
-              through_sequence,
-              tail_digest,
-              checkpoint_json
-            FROM effect_agent_checkpoints
-            ORDER BY thread_id, through_sequence
-          `.pipe(Effect.mapError(storageError("scan checkpoints")));
-				return {
-					threads: yield* decodeRows$2(Schema.Array(ThreadRow), "effect_agent_threads", "startup_scan", threads),
-					batches: yield* decodeRows$2(Schema.Array(BatchRow), "effect_agent_canonical_batches", "startup_scan", batches),
-					records: yield* decodeRows$2(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
-					checkpoints: yield* decodeRows$2(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
-				};
-			}));
-		}),
-		withWriteTransaction
-	};
-});
-//#endregion
-//#region src/sqlite-thread-store.ts
-const OffsetText = Schema.String.check(Schema.isMaxLength(4096));
-const SQLITE_OFFSET_PREFIX = "effect-agent-sqlite@1:";
-const ZERO_CANONICAL_SEQUENCE = Schema.decodeSync(CanonicalSequence)(0);
-const isDigest = Schema.is(Digest);
-const isSqliteFenceRejected = Schema.is(SqliteFenceRejected);
-const isSqliteAppendConflict = Schema.is(SqliteAppendConflict);
-const isSqliteCheckpointConflict = Schema.is(SqliteCheckpointConflict);
-const storeError = (operation, error) => ThreadStoreError.make({
-	cause: error,
-	operation,
-	message: error.message
-});
-const schemaStoreError = (operation, error) => ThreadStoreError.make({
-	cause: error,
-	operation,
-	message: error.message
-});
-const makeOffset = Effect.fn("SqliteThreadStore.makeOffset")(function* (threadId, sequence) {
-	return yield* Schema.decodeUnknownEffect(CanonicalSequence)(sequence).pipe(Effect.flatMap((validatedSequence) => Schema.decodeUnknownEffect(ObservationOffset)(`${SQLITE_OFFSET_PREFIX}${encodeURIComponent(threadId)}:${validatedSequence}`)), Effect.mapError((error) => schemaStoreError("encode observation offset", error)));
-});
-const parseOffset = Effect.fn("SqliteThreadStore.parseOffset")(function* (threadId, 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 threadPrefix = `${SQLITE_OFFSET_PREFIX}${encodeURIComponent(threadId)}:`;
-	if (!text.startsWith(threadPrefix)) return yield* ThreadStoreError.make({
-		operation: "decode observation offset",
-		message: "The observation offset belongs to a different adapter, storage version, or Thread."
-	});
-	const sequenceText = text.slice(threadPrefix.length);
-	if (!/^(0|[1-9][0-9]*)$/.test(sequenceText)) return yield* ThreadStoreError.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 = (threadId, error) => FenceRejected.make({
-	threadId,
-	actualEpoch: error.actualEpoch,
-	attemptedEpoch: error.producerEpoch
-});
-const encodeCanonicalRecord = Effect.fn("SqliteThreadStore.encodeCanonicalRecord")(function* (record) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalRecord))(record).pipe(Effect.mapError((error) => schemaStoreError("encode canonical record", error)));
-});
-const encodeCanonicalBatch = Effect.fn("SqliteThreadStore.encodeCanonicalBatch")(function* (batch) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalBatch))(batch).pipe(Effect.mapError((error) => schemaStoreError("encode canonical batch", error)));
-});
-const encodeCheckpoint = Effect.fn("SqliteThreadStore.encodeCheckpoint")(function* (checkpoint) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(ThreadCheckpoint))(checkpoint).pipe(Effect.mapError((error) => schemaStoreError("encode checkpoint", error)));
-});
-const decodeEnvelope = Effect.fn("SqliteThreadStore.decodeEnvelope")(function* (row) {
-	const record = yield* Schema.decodeEffect(Schema.fromJsonString(CanonicalRecord))(row.record_json).pipe(Effect.mapError((error) => ThreadStoreError.make({
-		operation: "decode canonical record",
-		message: error.message
-	})));
-	const threadId = yield* Schema.decodeUnknownEffect(CanonicalRecordEnvelope.fields.threadId)(row.thread_id).pipe(Effect.mapError((error) => schemaStoreError("decode thread identity", error)));
-	const offset = yield* makeOffset(threadId, 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({
-		threadId,
-		batchId,
-		sequence: row.sequence,
-		offset,
-		record
-	});
-});
-const decodeCheckpoint = Effect.fn("SqliteThreadStore.decodeCheckpoint")(function* (checkpointJson) {
-	return yield* Schema.decodeEffect(Schema.fromJsonString(ThreadCheckpoint))(checkpointJson).pipe(Effect.mapError((error) => schemaStoreError("decode checkpoint", error)));
-});
-const requireThread = Effect.fn("SqliteThreadStore.requireThread")(function* (journal, threadId) {
-	const rows = yield* journal.getThread(threadId).pipe(Effect.mapError((error) => storeError("read thread", error)));
-	if (rows.length === 0) return yield* ThreadNotMaterialized.make({ threadId });
-	return rows[0];
-});
-const tailDigestAt = Effect.fn("SqliteThreadStore.tailDigestAt")(function* (journal, threadId, sequence) {
-	if (sequence === 0) return EMPTY_TAIL_DIGEST;
-	const digests = yield* journal.getTailDigestAt(threadId, sequence).pipe(Effect.mapError((error) => storeError("read checkpoint digest", error)));
-	if (digests.length !== 1) return yield* CheckpointRejected.make({
-		threadId,
-		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("SqliteThreadStore.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.thread_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.thread_id}/${record.sequence}`,
-		message: error.message
-	}))));
-	const checkpoints = yield* Effect.forEach(stored.checkpoints, (checkpoint) => Schema.decodeEffect(Schema.fromJsonString(ThreadCheckpoint))(checkpoint.checkpoint_json).pipe(Effect.map((decoded) => ({
-		decoded,
-		row: checkpoint
-	})), Effect.mapError((error) => SqliteStorageCorruptionError.make({
-		table: "effect_agent_checkpoints",
-		rowKey: `${checkpoint.thread_id}/${checkpoint.through_sequence}`,
-		message: error.message
-	}))));
-	const batchesByThread = groupByKey(batches, ({ row }) => row.thread_id);
-	const recordsByThread = groupByKey(records, ({ row }) => row.thread_id);
-	const checkpointsByThread = groupByKey(checkpoints, ({ row }) => row.thread_id);
-	const materializedIds = new Set(stored.threads.map((thread) => thread.thread_id));
-	for (const thread of stored.threads) {
-		const threadBatches = batchesByThread.get(thread.thread_id) ?? [];
-		const threadRecords = recordsByThread.get(thread.thread_id) ?? [];
-		const threadCheckpoints = checkpointsByThread.get(thread.thread_id) ?? [];
-		const recordsByBatch = groupByKey(threadRecords, ({ 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 threadBatches) {
-			const key = `${batchRow.thread_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 (threadRecords.length !== thread.tail_sequence || thread.tail_sequence !== expectedSequence - 1 || thread.tail_digest !== previousDigest) return yield* SqliteStorageCorruptionError.make({
-			table: "effect_agent_threads",
-			rowKey: thread.thread_id,
-			message: "Thread tail does not match its canonical batch chain."
-		});
-		for (const checkpoint of threadCheckpoints) if (checkpoint.decoded.threadId !== thread.thread_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: `${thread.thread_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.thread_id)) || records.some(({ row }) => !materializedIds.has(row.thread_id)) || checkpoints.some(({ row }) => !materializedIds.has(row.thread_id))) return yield* SqliteStorageCorruptionError.make({
-		table: "effect_agent_threads",
-		rowKey: "startup_scan",
-		message: "Canonical rows exist without a materialized Thread."
-	});
-});
-const makeServices$1 = Effect.fn("SqliteThreadStore.makeServices")(function* () {
-	const config = yield* SqliteStorageConfig;
-	const failpoint = yield* SqliteStorageFailpoint;
-	const crypto = yield* Crypto.Crypto;
-	const journal = yield* initializeSqliteJournal();
-	if (config.verifyOnOpen) yield* decodeStartupPayloads(journal, crypto);
-	const provideCrypto = (effect) => Effect.provideService(effect, Crypto.Crypto, crypto);
-	const hitFailpoint = Effect.fn("SqliteThreadStore.hitFailpoint")((location) => failpoint.hit(location).pipe(Effect.mapError((error) => storeError(`storage failpoint ${location}`, error))));
-	const materialize = Effect.fn("SqliteThreadStore.materialize")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadMaterialization))(request).pipe(Effect.mapError((error) => schemaStoreError("validate materialization", error)));
-		const now = yield* Clock.currentTimeMillis;
-		yield* hitFailpoint("materialize:before");
-		yield* journal.materialize(validated.threadId, new Date(now).toISOString(), EMPTY_TAIL_DIGEST, validated.producerEpoch).pipe(Effect.mapError((error) => error._tag === "SqliteFenceRejected" ? mapFence(validated.threadId, error) : storeError("materialize thread", error)));
-		yield* hitFailpoint("materialize:after");
-	});
-	const append = Effect.fn("SqliteThreadStore.append")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(FencedAppendRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate canonical append", error)));
-		yield* requireThread(journal, validated.threadId);
-		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)({
-			threadId: validated.threadId,
-			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 (isSqliteFenceRejected(error)) return mapFence(validated.threadId, error);
-			if (isSqliteAppendConflict(error)) return error.actualTailSequence !== void 0 && isDigest(error.actualTailDigest) ? AppendConflict.make({
-				threadId: validated.threadId,
-				batchId: validated.batch.batchId,
-				reason: error.reason,
-				actualTailSequence: error.actualTailSequence,
-				actualTailDigest: error.actualTailDigest
-			}) : AppendConflict.make({
-				threadId: validated.threadId,
-				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("SqliteThreadStore.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("SqliteThreadStore.read")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadRead))(request).pipe(Effect.mapError((error) => schemaStoreError("validate thread read", error)));
-		yield* requireThread(journal, validated.threadId);
-		const records = yield* loadRecords(RawReadRequest.make({
-			threadId: validated.threadId,
-			fromSequenceExclusive: validated.afterSequence ?? ZERO_CANONICAL_SEQUENCE,
-			limit: validated.limit
-		}));
-		return Stream.fromIterable(records);
-	});
-	const read = (request) => Stream.unwrap(readEffect(request));
-	const observeEffect = Effect.fn("SqliteThreadStore.observe")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadObservation))(request).pipe(Effect.mapError((error) => schemaStoreError("validate thread observation", error)));
-		yield* requireThread(journal, validated.threadId);
-		const initialSequence = yield* parseOffset(validated.threadId, validated.afterOffset);
-		const cursor = yield* Ref.make(initialSequence);
-		const poll = Effect.fn("SqliteThreadStore.observePoll")(function* () {
-			const fromSequenceExclusive = yield* Ref.get(cursor);
-			const records = yield* loadRecords(RawReadRequest.make({
-				threadId: validated.threadId,
-				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 exportThread = Effect.fn("SqliteThreadStore.export")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadExportRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate thread export", error)));
-		yield* requireThread(journal, validated.threadId);
-		const exported = yield* journal.exportThread(validated.threadId).pipe(Effect.mapError((error) => storeError("export thread", error)));
-		const records = yield* Effect.forEach(exported.records, decodeEnvelope);
-		if (records.length > 65536) return yield* ThreadStoreError.make({
-			operation: "decode thread export",
-			message: "The thread exceeds the current export record limit."
-		});
-		const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(exported.thread.tail_digest).pipe(Effect.mapError((error) => schemaStoreError("decode export tail digest", error)));
-		return ThreadExport.make({
-			format: "effect-agent/thread@1",
-			threadId: validated.threadId,
-			tailSequence: exported.thread.tail_sequence,
-			tailDigest,
-			records
-		});
-	});
-	const inspectTail = Effect.fn("SqliteThreadStore.inspectTail")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadTailRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate tail inspection", error)));
-		const thread = yield* requireThread(journal, validated.threadId);
-		const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(thread.tail_digest).pipe(Effect.mapError((error) => schemaStoreError("decode tail digest", error)));
-		return ThreadTail.make({
-			threadId: validated.threadId,
-			tailSequence: thread.tail_sequence,
-			tailDigest,
-			producerEpoch: thread.producer_epoch
-		});
-	});
-	const saveCheckpoint = Effect.fn("SqliteThreadStore.saveCheckpoint")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SaveCheckpointRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint", error)));
-		const thread = yield* requireThread(journal, validated.checkpoint.threadId);
-		if (validated.checkpoint.throughSequence > thread.tail_sequence) return yield* CheckpointRejected.make({
-			threadId: validated.checkpoint.threadId,
-			reason: "ahead-of-tail"
-		});
-		if ((yield* tailDigestAt(journal, validated.checkpoint.threadId, validated.checkpoint.throughSequence)) !== validated.checkpoint.tailDigest) return yield* CheckpointRejected.make({
-			threadId: validated.checkpoint.threadId,
-			reason: "digest-mismatch"
-		});
-		const checkpointJson = yield* encodeCheckpoint(validated.checkpoint);
-		const raw = RawCheckpoint.make({
-			threadId: validated.checkpoint.threadId,
-			throughSequence: validated.checkpoint.throughSequence,
-			tailDigest: validated.checkpoint.tailDigest,
-			checkpointJson
-		});
-		yield* hitFailpoint("save-checkpoint:before");
-		yield* journal.saveCheckpoint(raw).pipe(Effect.mapError((error) => isSqliteCheckpointConflict(error) ? CheckpointRejected.make({
-			threadId: validated.checkpoint.threadId,
-			reason: "digest-mismatch"
-		}) : storeError("save checkpoint", error)));
-		yield* hitFailpoint("save-checkpoint:after");
-	});
-	const loadCheckpoint = Effect.fn("SqliteThreadStore.loadCheckpoint")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(LoadCheckpointRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint lookup", error)));
-		const thread = yield* requireThread(journal, validated.threadId);
-		const rows = yield* journal.loadCheckpoint(validated.threadId, validated.atOrBeforeSequence ?? thread.tail_sequence).pipe(Effect.mapError((error) => storeError("load checkpoint", error)));
-		if (rows.length === 0) return Option.none();
-		if (rows.length !== 1) return yield* ThreadStoreError.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.threadId, checkpoint.throughSequence)) !== checkpoint.tailDigest) return yield* CheckpointRejected.make({
-			threadId: checkpoint.threadId,
-			reason: "digest-mismatch"
-		});
-		return Option.some(checkpoint);
-	});
-	const threadStore = ThreadStore.of({
-		append,
-		export: exportThread,
-		inspectTail,
-		materialize,
-		observe,
-		read,
-		checkpoints: {
-			save: saveCheckpoint,
-			load: loadCheckpoint
-		}
-	});
-	return Context.make(ThreadStore, threadStore);
-});
-/**
-* SQLite Thread Store implementation with configuration, failpoint, SQL, and Crypto
-* authority kept visible in its input channel.
-*/
-const threadStoreLayer = Layer.effectContext(makeServices$1());
-/**
-* Validated SQLite storage configuration Layer with the documented defaults applied. Shared
-* by the ThreadStore 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 Threads. Durable accepted work is
-* served by the separate SubmissionLedger port.
-*/
-const layer = (options) => Layer.unwrap(Effect.map(SqliteStorageConfig, (config) => threadStoreLayer.pipe(Layer.provide(Layer.mergeAll(Layer.succeed(SqliteStorageConfig)(config), storageFailpointLayer(options), SqliteClient.layer({ filename: options.filename }), NodeCrypto.layer))))).pipe(Layer.provide(storageConfigLayer(options)));
-/** 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(16777216));
-const BoundedIdentifier = Schema.NonEmptyString.check(Schema.isMaxLength(1024));
-const BoundedTimestamp = Schema.NonEmptyString.check(Schema.isMaxLength(128));
-const SCAN_PAGE_SIZE = 256;
-const EPOCH_ZERO = Schema.decodeSync(ProducerEpoch)(0);
-const RESUME_IMMEDIATELY = "resume-immediately";
-const SUSPENDED = "suspended";
-const NOT_WAITING = "not-waiting";
-const STILL_WAITING = "still-waiting";
-const WOKEN = "woken";
-var SubmissionRow = class extends Schema.Class("SubmissionRow")({
-	submission_id: BoundedIdentifier,
-	thread_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,
-  thread_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 thread 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);
-const equivalentPersistedJson = Schema.toEquivalence(PersistedJson);
-const equivalentUnknownResolution = Schema.toEquivalence(UnknownResolution);
-const isSqliteTransactionFailure = Schema.is(Schema.Union([SqliteStorageError, SqliteWriteContention]));
-/** 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();
-	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) => isSqliteTransactionFailure(error) ? 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$2(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$2(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 threadEpoch = Effect.fn("SqliteSubmissionLedger.threadEpoch")(function* (operation, threadId) {
-		const threads = yield* journal.getThread(threadId).pipe(Effect.mapError(internalFailure(operation)));
-		return threads.length === 0 ? EPOCH_ZERO : threads[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
-	* Thread'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* threadEpoch(operation, submission.thread_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,
-			threadId: row.thread_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$2(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$2(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$2(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$2(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$2(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, threadId, submissionId) {
-		const recordId = submissionAbortRecordId(submissionId);
-		const rows = yield* sql`
-        SELECT record_id
-        FROM effect_agent_canonical_records
-        WHERE thread_id = ${threadId}
-          AND record_id = ${recordId}
-      `.pipe(Effect.mapError(sqlFailure(operation)));
-		return (yield* decodeRows$2(Schema.Array(CanonicalRecordIdRow), "effect_agent_canonical_records", `${threadId}/${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.thread_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.threadId}/${validated.principal}/${validated.idempotencyKey}`;
-			const existingRows = yield* sql`
-            SELECT ${sql.literal(SUBMISSION_COLUMNS)}
-            FROM effect_agent_submissions
-            WHERE thread_id = ${validated.threadId}
-              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({
-					threadId: validated.threadId,
-					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 thread_id = ${validated.threadId}
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			const decodedMax = yield* decodeRows$2(Schema.Array(MaxQueueSequenceRow), "effect_agent_submissions", validated.threadId, 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,
-              thread_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.threadId},
-              ${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 thread_id = ${validated.threadId}
-        AND principal = ${validated.principal}
-        AND idempotency_key = ${validated.idempotencyKey}
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeSubmissionRows(operation, `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`, rows);
-		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", `${validated.threadId}/${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 thread_id = ${validated.threadId}
-        AND principal = ${validated.principal}
-        AND idempotency_key = ${validated.idempotencyKey}
-    `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeSubmissionRows(operation, `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`, rows);
-		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", `${validated.threadId}/${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 thread_id = ${validated.threadId}
-              AND state <> 'settled'
-            ORDER BY queue_sequence ASC
-            LIMIT 1
-          `.pipe(Effect.mapError(sqlFailure(operation)));
-			const heads = yield* decodeSubmissionRows(operation, validated.threadId, 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" && Option.isNone(yield* readAbortIntent(operation, head.submission_id))) 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 threads = yield* journal.getThread(head.thread_id).pipe(Effect.mapError(internalFailure(operation)));
-			let producerEpoch;
-			if (threads.length === 0) {
-				producerEpoch = 1;
-				yield* sql`
-              INSERT INTO effect_agent_threads (
-                thread_id,
-                created_at,
-                tail_sequence,
-                tail_digest,
-                producer_epoch
-              ) VALUES (
-                ${head.thread_id},
-                ${now.iso},
-                0,
-                ${EMPTY_TAIL_DIGEST},
-                ${producerEpoch}
-              )
-            `.pipe(Effect.mapError(sqlFailure(operation)));
-			} else {
-				producerEpoch = threads[0].producer_epoch + 1;
-				yield* sql`
-              UPDATE effect_agent_threads
-              SET producer_epoch = ${producerEpoch}
-              WHERE thread_id = ${head.thread_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,
-              thread_id,
-              owner_producer_id,
-              producer_epoch,
-              claimed_at
-            ) VALUES (
-              ${attemptId},
-              ${head.submission_id},
-              ${head.thread_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 reservationRecord = yield* decodeRecordEnvelopeText(reservation.value.record_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, error.message)));
-			const settlementFailure = settlementFailureFromRecord(reservationRecord);
-			if (reservation.value.outcome === "failed" !== (settlementFailure !== void 0)) return yield* corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, "The reserved outcome and canonical failure diagnostic disagree.");
-			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,
-					...settlementFailure === void 0 ? {} : { failure: settlementFailure },
-					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,
-				...settlementFailure === void 0 ? {} : { failure: settlementFailure },
-				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.thread_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.thread_id !== validated.threadId) return yield* LedgerError.make({
-				operation,
-				message: `Host submission ${validated.hostSubmissionId} does not belong to thread ${validated.threadId}.`
-			});
-			yield* requireOwnership(operation, host, validated.ownershipToken);
-			const laterRows = yield* sql`
-          SELECT ${sql.literal(SUBMISSION_COLUMNS)}
-          FROM effect_agent_submissions
-          WHERE thread_id = ${validated.threadId}
-            AND queue_sequence > ${host.queue_sequence}
-          ORDER BY queue_sequence ASC
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			const later = yield* decodeSubmissionRows(operation, validated.threadId, 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);
-			const existingIntent = existing === void 0 ? void 0 : yield* unknownResolutionIntentFromRow(operation, existing);
-			if (existingIntent !== void 0 && !equivalentUnknownResolution(existingIntent.resolution, validated.resolution)) return yield* UnknownResolutionConflict.make({
-				submissionId: validated.submissionId,
-				toolCallId: validated.toolCallId
-			});
-			let resolved;
-			if (existingIntent !== void 0) resolved = existingIntent;
-			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);
-			const childReservation = yield* readReservation(operation, validated.childSubmissionId);
-			if (!(Option.isSome(child) && (child.value.state === "settled" || child.value.state === "terminalizing" && Option.isSome(childReservation)))) 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);
-				const reservation = yield* readReservation(operation, entry.childSubmissionId);
-				if (!(Option.isSome(listed) && (listed.value.state === "settled" || listed.value.state === "terminalizing" && Option.isSome(reservation)))) 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)) {
-				const existingSnapshot = yield* childReservationSnapshotFromRow(operation, existing.value);
-				if (!(existing.value.parent_submission_id === validated.parentSubmissionId && existing.value.parent_tool_call_id === validated.parentToolCallId && existing.value.allocation_digest === validated.allocationDigest && equivalentPersistedJson(existingSnapshot.allocation, validated.allocation))) 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: existingSnapshot,
-					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") {
-				const existingSnapshot = yield* childReservationSnapshotFromRow(operation, existing.value);
-				if (existingSnapshot.accounting !== void 0 && equivalentPersistedJson(existingSnapshot.accounting, validated.accounting)) return existingSnapshot;
-				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 thread_id ASC, queue_sequence ASC
-          LIMIT ${SCAN_PAGE_SIZE}
-        ` : sql`
-          SELECT ${sql.literal(SUBMISSION_COLUMNS)}
-          FROM effect_agent_submissions
-          WHERE state <> 'settled'
-            AND (
-              thread_id > ${cursor.threadId}
-              OR (
-                thread_id = ${cursor.threadId}
-                AND queue_sequence > ${cursor.queueSequence}
-              )
-            )
-          ORDER BY thread_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({
-			threadId: last.thread_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 ThreadStore so claims fence the same producer epochs.
-*/
-const ledgerLayer = (options) => Layer.unwrap(Effect.map(SqliteStorageConfig, (config) => submissionLedgerLayer.pipe(Layer.provide(Layer.mergeAll(Layer.succeed(SqliteStorageConfig)(config), storageFailpointLayer(options), SqliteClient.layer({ filename: options.filename }), NodeCrypto.layer))))).pipe(Layer.provide(storageConfigLayer(options)));
-//#endregion
-//#region src/sqlite-schedule-store.ts
-const StoredScheduleJson = Schema.String.check(Schema.isMaxLength(16777216));
-const StoredDeadline = Schema.NullOr(ScheduleInstant);
-var ScheduleRow = class extends Schema.Class("@effect-agent/storage-sqlite/ScheduleRow")({
-	tenant_id: ScheduleOwner.fields.tenantId,
-	owner_id: ScheduleOwner.fields.ownerId,
-	schedule_id: ScheduleId,
-	deadline_at_millis: StoredDeadline,
-	record_json: StoredScheduleJson
-}) {};
-const ScheduleDueRow = Schema.Struct({
-	tenant_id: ScheduleOwner.fields.tenantId,
-	owner_id: ScheduleOwner.fields.ownerId,
-	schedule_id: ScheduleId,
-	deadline_at_millis: ScheduleInstant
-});
-var ScheduleCountRow = class extends Schema.Class("@effect-agent/storage-sqlite/ScheduleCountRow")({ schedule_count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) }) {};
-var ScheduleDeadlineRow = class extends Schema.Class("@effect-agent/storage-sqlite/ScheduleDeadlineRow")({ deadline_at_millis: StoredDeadline }) {};
-const unavailable$1 = (operation) => ScheduleStorageError.make({
-	operation,
-	reason: "unavailable"
-});
-const corrupt$1 = (operation) => ScheduleStorageError.make({
-	operation,
-	reason: "corrupt"
-});
-const decodeRows$1 = Effect.fn("SqliteScheduleStore.decodeRows")(function* (schema, rows, operation) {
-	return yield* Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError(() => corrupt$1(operation)));
-});
-const decodeRecord = Effect.fn("SqliteScheduleStore.decodeRecord")(function* (row) {
-	const record = yield* Schema.decodeEffect(Schema.fromJsonString(ScheduleRecord))(row.record_json).pipe(Effect.mapError(() => corrupt$1("decode schedule")));
-	if (record.owner.tenantId !== row.tenant_id || record.owner.ownerId !== row.owner_id || record.scheduleId !== row.schedule_id || scheduleDeadline(record) !== row.deadline_at_millis) return yield* corrupt$1("decode schedule identity");
-	return record;
-});
-const encodeRecord = Effect.fn("SqliteScheduleStore.encodeRecord")(function* (record) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(ScheduleRecord))(record).pipe(Effect.mapError(() => corrupt$1("encode schedule")));
-});
-const decodeInput = Effect.fn("SqliteScheduleStore.decodeInput")(function* (operation, schema, value) {
-	return yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => corrupt$1(operation)));
-});
-const makeScheduleStore = Effect.gen(function* () {
-	const sql = yield* SqlClient.SqlClient;
-	const scheduleFailpoint = yield* ScheduleFailpoint;
-	yield* initializeSqliteJournal();
-	const readRows = Effect.fn("SqliteScheduleStore.readRows")(function* (key, operation) {
-		const rows = yield* sql`
-      SELECT tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
-      FROM effect_agent_schedules
-      WHERE tenant_id = ${key.owner.tenantId}
-        AND owner_id = ${key.owner.ownerId}
-        AND schedule_id = ${key.scheduleId}
-    `.pipe(Effect.mapError(() => unavailable$1(operation)));
-		return yield* decodeRows$1(Schema.Array(ScheduleRow), rows, operation);
-	});
-	const readOne = Effect.fn("SqliteScheduleStore.readOne")(function* (key, operation) {
-		const rows = yield* readRows(key, operation);
-		if (rows.length === 0) return null;
-		if (rows.length !== 1) return yield* corrupt$1(operation);
-		return yield* decodeRecord(rows[0]);
-	});
-	const insert = Effect.fn("SqliteScheduleStore.insert")(function* (record, ownerLimit) {
-		const operation = "insert schedule";
-		const canonical = yield* decodeInput(operation, ScheduleRecord, record);
-		const recordJson = yield* encodeRecord(canonical);
-		const result = yield* sql.withTransaction(Effect.gen(function* () {
-			const existing = yield* readOne(canonical, operation);
-			if (existing !== null) {
-				if (existing.creationFingerprint === canonical.creationFingerprint) return {
-					record: existing,
-					inserted: false
-				};
-				return yield* ScheduleConflict.make({
-					reason: "creation",
-					key: {
-						owner: canonical.owner,
-						scheduleId: canonical.scheduleId
-					}
-				});
-			}
-			const rawCounts = yield* sql`
-            SELECT COUNT(*) AS schedule_count
-            FROM effect_agent_schedules
-            WHERE tenant_id = ${canonical.owner.tenantId}
-              AND owner_id = ${canonical.owner.ownerId}
-              AND (json_extract(record_json, '$.pending') IS NOT NULL OR
-                (json_extract(record_json, '$.state') != 'cancelled' AND json_extract(record_json, '$.nextAtMillis') IS NOT NULL))
-          `.pipe(Effect.mapError(() => unavailable$1(operation)));
-			const counts = yield* decodeRows$1(Schema.Array(ScheduleCountRow), rawCounts, operation);
-			if (counts.length !== 1) return yield* corrupt$1(operation);
-			if (counts[0].schedule_count >= ownerLimit) return yield* ScheduleCapacityError.make({ limit: ownerLimit });
-			yield* scheduleFailpoint.hit("schedule:insert:before");
-			yield* sql`
-            INSERT INTO effect_agent_schedules (
-              tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
-            ) VALUES (
-              ${canonical.owner.tenantId},
-              ${canonical.owner.ownerId},
-              ${canonical.scheduleId},
-              ${scheduleDeadline(canonical)},
-              ${recordJson}
-            )
-          `.pipe(Effect.mapError(() => unavailable$1(operation)));
-			return {
-				record: canonical,
-				inserted: true
-			};
-		})).pipe(Effect.catchTag("SqlError", () => Effect.fail(unavailable$1(operation))));
-		if (result.inserted) yield* scheduleFailpoint.hit("schedule:insert:after");
-		return result.record;
-	});
-	const get = Effect.fn("SqliteScheduleStore.get")(function* (key) {
-		const decodedKey = yield* decodeInput("get schedule", ScheduleKey, key);
-		return yield* readOne(decodedKey, "get schedule");
-	});
-	const list = Effect.fn("SqliteScheduleStore.list")(function* (request) {
-		const operation = "list schedules";
-		const decodedRequest = yield* decodeInput(operation, SchedulePageRequest, request);
-		const rows = decodedRequest.after === void 0 ? yield* sql`
-            SELECT tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
-            FROM effect_agent_schedules
-            WHERE tenant_id = ${decodedRequest.owner.tenantId}
-              AND owner_id = ${decodedRequest.owner.ownerId}
-            ORDER BY schedule_id
-            LIMIT ${decodedRequest.limit + 1}
-          `.pipe(Effect.mapError(() => unavailable$1(operation))) : yield* sql`
-            SELECT tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
-            FROM effect_agent_schedules
-            WHERE tenant_id = ${decodedRequest.owner.tenantId}
-              AND owner_id = ${decodedRequest.owner.ownerId}
-              AND schedule_id > ${decodedRequest.after}
-            ORDER BY schedule_id
-            LIMIT ${decodedRequest.limit + 1}
-          `.pipe(Effect.mapError(() => unavailable$1(operation)));
-		const decoded = yield* decodeRows$1(Schema.Array(ScheduleRow), rows, operation);
-		const records = yield* Effect.forEach(decoded, decodeRecord);
-		const hasNext = records.length > decodedRequest.limit;
-		const items = hasNext ? records.slice(0, decodedRequest.limit) : records;
-		return {
-			items,
-			next: hasNext ? items.at(-1)?.scheduleId ?? null : null
-		};
-	});
-	const change = Effect.fn("SqliteScheduleStore.change")(function* (key, change, ownerLimit = defaultSchedulingLimits.maxSchedulesPerOwner) {
-		const operation = "change schedule";
-		const decodedKey = yield* decodeInput(operation, ScheduleKey, key);
-		const decodedChange = yield* decodeInput(operation, ScheduleChange, change);
-		const result = yield* sql.withTransaction(Effect.gen(function* () {
-			const current = yield* readOne(decodedKey, operation);
-			if (current === null) return yield* ScheduleNotFound.make({ key: decodedKey });
-			const transition = applyScheduleChange(current, decodedChange);
-			if (Result.isFailure(transition)) return yield* transition.failure;
-			const next = transition.success;
-			if (!scheduleUsesCapacity(current) && scheduleUsesCapacity(next)) {
-				const rawCounts = yield* sql`
-              SELECT COUNT(*) AS schedule_count FROM effect_agent_schedules
-              WHERE tenant_id = ${key.owner.tenantId} AND owner_id = ${key.owner.ownerId}
-                AND (json_extract(record_json, '$.pending') IS NOT NULL OR
-                  (json_extract(record_json, '$.state') != 'cancelled' AND json_extract(record_json, '$.nextAtMillis') IS NOT NULL))
-            `.pipe(Effect.mapError(() => unavailable$1(operation)));
-				const counts = yield* decodeRows$1(Schema.Array(ScheduleCountRow), rawCounts, operation);
-				if (counts.length !== 1) return yield* corrupt$1(operation);
-				if (counts[0].schedule_count >= ownerLimit) return yield* ScheduleCapacityError.make({ limit: ownerLimit });
-			}
-			if (next === current) return {
-				record: current,
-				changed: false
-			};
-			const recordJson = yield* encodeRecord(next);
-			yield* scheduleFailpoint.hit(`schedule:${decodedChange._tag.toLowerCase()}:before`);
-			yield* sql`
-            UPDATE effect_agent_schedules
-            SET deadline_at_millis = ${scheduleDeadline(next)}, record_json = ${recordJson}
-            WHERE tenant_id = ${decodedKey.owner.tenantId}
-              AND owner_id = ${decodedKey.owner.ownerId}
-              AND schedule_id = ${decodedKey.scheduleId}
-          `.pipe(Effect.mapError(() => unavailable$1(operation)));
-			return {
-				record: next,
-				changed: true
-			};
-		})).pipe(Effect.catchTag("SqlError", () => Effect.fail(unavailable$1(operation))));
-		if (result.changed) yield* scheduleFailpoint.hit(`schedule:${decodedChange._tag.toLowerCase()}:after`);
-		return result.record;
-	});
-	const due = Effect.fn("SqliteScheduleStore.due")(function* (nowMillis, limit, owner, after) {
-		const operation = "query due schedules";
-		const decodedOwner = owner === void 0 ? void 0 : yield* decodeInput(operation, ScheduleOwner, owner);
-		const cursor = after === void 0 ? void 0 : yield* Schema.decodeUnknownEffect(ScheduleDueCursor)(after).pipe(Effect.mapError(() => corrupt$1(operation)));
-		const continuation = cursor === void 0 ? sql`1 = 1` : sql`
-      (deadline_at_millis, tenant_id, owner_id, schedule_id) >
-      (${cursor.deadlineAtMillis}, ${cursor.owner.tenantId}, ${cursor.owner.ownerId}, ${cursor.scheduleId})`;
-		const rows = decodedOwner === void 0 ? yield* sql`
-            SELECT tenant_id, owner_id, schedule_id, deadline_at_millis
-            FROM effect_agent_schedules
-            WHERE deadline_at_millis <= ${nowMillis} AND ${continuation}
-            ORDER BY deadline_at_millis, tenant_id, owner_id, schedule_id
-            LIMIT ${limit}
-          `.pipe(Effect.mapError(() => unavailable$1(operation))) : yield* sql`
-            SELECT tenant_id, owner_id, schedule_id, deadline_at_millis
-            FROM effect_agent_schedules
-            WHERE tenant_id = ${decodedOwner.tenantId}
-              AND owner_id = ${decodedOwner.ownerId}
-              AND deadline_at_millis <= ${nowMillis} AND ${continuation}
-            ORDER BY deadline_at_millis, schedule_id
-            LIMIT ${limit}
-          `.pipe(Effect.mapError(() => unavailable$1(operation)));
-		return (yield* decodeRows$1(Schema.Array(ScheduleDueRow), rows, operation)).map((row) => ({
-			owner: {
-				tenantId: row.tenant_id,
-				ownerId: row.owner_id
-			},
-			scheduleId: row.schedule_id,
-			deadlineAtMillis: row.deadline_at_millis
-		}));
-	});
-	const nextDeadline = Effect.fn("SqliteScheduleStore.nextDeadline")(function* (owner) {
-		const operation = "query next schedule deadline";
-		const decodedOwner = owner === void 0 ? void 0 : yield* decodeInput(operation, ScheduleOwner, owner);
-		const rows = decodedOwner === void 0 ? yield* sql`
-          SELECT MIN(deadline_at_millis) AS deadline_at_millis
-          FROM effect_agent_schedules
-          WHERE deadline_at_millis IS NOT NULL
-        `.pipe(Effect.mapError(() => unavailable$1(operation))) : yield* sql`
-          SELECT MIN(deadline_at_millis) AS deadline_at_millis
-          FROM effect_agent_schedules
-          WHERE tenant_id = ${decodedOwner.tenantId}
-            AND owner_id = ${decodedOwner.ownerId}
-            AND deadline_at_millis IS NOT NULL
-        `.pipe(Effect.mapError(() => unavailable$1(operation)));
-		const decoded = yield* decodeRows$1(Schema.Array(ScheduleDeadlineRow), rows, operation);
-		if (decoded.length !== 1) return yield* corrupt$1(operation);
-		return decoded[0].deadline_at_millis;
-	});
-	return ScheduleStore.of({
-		insert,
-		get,
-		list,
-		change,
-		due,
-		nextDeadline
-	});
-});
-/** SQLite implementation of the atomic ScheduleStore port. */
-const scheduleStoreLayer = Layer.effect(ScheduleStore)(makeScheduleStore);
-//#endregion
-//#region src/sqlite-subscription-store.ts
-const StoredJson = Schema.String.check(Schema.isMaxLength(16777216));
-const CountRow = Schema.Struct({ count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) });
-const SequenceRow = Schema.Struct({ sequence: Schema.Natural });
-const ScanRow = Schema.Struct({
-	event_scan_cursor: Schema.String,
-	delivery_scan_cursor: Schema.String,
-	recovery_scan_cursor: Schema.Natural
-});
-const JsonRow = Schema.Struct({ record_json: StoredJson });
-const RegistrationRow = Schema.Struct({
-	owner_id: Schema.String,
-	subscription_id: Schema.String,
-	ordinal: Schema.Natural,
-	source_name: Schema.String,
-	source_version: Schema.String,
-	matching_key: Schema.String,
-	state: SubscriptionRecord.fields.state,
-	expires_at_millis: Schema.Number,
-	recovery_at_millis: Schema.NullOr(Schema.Number),
-	record_json: StoredJson
-});
-const EventRow = Schema.Struct({
-	event_id: Schema.String,
-	source_name: Schema.String,
-	source_version: Schema.String,
-	matching_key: Schema.String,
-	payload_digest: Digest,
-	cutoff: Schema.Natural,
-	cursor: Schema.Natural,
-	routing_complete: Schema.Number,
-	next_attempt_at_millis: Schema.Number,
-	record_json: StoredJson
-});
-const DeliveryRow = Schema.Struct({
-	owner_id: Schema.String,
-	subscription_id: Schema.String,
-	event_id: Schema.String,
-	delivery_key: Schema.String,
-	state: SubscriptionDelivery.fields.state,
-	next_attempt_at_millis: Schema.Number,
-	record_json: StoredJson
-});
-const error = (reason, code) => SubscriptionError.make({
-	reason,
-	code
-});
-const unavailable = (operation) => error("storage", operation);
-const corrupt = (operation) => error("corrupt", operation);
-const bytes = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
-const validate = (schema, value, code) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => error("validation", code)));
-const encode = (schema, value, code) => Schema.encodeEffect(Schema.fromJsonString(schema))(value).pipe(Effect.mapError(() => corrupt(code)));
-const decode = (schema, value, code) => Schema.decodeEffect(Schema.fromJsonString(schema))(value).pipe(Effect.mapError(() => corrupt(code)));
-const decodeRows = (schema, rows, code) => Schema.decodeUnknownEffect(Schema.Array(schema))(rows).pipe(Effect.mapError(() => corrupt(code)));
-const sameDeliveryIdentity = (left, right) => subscriptionDeliveryKeyString(left.key) === subscriptionDeliveryKeyString(right.key) && left.deliveryId === right.deliveryId && left.source.name === right.source.name && left.source.version === right.source.version && left.threadId === right.threadId && left.admissionKey === right.admissionKey && left.subscriptionFingerprint === right.subscriptionFingerprint && left.eventDigest === right.eventDigest;
-const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function* (owned) {
-	const partition = yield* validate(SourcePartition, owned, "partition");
-	const sql = yield* SqlClient.SqlClient;
-	const failpoint = yield* SubscriptionFailpoint;
-	yield* initializeSqliteJournal();
-	yield* sql`
-    INSERT INTO effect_agent_subscription_sequences (
-      tenant_id, source_address, sequence, event_scan_cursor, delivery_scan_cursor, recovery_scan_cursor
-    ) VALUES (${partition.tenantId}, ${partition.address}, 0, '', '', 0) ON CONFLICT DO NOTHING
-  `.pipe(Effect.mapError(() => unavailable("initialize subscription partition")));
-	const transact = (effect) => sql.withTransaction(effect).pipe(Effect.catchTag("SqlError", () => Effect.fail(unavailable("transaction"))));
-	const query = (effect, code) => effect.pipe(Effect.mapError(() => unavailable(code)));
-	const requirePartition = (candidate, code) => sameSourcePartition(candidate, partition) ? Effect.void : Effect.fail(error("validation", code));
-	const requireKey = Effect.fn("SqliteSubscriptionStore.requireKey")(function* (input, code) {
-		const key = yield* validate(SubscriptionKey, input, code);
-		yield* requirePartition(key.partition, code);
-		return key;
-	});
-	const readRegistration = Effect.fn("SqliteSubscriptionStore.readRegistration")(function* (key, code) {
-		const rows = yield* query(sql`
-      SELECT owner_id, subscription_id, ordinal, source_name, source_version, matching_key, state,
-        expires_at_millis, recovery_at_millis, record_json FROM effect_agent_subscriptions
-      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
-        AND owner_id=${key.ownerId} AND subscription_id=${key.subscriptionId}
-    `, code);
-		const decodedRows = yield* decodeRows(RegistrationRow, rows, code);
-		if (decodedRows.length > 1) return yield* corrupt(code);
-		const row = decodedRows[0];
-		if (row === void 0) return null;
-		const record = yield* decode(SubscriptionRecord, row.record_json, code);
-		if (!sameSourcePartition(record.key.partition, partition) || record.key.ownerId !== row.owner_id || record.key.subscriptionId !== row.subscription_id || record.ordinal !== row.ordinal || record.configuration.source.name !== row.source_name || record.configuration.source.version !== row.source_version || record.configuration.matchingKey !== row.matching_key || record.state !== row.state || record.configuration.expiresAtMillis !== row.expires_at_millis || (record.recovery?.nextAttemptAtMillis ?? null) !== row.recovery_at_millis) return yield* corrupt(`${code}-projection`);
-		return record;
-	});
-	const readEvent = Effect.fn("SqliteSubscriptionStore.readEvent")(function* (eventId, code) {
-		const rows = yield* query(sql`
-      SELECT event_id, source_name, source_version, matching_key, payload_digest, cutoff, cursor,
-        routing_complete, next_attempt_at_millis, record_json FROM effect_agent_subscription_events
-      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND event_id=${eventId}
-    `, code);
-		const decodedRows = yield* decodeRows(EventRow, rows, code);
-		if (decodedRows.length > 1) return yield* corrupt(code);
-		const row = decodedRows[0];
-		if (row === void 0) return null;
-		const event = yield* decode(AcceptedEvent, row.record_json, code);
-		if (!sameSourcePartition(event.partition, partition) || event.eventId !== row.event_id || event.source.name !== row.source_name || event.source.version !== row.source_version || event.matchingKey !== row.matching_key || event.payloadDigest !== row.payload_digest || event.cutoff !== row.cutoff || event.cursor !== row.cursor || (event.routingComplete ? 1 : 0) !== row.routing_complete || event.nextAttemptAtMillis !== row.next_attempt_at_millis) return yield* corrupt(`${code}-projection`);
-		return event;
-	});
-	const readDelivery = Effect.fn("SqliteSubscriptionStore.readDelivery")(function* (key, code) {
-		const rows = yield* query(sql`
-      SELECT owner_id, subscription_id, event_id, delivery_key, state, next_attempt_at_millis, record_json
-      FROM effect_agent_subscription_deliveries
-      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
-        AND owner_id=${key.subscription.ownerId} AND subscription_id=${key.subscription.subscriptionId}
-        AND event_id=${key.eventId}
-    `, code);
-		const decodedRows = yield* decodeRows(DeliveryRow, rows, code);
-		if (decodedRows.length > 1) return yield* corrupt(code);
-		const row = decodedRows[0];
-		if (row === void 0) return null;
-		const delivery = yield* decode(SubscriptionDelivery, row.record_json, code);
-		if (!sameSourcePartition(delivery.key.subscription.partition, partition) || delivery.key.subscription.ownerId !== row.owner_id || delivery.key.subscription.subscriptionId !== row.subscription_id || delivery.key.eventId !== row.event_id || subscriptionDeliveryKeyString(delivery.key) !== row.delivery_key || delivery.state !== row.state || delivery.retry.nextAttemptAtMillis !== row.next_attempt_at_millis) return yield* corrupt(`${code}-projection`);
-		return delivery;
-	});
-	const count = Effect.fn("SqliteSubscriptionStore.count")(function* (statement, code) {
-		const rows = yield* query(statement, code);
-		const decoded = yield* decodeRows(CountRow, rows, code);
-		if (decoded.length !== 1) return yield* corrupt(code);
-		return decoded[0].count;
-	});
-	const nextSequence = Effect.fn("SqliteSubscriptionStore.nextSequence")(function* () {
-		const rows = yield* query(sql`
-      UPDATE effect_agent_subscription_sequences SET sequence=sequence+1
-      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
-      RETURNING sequence
-    `, "advance subscription sequence");
-		const decoded = yield* decodeRows(SequenceRow, rows, "advance subscription sequence");
-		if (decoded.length !== 1) return yield* corrupt("subscription sequence");
-		return decoded[0].sequence;
-	});
-	const writeRegistration = Effect.fn("SqliteSubscriptionStore.writeRegistration")(function* (record) {
-		const json = yield* encode(SubscriptionRecord, record, "encode subscription");
-		yield* query(sql`
-      UPDATE effect_agent_subscriptions SET state=${record.state}, expires_at_millis=${record.configuration.expiresAtMillis},
-        recovery_at_millis=${record.recovery?.nextAttemptAtMillis ?? null}, record_json=${json}
-      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
-        AND owner_id=${record.key.ownerId} AND subscription_id=${record.key.subscriptionId}
-    `, "write subscription");
-	});
-	const writeEvent = Effect.fn("SqliteSubscriptionStore.writeEvent")(function* (event) {
-		const json = yield* encode(AcceptedEvent, event, "encode event");
-		yield* query(sql`
-      UPDATE effect_agent_subscription_events SET cursor=${event.cursor}, routing_complete=${event.routingComplete ? 1 : 0},
-        next_attempt_at_millis=${event.nextAttemptAtMillis}, record_json=${json}
-      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND event_id=${event.eventId}
-    `, "write event");
-	});
-	const writeDelivery = Effect.fn("SqliteSubscriptionStore.writeDelivery")(function* (delivery) {
-		const json = yield* encode(SubscriptionDelivery, delivery, "encode delivery");
-		yield* query(sql`
-      UPDATE effect_agent_subscription_deliveries SET state=${delivery.state},
-        next_attempt_at_millis=${delivery.retry.nextAttemptAtMillis}, record_json=${json}
-      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
-        AND owner_id=${delivery.key.subscription.ownerId} AND subscription_id=${delivery.key.subscription.subscriptionId}
-        AND event_id=${delivery.key.eventId}
-    `, "write delivery");
-	});
-	const register = Effect.fn("SqliteSubscriptionStore.register")(function* (input, inputLimits) {
-		const record = yield* validate(SubscriptionRecord, input, "register-record");
-		const limits = yield* validate(SubscriptionLimits, inputLimits, "register-limits");
-		yield* requirePartition(record.key.partition, "register-partition");
-		const result = yield* transact(Effect.gen(function* () {
-			const existing = yield* readRegistration(record.key, "register-existing");
-			if (existing !== null) {
-				if (existing.creationFingerprint !== record.creationFingerprint) return yield* error("conflict", "registration-identity");
-				return {
-					value: existing,
-					changed: false
-				};
-			}
-			if (bytes(record.configuration.context) > limits.maxContextBytes) return yield* error("capacity", "context-bytes");
-			if (bytes(record.configuration.parameters) > limits.maxPayloadBytes) return yield* error("capacity", "parameters-bytes");
-			if (record.configuration.expiresAtMillis - record.createdAtMillis > limits.maxLifetimeMillis) return yield* error("capacity", "lifetime");
-			if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscriptions WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}`, "count registrations")) >= limits.maxRegistrations) return yield* error("capacity", "registrations");
-			if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscriptions WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND owner_id=${record.key.ownerId}`, "count owner registrations")) >= limits.maxRegistrationsPerOwner) return yield* error("capacity", "owner-registrations");
-			const assigned = {
-				...record,
-				ordinal: yield* nextSequence()
-			};
-			const json = yield* encode(SubscriptionRecord, assigned, "encode registration");
-			yield* failpoint.hit("subscription:register:before");
-			yield* query(sql`
-        INSERT INTO effect_agent_subscriptions (tenant_id, source_address, owner_id, subscription_id, ordinal,
-          source_name, source_version, matching_key, state, expires_at_millis, recovery_at_millis, record_json)
-        VALUES (${partition.tenantId}, ${partition.address}, ${assigned.key.ownerId}, ${assigned.key.subscriptionId}, ${assigned.ordinal},
-          ${assigned.configuration.source.name}, ${assigned.configuration.source.version}, ${assigned.configuration.matchingKey}, ${assigned.state},
-          ${assigned.configuration.expiresAtMillis}, ${assigned.recovery?.nextAttemptAtMillis ?? null}, ${json})
-      `, "insert registration");
-			return {
-				value: assigned,
-				changed: true
-			};
-		}));
-		if (result.changed) yield* failpoint.hit("subscription:register:after");
-		return result.value;
-	});
-	const get = Effect.fn("SqliteSubscriptionStore.get")(function* (input) {
-		return yield* readRegistration(yield* requireKey(input, "get-key"), "get subscription");
-	});
-	const list = Effect.fn("SqliteSubscriptionStore.list")(function* (ownerId, after, limit) {
-		const rows = yield* query(sql`
-      SELECT owner_id, subscription_id, ordinal FROM effect_agent_subscriptions WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
-        AND owner_id=${ownerId} AND ordinal>${after} ORDER BY ordinal LIMIT ${limit}
-    `, "list subscriptions");
-		const decoded = yield* decodeRows(Schema.Struct({
-			owner_id: Schema.String,
-			subscription_id: Schema.String,
-			ordinal: Schema.Natural
-		}), rows, "list subscriptions");
-		return yield* Effect.forEach(decoded, Effect.fn("SqliteSubscriptionStore.listRecord")(function* (row) {
-			const record = yield* readRegistration({
-				partition,
-				ownerId: row.owner_id,
-				subscriptionId: row.subscription_id
-			}, "list subscription");
-			if (record === null || record.ordinal !== row.ordinal) return yield* corrupt("list subscription projection");
-			return record;
-		}));
-	});
-	const cancel = Effect.fn("SqliteSubscriptionStore.cancel")(function* (input) {
-		const key = yield* requireKey(input, "cancel-key");
-		const result = yield* transact(Effect.gen(function* () {
-			const current = yield* readRegistration(key, "cancel subscription");
-			if (current === null) return yield* error("not-found", "subscription");
-			if (current.state === "cancelled") return {
-				value: current,
-				changed: false
-			};
-			const updated = {
-				...current,
-				state: "cancelled",
-				recovery: null
-			};
-			yield* failpoint.hit("subscription:cancel:before");
-			yield* writeRegistration(updated);
-			return {
-				value: updated,
-				changed: true
-			};
-		}));
-		if (result.changed) yield* failpoint.hit("subscription:cancel:after");
-		return result.value;
-	});
-	const accept = Effect.fn("SqliteSubscriptionStore.accept")(function* (input, inputLimits) {
-		const event = yield* validate(AcceptedEvent, input, "accept-event");
-		const limits = yield* validate(SubscriptionLimits, inputLimits, "accept-limits");
-		yield* requirePartition(event.partition, "accept-partition");
-		const result = yield* transact(Effect.gen(function* () {
-			const existing = yield* readEvent(event.eventId, "accept event");
-			if (existing !== null) {
-				if (!sameAcceptedEventIdentity(existing, event)) return yield* error("conflict", "event-identity");
-				return {
-					value: existing,
-					changed: false
-				};
-			}
-			if (bytes(event.payload) > limits.maxPayloadBytes) return yield* error("capacity", "payload-bytes");
-			if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscription_events WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}`, "count events")) >= limits.maxEvents) return yield* error("capacity", "events");
-			const accepted = {
-				...event,
-				cutoff: yield* nextSequence(),
-				cursor: 0,
-				routingComplete: false,
-				routingFailure: null
-			};
-			const json = yield* encode(AcceptedEvent, accepted, "encode accepted event");
-			yield* failpoint.hit("subscription:accept:before");
-			yield* query(sql`
-        INSERT INTO effect_agent_subscription_events (tenant_id, source_address, event_id, source_name, source_version,
-          matching_key, payload_digest, cutoff, cursor, routing_complete, next_attempt_at_millis, record_json)
-        VALUES (${partition.tenantId}, ${partition.address}, ${accepted.eventId}, ${accepted.source.name}, ${accepted.source.version},
-          ${accepted.matchingKey}, ${accepted.payloadDigest}, ${accepted.cutoff}, ${accepted.cursor}, 0, ${accepted.nextAttemptAtMillis}, ${json})
-      `, "insert event");
-			return {
-				value: accepted,
-				changed: true
-			};
-		}));
-		if (result.changed) yield* failpoint.hit("subscription:accept:after");
-		return result.value;
-	});
-	const event = Effect.fn("SqliteSubscriptionStore.event")((eventId) => readEvent(eventId, "get event"));
-	const pendingEvents = Effect.fn("SqliteSubscriptionStore.pendingEvents")(function* (nowMillis, after, limit) {
-		const rows = yield* query(sql`
-      SELECT event_id FROM effect_agent_subscription_events WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
-        AND routing_complete=0 AND next_attempt_at_millis<=${nowMillis} AND event_id>${after} ORDER BY event_id LIMIT ${limit}
-    `, "pending events");
-		return yield* decodeRows(Schema.Struct({ event_id: Schema.String }), rows, "pending event keys").pipe(Effect.map((items) => items.map((item) => item.event_id)));
-	});
-	const candidates = Effect.fn("SqliteSubscriptionStore.candidates")(function* (input, limit) {
-		const supplied = yield* validate(AcceptedEvent, input, "candidates-event");
-		yield* requirePartition(supplied.partition, "candidates-partition");
-		const stored = yield* readEvent(supplied.eventId, "candidates event");
-		if (stored === null) return yield* error("not-found", "event");
-		if (!sameAcceptedEventIdentity(stored, supplied)) return yield* error("conflict", "event");
-		const rows = yield* query(sql`
-      SELECT owner_id, subscription_id, ordinal FROM effect_agent_subscriptions WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
-        AND source_name=${stored.source.name} AND source_version=${stored.source.version} AND matching_key=${stored.matchingKey}
-        AND ordinal>${stored.cursor} AND ordinal<=${stored.cutoff} ORDER BY ordinal LIMIT ${limit}
-    `, "subscription candidates");
-		const decoded = yield* decodeRows(Schema.Struct({
-			owner_id: Schema.String,
-			subscription_id: Schema.String,
-			ordinal: Schema.Natural
-		}), rows, "subscription candidates");
-		return yield* Effect.forEach(decoded, Effect.fn("SqliteSubscriptionStore.candidateRecord")(function* (row) {
-			const record = yield* readRegistration({
-				partition,
-				ownerId: row.owner_id,
-				subscriptionId: row.subscription_id
-			}, "subscription candidate");
-			if (record === null || record.ordinal !== row.ordinal) return yield* corrupt("subscription candidate projection");
-			return record;
-		}));
-	});
-	const insertDelivery = Effect.fn("SqliteSubscriptionStore.insertDelivery")(function* (delivery) {
-		const json = yield* encode(SubscriptionDelivery, delivery, "encode selected delivery");
-		yield* query(sql`
-      INSERT INTO effect_agent_subscription_deliveries (tenant_id, source_address, owner_id, subscription_id, event_id,
-        delivery_key, state, next_attempt_at_millis, record_json)
-      VALUES (${partition.tenantId}, ${partition.address}, ${delivery.key.subscription.ownerId}, ${delivery.key.subscription.subscriptionId},
-        ${delivery.key.eventId}, ${subscriptionDeliveryKeyString(delivery.key)}, ${delivery.state}, ${delivery.retry.nextAttemptAtMillis}, ${json})
-    `, "insert delivery");
-	});
-	const select = Effect.fn("SqliteSubscriptionStore.select")(function* (inputEvent, inputDeliveries, cursor, complete, nowMillis, inputLimits) {
-		const supplied = yield* validate(AcceptedEvent, inputEvent, "select-event");
-		const deliveries = yield* validate(Schema.Array(SubscriptionDelivery), inputDeliveries, "select-deliveries");
-		const limits = yield* validate(SubscriptionLimits, inputLimits, "select-limits");
-		yield* requirePartition(supplied.partition, "select-partition");
-		for (const candidate of deliveries) yield* requirePartition(candidate.key.subscription.partition, "select-delivery-partition");
-		if (yield* transact(Effect.gen(function* () {
-			const accepted = yield* readEvent(supplied.eventId, "select event");
-			if (accepted === null) return yield* error("not-found", "event");
-			if (!sameAcceptedEventIdentity(accepted, supplied) || accepted.cursor !== supplied.cursor) return yield* error("conflict", "event-cursor");
-			if (accepted.routingComplete) return false;
-			if (!Number.isSafeInteger(cursor) || cursor < accepted.cursor || cursor > accepted.cutoff) return yield* error("validation", "cursor");
-			yield* failpoint.hit("subscription:select:before");
-			const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
-			const additions = [];
-			for (const delivery of deliveries) {
-				const record = yield* readRegistration(delivery.key.subscription, "select registration");
-				if (record === null) return yield* error("not-found", "subscription");
-				if (!subscriptionDeliveryCanSelect(delivery, record, accepted) || delivery.key.eventId !== accepted.eventId || delivery.source.name !== accepted.source.name || delivery.source.version !== accepted.source.version || record.ordinal <= accepted.cursor || record.ordinal > cursor) return yield* error("conflict", "selection");
-				const existing = yield* readDelivery(delivery.key, "select existing delivery");
-				if (existing !== null) {
-					if (!sameDeliveryIdentity(existing, delivery)) return yield* error("conflict", "delivery-identity");
-					continue;
-				}
-				if (!subscriptionCanSelect(record, accepted, effectiveNowMillis, false)) continue;
-				additions.push({
-					delivery,
-					record
-				});
-			}
-			if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}`, "count deliveries")) + additions.length > limits.maxDeliveries) return yield* error("capacity", "deliveries");
-			for (const ownerId of new Set(additions.map(({ record }) => record.key.ownerId))) if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND owner_id=${ownerId}`, "count owner deliveries")) + additions.filter(({ record }) => record.key.ownerId === ownerId).length > limits.maxDeliveriesPerOwner) return yield* error("capacity", "owner-deliveries");
-			for (const addition of additions) {
-				yield* insertDelivery(addition.delivery);
-				if (addition.record.configuration.mode === "once") yield* writeRegistration({
-					...addition.record,
-					state: "consumed",
-					recovery: null
-				});
-			}
-			yield* writeEvent({
-				...accepted,
-				cursor,
-				routingComplete: complete,
-				routingFailure: null
-			});
-			return true;
-		}))) yield* failpoint.hit("subscription:select:after");
-	});
-	const catchUp = Effect.fn("SqliteSubscriptionStore.catchUp")(function* (inputEvent, inputDelivery, nowMillis, inputLimits) {
-		const supplied = yield* validate(AcceptedEvent, inputEvent, "catch-up-event");
-		const delivery = yield* validate(SubscriptionDelivery, inputDelivery, "catch-up-delivery");
-		const limits = yield* validate(SubscriptionLimits, inputLimits, "catch-up-limits");
-		yield* requirePartition(supplied.partition, "catch-up-partition");
-		yield* requirePartition(delivery.key.subscription.partition, "catch-up-delivery-partition");
-		if (yield* transact(Effect.gen(function* () {
-			const accepted = yield* readEvent(supplied.eventId, "catch-up event");
-			const record = yield* readRegistration(delivery.key.subscription, "catch-up subscription");
-			if (accepted === null || record === null) return yield* error("not-found", accepted === null ? "event" : "subscription");
-			if (!sameAcceptedEventIdentity(accepted, supplied) || !subscriptionDeliveryCanSelect(delivery, record, accepted) || delivery.key.eventId !== accepted.eventId || delivery.source.name !== accepted.source.name || delivery.source.version !== accepted.source.version || record.configuration.mode !== "once") return yield* error("conflict", "catch-up-identity");
-			const existing = yield* readDelivery(delivery.key, "catch-up existing delivery");
-			if (existing !== null) {
-				if (!sameDeliveryIdentity(existing, delivery)) return yield* error("conflict", "delivery-identity");
-				return false;
-			}
-			yield* failpoint.hit("subscription:catch-up:before");
-			const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
-			if (!subscriptionCanSelect(record, accepted, effectiveNowMillis, true)) return yield* error("conflict", "catch-up-eligibility");
-			if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}`, "count deliveries")) >= limits.maxDeliveries) return yield* error("capacity", "deliveries");
-			if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND owner_id=${record.key.ownerId}`, "count owner deliveries")) >= limits.maxDeliveriesPerOwner) return yield* error("capacity", "owner-deliveries");
-			yield* insertDelivery(delivery);
-			yield* writeRegistration({
-				...record,
-				state: "consumed",
-				recovery: null
-			});
-			return true;
-		}))) yield* failpoint.hit("subscription:catch-up:after");
-	});
-	const deferEvent = Effect.fn("SqliteSubscriptionStore.deferEvent")(function* (eventId, nextAttemptAtMillis, code) {
-		const routingFailure = code === void 0 ? "routing-failed" : yield* validate(SubscriptionName, code, "routing-failure");
-		yield* transact(Effect.gen(function* () {
-			const accepted = yield* readEvent(eventId, "defer event");
-			if (accepted === null) return yield* error("not-found", "event");
-			yield* failpoint.hit("subscription:defer-event:before");
-			yield* writeEvent({
-				...accepted,
-				nextAttemptAtMillis,
-				routingFailure
-			});
-		}));
-		yield* failpoint.hit("subscription:defer-event:after");
-	});
-	const delivery = Effect.fn("SqliteSubscriptionStore.delivery")(function* (input) {
-		const key = yield* validate(SubscriptionDeliveryKey, input, "delivery-key");
-		yield* requirePartition(key.subscription.partition, "delivery-partition");
-		return yield* readDelivery(key, "get delivery");
-	});
-	const pendingDeliveries = Effect.fn("SqliteSubscriptionStore.pendingDeliveries")(function* (nowMillis, after, limit) {
-		const rows = yield* query(sql`
-      SELECT owner_id, subscription_id, event_id FROM effect_agent_subscription_deliveries
-      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND state NOT IN ('delivered','refused')
-        AND next_attempt_at_millis<=${nowMillis} AND delivery_key>${after} ORDER BY delivery_key LIMIT ${limit}
-    `, "pending deliveries");
-		const rowSchema = Schema.Struct({
-			owner_id: Schema.String,
-			subscription_id: Schema.String,
-			event_id: Schema.String
-		});
-		return yield* decodeRows(rowSchema, rows, "pending delivery keys").pipe(Effect.map((items) => items.map((item) => ({
-			subscription: {
-				partition,
-				ownerId: item.owner_id,
-				subscriptionId: item.subscription_id
-			},
-			eventId: item.event_id
-		}))));
-	});
-	const listDeliveries = Effect.fn("SqliteSubscriptionStore.listDeliveries")(function* (input, after, limit) {
-		const key = yield* requireKey(input, "list-deliveries-key");
-		const rows = yield* query(sql`
-      SELECT record_json FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
-        AND owner_id=${key.ownerId} AND subscription_id=${key.subscriptionId} AND delivery_key>${after} ORDER BY delivery_key LIMIT ${limit}
-    `, "list deliveries");
-		const decoded = yield* decodeRows(JsonRow, rows, "list deliveries");
-		return yield* Effect.forEach(decoded, (row) => decode(SubscriptionDelivery, row.record_json, "list delivery"));
-	});
-	const changeDelivery = Effect.fn("SqliteSubscriptionStore.changeDelivery")(function* (inputKey, inputDeliveryId, inputChange) {
-		const key = yield* validate(SubscriptionDeliveryKey, inputKey, "change-delivery-key");
-		const deliveryId = yield* validate(Digest, inputDeliveryId, "change-delivery-id");
-		const change = yield* validate(DeliveryChange, inputChange, "change-delivery-change");
-		yield* requirePartition(key.subscription.partition, "change-delivery-partition");
-		const result = yield* transact(Effect.gen(function* () {
-			const existing = yield* readDelivery(key, "change delivery");
-			const record = yield* readRegistration(key.subscription, "change delivery subscription");
-			if (existing === null || record === null) return yield* error("not-found", existing === null ? "delivery" : "subscription");
-			yield* failpoint.hit(`subscription:delivery-${change._tag.toLowerCase()}:before`);
-			const effectiveChange = change._tag === "Prepare" ? {
-				...change,
-				nowMillis: Math.max(change.nowMillis, yield* Clock.currentTimeMillis)
-			} : change;
-			const transition = applySubscriptionDeliveryChange(existing, record, deliveryId, effectiveChange);
-			if (Result.isFailure(transition)) return yield* transition.failure;
-			if (transition.success === existing) return {
-				value: existing,
-				changed: false
-			};
-			yield* writeDelivery(transition.success);
-			return {
-				value: transition.success,
-				changed: true
-			};
-		}));
-		if (result.changed) yield* failpoint.hit(`subscription:delivery-${change._tag.toLowerCase()}:after`);
-		return result.value;
-	});
-	const recovering = Effect.fn("SqliteSubscriptionStore.recovering")(function* (nowMillis, after, limit) {
-		const rows = yield* query(sql`
-      SELECT owner_id, subscription_id, ordinal FROM effect_agent_subscriptions
-      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND state='active'
-        AND recovery_at_millis IS NOT NULL AND recovery_at_millis<=${nowMillis} AND ordinal>${after}
-      ORDER BY ordinal LIMIT ${limit}
-    `, "recovering subscriptions");
-		const rowSchema = Schema.Struct({
-			owner_id: Schema.String,
-			subscription_id: Schema.String,
-			ordinal: Schema.Natural
-		});
-		return yield* decodeRows(rowSchema, rows, "recovering subscription keys").pipe(Effect.map((items) => items.map((item) => ({
-			key: {
-				partition,
-				ownerId: item.owner_id,
-				subscriptionId: item.subscription_id
-			},
-			ordinal: item.ordinal
-		}))));
-	});
-	const deferRecovery = Effect.fn("SqliteSubscriptionStore.deferRecovery")(function* (input, recovery) {
-		const key = yield* requireKey(input, "defer-recovery-key");
-		yield* transact(Effect.gen(function* () {
-			const record = yield* readRegistration(key, "defer recovery");
-			if (record === null) return yield* error("not-found", "subscription");
-			yield* failpoint.hit("subscription:defer-recovery:before");
-			yield* writeRegistration({
-				...record,
-				recovery: record.state === "active" ? recovery : null
-			});
-		}));
-		yield* failpoint.hit("subscription:defer-recovery:after");
-	});
-	const readScanCursors = Effect.gen(function* () {
-		const rows = yield* query(sql`
-      SELECT event_scan_cursor, delivery_scan_cursor, recovery_scan_cursor
-      FROM effect_agent_subscription_sequences
-      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
-    `, "read subscription scan cursors");
-		const decoded = yield* decodeRows(ScanRow, rows, "read subscription scan cursors");
-		if (decoded.length !== 1) return yield* corrupt("subscription scan cursors");
-		return {
-			events: decoded[0].event_scan_cursor,
-			deliveries: decoded[0].delivery_scan_cursor,
-			recovery: decoded[0].recovery_scan_cursor
-		};
-	});
-	const advanceScanCursors = Effect.fn("SqliteSubscriptionStore.advanceScanCursors")(function* (input) {
-		const cursors = yield* validate(SubscriptionScanCursors, input, "scan-cursors");
-		yield* transact(Effect.gen(function* () {
-			yield* failpoint.hit("subscription:advance-scan-cursors:before");
-			yield* query(sql`
-        UPDATE effect_agent_subscription_sequences
-        SET event_scan_cursor=${cursors.events}, delivery_scan_cursor=${cursors.deliveries}, recovery_scan_cursor=${cursors.recovery}
-        WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
-      `, "advance subscription scan cursors");
-		}));
-		yield* failpoint.hit("subscription:advance-scan-cursors:after");
-	});
-	const indexedDeadline = query(sql`
-    SELECT MIN(deadline) AS deadline FROM (
-      SELECT next_attempt_at_millis AS deadline FROM effect_agent_subscription_events
-        WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND routing_complete=0
-      UNION ALL SELECT next_attempt_at_millis FROM effect_agent_subscription_deliveries
-        WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND state NOT IN ('delivered','refused')
-      UNION ALL SELECT recovery_at_millis FROM effect_agent_subscriptions
-        WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND state='active' AND recovery_at_millis IS NOT NULL
-    )
-  `, "next subscription deadline").pipe(Effect.flatMap((rows) => decodeRows(Schema.Struct({ deadline: Schema.NullOr(Schema.Number) }), rows, "next subscription deadline")), Effect.flatMap((rows) => rows.length === 1 ? Effect.succeed(rows[0].deadline) : Effect.fail(corrupt("next subscription deadline"))));
-	const nextDeadline = Effect.gen(function* () {
-		const cursors = yield* readScanCursors;
-		if (cursors.events !== "" || cursors.deliveries !== "" || cursors.recovery !== 0) return 0;
-		return yield* indexedDeadline;
-	});
-	return SubscriptionStore.of({
-		partition,
-		register,
-		get,
-		list,
-		cancel,
-		accept,
-		event,
-		pendingEvents,
-		candidates,
-		select,
-		catchUp,
-		deferEvent,
-		delivery,
-		pendingDeliveries,
-		listDeliveries,
-		changeDelivery,
-		recovering,
-		deferRecovery,
-		readScanCursors,
-		advanceScanCursors,
-		nextDeadline
-	});
-});
-const subscriptionStoreLayer = (partition) => Layer.effect(SubscriptionStore, makeSubscriptionStore(partition));
-//#endregion
-export { CurrentSqliteStorageVersion, SqliteAppendConflict, SqliteCheckpointConflict, SqliteFenceRejected, SqliteLedgerError, SqliteStorageCompatibilityError, SqliteStorageConfig, SqliteStorageConfigValue, SqliteStorageCorruptionError, SqliteStorageError, SqliteStorageFailpoint, SqliteStorageFailpointError, SqliteStorageFailpointLocation, SqliteWriteContention, activityProcessorStoreLayer, activityProcessorStoreLayerWithFailpoints, layer, ledgerLayer, memoryReaderLayer, memoryStoreLayer, memoryStoreLayerWithFailpoints, observationOffsetAt, scheduleStoreLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer, subscriptionStoreLayer, threadStoreLayer };
-
-//# sourceMappingURL=index.mjs.map
+import { t as SqliteActivityStore_exports } from "./SqliteActivityStore.mjs";
+import { t as SqliteStorageConfig_exports } from "./SqliteStorageConfig.mjs";
+import { t as SqliteStorageError_exports } from "./SqliteStorageError.mjs";
+import { t as SqliteStorageFailpoint_exports } from "./SqliteStorageFailpoint.mjs";
+import { t as SqliteScheduleStore_exports } from "./SqliteScheduleStore.mjs";
+import { t as SqliteStorageVersion_exports } from "./SqliteStorageVersion.mjs";
+import { t as SqliteThreadStore_exports } from "./SqliteThreadStore.mjs";
+import { t as SqliteSubmissionLedger_exports } from "./SqliteSubmissionLedger.mjs";
+import { t as SqliteSubscriptionStore_exports } from "./SqliteSubscriptionStore.mjs";
+export { SqliteActivityStore_exports as SqliteActivityStore, SqliteScheduleStore_exports as SqliteScheduleStore, SqliteStorageConfig_exports as SqliteStorageConfig, SqliteStorageError_exports as SqliteStorageError, SqliteStorageFailpoint_exports as SqliteStorageFailpoint, SqliteStorageVersion_exports as SqliteStorageVersion, SqliteSubmissionLedger_exports as SqliteSubmissionLedger, SqliteSubscriptionStore_exports as SqliteSubscriptionStore, SqliteThreadStore_exports as SqliteThreadStore };