@effect-agent/storage-sqlite 0.1.0-beta.39 → 0.1.0-beta.40

package/dist/index.mjs

@@ -1,9 +1,10 @@
 import { t as SqliteStorageFailpoint } from "./sqlite-storage-failpoint-DIwWk5dw.mjs";
-import { AbortCommand, AbortIntent, AcceptedEvent, 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, 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 { 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 { MemoryDocument, MemoryKey, MemoryMutationFailpoint, MemoryNamespaceAddress, MemoryOperationConflict, MemoryReader, MemoryStorageError, MemoryWrite, MemoryWriter, applyMemoryWrite } from "@effect-agent/core";
 //#region src/errors.ts
 /** The SQLite file uses a private-development format this adapter cannot read. */
 var SqliteStorageCompatibilityError = class extends Schema.TaggedError()("SqliteStorageCompatibilityError", {
@@ -132,10 +133,10 @@ var SqliteStorageFailpointError = class extends Schema.TaggedError()("SqliteStor
 //#endregion
 //#region src/migrations.ts
 const CurrentSqliteStorageVersion = 7;
-const sqliteMigrations = SqliteMigrator.fromRecord({
-	"1_current_persistent_thread_foundation": Effect.gen(function* () {
-		const sql = yield* SqlClient.SqlClient;
-		yield* sql`
+/** 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,
@@ -144,7 +145,7 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
         producer_epoch INTEGER NOT NULL
       )
     `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_canonical_batches (
         thread_id TEXT NOT NULL,
         batch_id TEXT NOT NULL,
@@ -159,7 +160,7 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
           ON DELETE RESTRICT
       )
     `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_canonical_records (
         thread_id TEXT NOT NULL,
         sequence INTEGER NOT NULL,
@@ -173,11 +174,11 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
           ON DELETE RESTRICT
       )
     `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE INDEX effect_agent_canonical_records_batch
         ON effect_agent_canonical_records (thread_id, batch_id, sequence)
     `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_checkpoints (
         thread_id TEXT NOT NULL,
         through_sequence INTEGER NOT NULL,
@@ -189,11 +190,7 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
           ON DELETE RESTRICT
       )
     `.withoutTransform;
-		yield* sql`PRAGMA user_version = 1`.withoutTransform;
-	}),
-	"2_durable_submission_ledger": Effect.gen(function* () {
-		const sql = yield* SqlClient.SqlClient;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_submissions (
         submission_id TEXT PRIMARY KEY NOT NULL,
         thread_id TEXT NOT NULL,
@@ -212,11 +209,18 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
         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`
+	yield* sql`
       CREATE TABLE effect_agent_submission_ownership (
         submission_id TEXT PRIMARY KEY NOT NULL,
         attempt_id TEXT NOT NULL,
@@ -229,7 +233,7 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
           ON DELETE RESTRICT
       )
     `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_attempts (
         attempt_id TEXT PRIMARY KEY NOT NULL,
         submission_id TEXT NOT NULL,
@@ -242,7 +246,7 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
           ON DELETE RESTRICT
       )
     `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_settlement_reservations (
         submission_id TEXT PRIMARY KEY NOT NULL,
         settlement_id TEXT NOT NULL,
@@ -257,7 +261,7 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
           ON DELETE RESTRICT
       )
     `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_abort_intents (
         submission_id TEXT PRIMARY KEY NOT NULL,
         author TEXT NOT NULL,
@@ -269,35 +273,11 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
           ON DELETE RESTRICT
       )
     `.withoutTransform;
-		yield* sql`PRAGMA user_version = 2`.withoutTransform;
-	}),
-	"3_durable_tools_and_joined_input": Effect.gen(function* () {
-		const sql = yield* SqlClient.SqlClient;
-		yield* sql`
-      ALTER TABLE effect_agent_submissions
-        ADD COLUMN joined_host_submission_id TEXT
-    `.withoutTransform;
-		yield* sql`
-      ALTER TABLE effect_agent_submissions
-        ADD COLUMN suspended_reason_json TEXT
-    `.withoutTransform;
-		yield* sql`
-      ALTER TABLE effect_agent_submissions
-        ADD COLUMN suspended_at TEXT
-    `.withoutTransform;
-		yield* sql`
-      ALTER TABLE effect_agent_submissions
-        ADD COLUMN unknown_reason TEXT
-    `.withoutTransform;
-		yield* sql`
-      ALTER TABLE effect_agent_submissions
-        ADD COLUMN unknown_tool_call_ids_json TEXT
-    `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE INDEX effect_agent_submissions_joined_host
         ON effect_agent_submissions (joined_host_submission_id)
     `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_approval_decisions (
         submission_id TEXT NOT NULL,
         tool_call_id TEXT NOT NULL,
@@ -311,7 +291,7 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
           ON DELETE RESTRICT
       )
     `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_unknown_resolutions (
         submission_id TEXT NOT NULL,
         tool_call_id TEXT NOT NULL,
@@ -325,23 +305,11 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
           ON DELETE RESTRICT
       )
     `.withoutTransform;
-		yield* sql`PRAGMA user_version = 3`.withoutTransform;
-	}),
-	"4_durable_subagents": Effect.gen(function* () {
-		const sql = yield* SqlClient.SqlClient;
-		yield* sql`
-      ALTER TABLE effect_agent_submissions
-        ADD COLUMN parent_submission_id TEXT
-    `.withoutTransform;
-		yield* sql`
-      ALTER TABLE effect_agent_submissions
-        ADD COLUMN parent_tool_call_id TEXT
-    `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE INDEX effect_agent_submissions_parent
         ON effect_agent_submissions (parent_submission_id)
     `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_child_reservations (
         reservation_id TEXT PRIMARY KEY NOT NULL,
         parent_submission_id TEXT NOT NULL,
@@ -360,11 +328,7 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
           ON DELETE RESTRICT
       )
     `.withoutTransform;
-		yield* sql`PRAGMA user_version = 4`.withoutTransform;
-	}),
-	"5_durable_schedules": Effect.gen(function* () {
-		const sql = yield* SqlClient.SqlClient;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_schedules (
         tenant_id TEXT NOT NULL,
         owner_id TEXT NOT NULL,
@@ -374,21 +338,17 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
         PRIMARY KEY (tenant_id, owner_id, schedule_id)
       )
     `.withoutTransform;
-		yield* sql`
+	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`
+	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`PRAGMA user_version = 5`.withoutTransform;
-	}),
-	"6_durable_subscriptions": Effect.gen(function* () {
-		const sql = yield* SqlClient.SqlClient;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_subscription_sequences (
         tenant_id TEXT NOT NULL,
         source_address TEXT NOT NULL,
@@ -399,7 +359,7 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
         PRIMARY KEY (tenant_id, source_address)
       )
     `.withoutTransform;
-		yield* sql`
+	yield* sql`
       CREATE TABLE effect_agent_subscriptions (
         tenant_id TEXT NOT NULL,
         source_address TEXT NOT NULL,
@@ -417,10 +377,10 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
         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`
+	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,
@@ -437,8 +397,8 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
         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`
+	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,
@@ -453,14 +413,308 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
         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 = 6`.withoutTransform;
-	}),
-	"7_thread_terminology_cutover": Effect.gen(function* () {
-		yield* (yield* SqlClient.SqlClient)`PRAGMA user_version = 7`.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 = 1;
+const METADATA_COMPONENT$1 = "activity";
+const STATE_TABLE = "effect_agent_activity_processor_state_v1";
+const StoredJson$2 = 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$2
+}) {};
+var ActivityChangeCountRow = class extends Schema.Class("@effect-agent/storage-sqlite/ActivityChangeCountRow")({ changed: Schema.Int }) {};
+const StoredVersionHeader$1 = Schema.Struct({ version: Schema.Int });
+const storeError$1 = (operation, reason = "unavailable") => ActivityStoreError.make({
+	operation,
+	reason
+});
+const query$1 = (effect, operation) => effect.pipe(Effect.mapError(() => storeError$1(operation)));
+const decodeRows$4 = 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$2 = 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$2)(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$1))(value).pipe(Effect.mapError(() => storeError$1(operation, "corrupt")))).version !== STORAGE_VERSION$1) 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$1}
+        `;
+		const metadata = yield* decodeRows$4(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$1) 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$4(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$1}, ${STORAGE_VERSION$1})
+          `;
+		}
+		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$1(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$4(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$1) 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$1(sql`SELECT changes() AS changed`, operation);
+		const rows = yield* decodeRows$4(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$1}, ${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$1},
+          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$2(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$2(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$1,
+				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$2(ActivityClaim, request.claim, operation);
+		const work = yield* decodeInput$2(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$2(ActivityClaim, request.claim, operation);
+		const workId = yield* decodeInput$2(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$2(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));
@@ -493,11 +747,11 @@ var SqliteStorageConfigValue = class extends Schema.Class("@effect-agent/storage
 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(16 * 1024 * 1024));
+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 = 16 * 1024 * 1024;
+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 }) {};
@@ -570,19 +824,19 @@ var RawThreadExport = class extends Schema.Class("@effect-agent/storage-sqlite/R
 	thread: ThreadRow,
 	records: Schema.Array(RecordRow)
 }) {};
-const storageError = (operation) => (error) => SqliteStorageError.make({
+const storageError$1 = (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({
+const decodeRows$3 = 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({
+const decodeSingleRow = Effect.fn("SqliteJournal.decodeSingleRow")((schema, table, rowKey, rows) => decodeRows$3(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}.`
@@ -591,16 +845,16 @@ 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")));
+	yield* sql`PRAGMA foreign_keys = ON`.pipe(Effect.mapError(storageError$1("enable foreign keys")));
+	yield* sql.unsafe(`PRAGMA busy_timeout = ${busyTimeout}`).pipe(Effect.mapError(storageError$1("configure busy timeout")));
+	const journalModeRows = yield* sql`PRAGMA journal_mode`.pipe(Effect.mapError(storageError$1("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 versionRows = yield* sql`PRAGMA user_version`.pipe(Effect.mapError(storageError$1("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,
@@ -614,8 +868,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
       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({
+    `.pipe(Effect.mapError(storageError$1("inspect unversioned storage")));
+		if ((yield* decodeRows$3(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."
@@ -645,8 +899,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
         '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({
+  `.pipe(Effect.mapError(storageError$1("verify storage tables")));
+	if ((yield* decodeRows$3(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."
@@ -655,7 +909,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
 		cause: error,
 		operation,
 		message: `Another producer holds the SQLite write lock; ${operation} is safe to retry.`
-	}) : storageError(operation)(error);
+	}) : storageError$1(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
@@ -688,11 +942,11 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
 	* `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 connection = yield* sql.reserve.pipe(Effect.mapError(storageError$1(operation)));
+		yield* connection.executeUnprepared("BEGIN", [], void 0).pipe(Effect.mapError(storageError$1(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)));
+			yield* connection.executeUnprepared("COMMIT", [], void 0).pipe(Effect.mapError(storageError$1(operation)));
 			return exit.value;
 		}
 		yield* Effect.orDie(connection.executeUnprepared("ROLLBACK", [], void 0));
@@ -713,8 +967,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             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);
+        `.pipe(Effect.mapError(storageError$1("read materialized thread")));
+			const existing = yield* decodeRows$3(Schema.Array(ThreadRow), "effect_agent_threads", threadId, existingRows);
 			if (existing.length > 1) return yield* SqliteStorageCorruptionError.make({
 				table: "effect_agent_threads",
 				rowKey: threadId,
@@ -735,7 +989,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
               ${emptyTailDigest},
               ${producerEpoch}
             )
-          `.pipe(Effect.mapError(storageError("materialize thread")));
+          `.pipe(Effect.mapError(storageError$1("materialize thread")));
 				return;
 			}
 			if (producerEpoch < existing[0].producer_epoch) return yield* SqliteFenceRejected.make({
@@ -747,7 +1001,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             UPDATE effect_agent_threads
             SET producer_epoch = ${producerEpoch}
             WHERE thread_id = ${threadId}
-          `.pipe(Effect.mapError(storageError("advance materialization epoch")));
+          `.pipe(Effect.mapError(storageError$1("advance materialization epoch")));
 		}));
 	});
 	const getThread = Effect.fn("SqliteJournal.getThread")(function* (threadId) {
@@ -760,8 +1014,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
         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);
+    `.pipe(Effect.mapError(storageError$1("read thread")));
+		return yield* decodeRows$3(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({
@@ -783,7 +1037,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             producer_epoch
           FROM effect_agent_threads
           WHERE thread_id = ${request.threadId}
-        `.pipe(Effect.mapError(storageError("read append tail")));
+        `.pipe(Effect.mapError(storageError$1("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,
@@ -802,8 +1056,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
           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);
+        `.pipe(Effect.mapError(storageError$1("read idempotent batch")));
+			const batches = yield* decodeRows$3(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}`,
@@ -843,8 +1097,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
           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);
+        `.pipe(Effect.mapError(storageError$1("check canonical record identities")));
+			const existingRecords = yield* decodeRows$3(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"
@@ -877,7 +1131,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             ${request.tailDigest},
             ${request.batchJson}
           )
-        `.pipe(Effect.mapError(storageError("insert canonical batch")));
+        `.pipe(Effect.mapError(storageError$1("insert canonical batch")));
 			yield* failpoint("append:after-batch-insert");
 			yield* Effect.forEach(request.records, (record, index) => Effect.gen(function* () {
 				yield* sql`
@@ -894,7 +1148,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
                     ${request.batchId},
                     ${record.recordJson}
                   )
-                `.pipe(Effect.mapError(storageError("insert canonical record")));
+                `.pipe(Effect.mapError(storageError$1("insert canonical record")));
 				yield* failpoint("append:after-record-insert");
 			}), { discard: true });
 			yield* sql`
@@ -904,7 +1158,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             tail_digest = ${request.tailDigest},
             producer_epoch = ${request.producerEpoch}
           WHERE thread_id = ${request.threadId}
-        `.pipe(Effect.mapError(storageError("advance thread tail")));
+        `.pipe(Effect.mapError(storageError$1("advance thread tail")));
 			yield* failpoint("append:after-tail-update");
 			return RawAppendResult.make({
 				firstSequence,
@@ -927,8 +1181,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
         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);
+    `.pipe(Effect.mapError(storageError$1("read canonical records")));
+		return yield* decodeRows$3(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* () {
@@ -941,7 +1195,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
               producer_epoch
             FROM effect_agent_threads
             WHERE thread_id = ${threadId}
-          `.pipe(Effect.mapError(storageError("export thread")));
+          `.pipe(Effect.mapError(storageError$1("export thread")));
 			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", threadId, threadRows);
 			yield* failpoint("export:after-thread-read");
 			const batchRows = yield* sql`
@@ -956,7 +1210,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             FROM effect_agent_canonical_batches
             WHERE thread_id = ${threadId}
             ORDER BY first_sequence
-          `.pipe(Effect.mapError(storageError("export canonical batches")));
+          `.pipe(Effect.mapError(storageError$1("export canonical batches")));
 			const recordRows = yield* sql`
             SELECT
               thread_id,
@@ -967,7 +1221,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             FROM effect_agent_canonical_records
             WHERE thread_id = ${threadId}
             ORDER BY sequence
-          `.pipe(Effect.mapError(storageError("export canonical records")));
+          `.pipe(Effect.mapError(storageError$1("export canonical records")));
 			const checkpointRows = yield* sql`
             SELECT
               thread_id,
@@ -977,12 +1231,12 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             FROM effect_agent_checkpoints
             WHERE thread_id = ${threadId}
             ORDER BY through_sequence
-          `.pipe(Effect.mapError(storageError("export checkpoints")));
+          `.pipe(Effect.mapError(storageError$1("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)
+				batches: yield* decodeRows$3(Schema.Array(BatchRow), "effect_agent_canonical_batches", threadId, batchRows),
+				records: yield* decodeRows$3(Schema.Array(RecordRow), "effect_agent_canonical_records", threadId, recordRows),
+				checkpoints: yield* decodeRows$3(Schema.Array(CheckpointRow), "effect_agent_checkpoints", threadId, checkpointRows)
 			});
 		}));
 	});
@@ -1001,7 +1255,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             producer_epoch
           FROM effect_agent_threads
           WHERE thread_id = ${checkpoint.threadId}
-        `.pipe(Effect.mapError(storageError("read checkpoint tail")));
+        `.pipe(Effect.mapError(storageError$1("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`
@@ -1013,8 +1267,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
           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);
+        `.pipe(Effect.mapError(storageError$1("read idempotent checkpoint")));
+			const existing = yield* decodeRows$3(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}`,
@@ -1036,7 +1290,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
             ${checkpoint.tailDigest},
             ${checkpoint.checkpointJson}
           )
-        `.pipe(Effect.mapError(storageError("insert checkpoint")));
+        `.pipe(Effect.mapError(storageError$1("insert checkpoint")));
 		}));
 	});
 	const loadCheckpoint = Effect.fn("SqliteJournal.loadCheckpoint")(function* (threadId, atOrBeforeSequence) {
@@ -1051,8 +1305,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
         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);
+    `.pipe(Effect.mapError(storageError$1("load checkpoint")));
+		return yield* decodeRows$3(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${threadId}<=${atOrBeforeSequence}`, rows);
 	});
 	return {
 		append,
@@ -1075,8 +1329,8 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
       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);
+    `.pipe(Effect.mapError(storageError$1("read canonical digest at sequence")));
+			return (yield* decodeRows$3(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${threadId}/${sequence}`, rows)).map((batch) => batch.tail_digest);
 		}),
 		loadCheckpoint,
 		materialize,
@@ -1093,7 +1347,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
               producer_epoch
             FROM effect_agent_threads
             ORDER BY thread_id
-          `.pipe(Effect.mapError(storageError("scan threads")));
+          `.pipe(Effect.mapError(storageError$1("scan threads")));
 				const batches = yield* sql`
             SELECT
               thread_id,
@@ -1105,7 +1359,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
               batch_json
             FROM effect_agent_canonical_batches
             ORDER BY thread_id, first_sequence
-          `.pipe(Effect.mapError(storageError("scan canonical batches")));
+          `.pipe(Effect.mapError(storageError$1("scan canonical batches")));
 				const records = yield* sql`
             SELECT
               thread_id,
@@ -1115,7 +1369,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
               record_json
             FROM effect_agent_canonical_records
             ORDER BY thread_id, sequence
-          `.pipe(Effect.mapError(storageError("scan canonical records")));
+          `.pipe(Effect.mapError(storageError$1("scan canonical records")));
 				const checkpoints = yield* sql`
             SELECT
               thread_id,
@@ -1124,12 +1378,12 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
               checkpoint_json
             FROM effect_agent_checkpoints
             ORDER BY thread_id, through_sequence
-          `.pipe(Effect.mapError(storageError("scan checkpoints")));
+          `.pipe(Effect.mapError(storageError$1("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)
+					threads: yield* decodeRows$3(Schema.Array(ThreadRow), "effect_agent_threads", "startup_scan", threads),
+					batches: yield* decodeRows$3(Schema.Array(BatchRow), "effect_agent_canonical_batches", "startup_scan", batches),
+					records: yield* decodeRows$3(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
+					checkpoints: yield* decodeRows$3(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
 				};
 			}));
 		}),
@@ -1138,7 +1392,7 @@ const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function*
 });
 //#endregion
 //#region src/sqlite-thread-store.ts
-const OffsetText = Schema.String.check(Schema.isMaxLength(4 * 1024));
+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);
@@ -1541,7 +1795,7 @@ const layer = (options) => Layer.unwrap(Effect.map(SqliteStorageConfig, (config)
 const observationOffsetAt = makeOffset;
 //#endregion
 //#region src/sqlite-ledger.ts
-const BoundedStoredText = Schema.String.check(Schema.isMaxLength(16 * 1024 * 1024));
+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;
@@ -1750,7 +2004,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 		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 decodeSubmissionRows = (operation, rowKey, rows) => decodeRows$3(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)}
@@ -1781,7 +2035,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       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)));
+		const decoded = yield* decodeRows$3(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]);
 	});
@@ -1846,7 +2100,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       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)));
+		const decoded = yield* decodeRows$3(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]);
 	});
@@ -1861,11 +2115,11 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       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)));
+		const decoded = yield* decodeRows$3(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 decodeChildReservationRows = (operation, rowKey, rows) => decodeRows$3(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)}
@@ -1918,7 +2172,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         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)));
+		return yield* decodeRows$3(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({
@@ -1943,7 +2197,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         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)));
+		return yield* decodeRows$3(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)));
@@ -1974,7 +2228,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         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;
+		return (yield* decodeRows$3(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);
@@ -2028,7 +2282,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             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 decodedMax = yield* decodeRows$3(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`
@@ -2395,7 +2649,8 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 				submissionId: validated.submissionId,
 				existingOutcome: reservation.value.outcome
 			});
-			const settlementFailure = settlementFailureFromRecord(yield* decodeRecordEnvelopeText(reservation.value.record_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, error.message))));
+			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") {
@@ -3175,8 +3430,308 @@ const submissionLedgerLayer = Layer.effectContext(makeServices());
 */
 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-memory-store.ts
+const STORAGE_VERSION = 2;
+const METADATA_COMPONENT = "memory";
+const DOCUMENT_TABLE = "effect_agent_memory_documents_v1";
+const RECEIPT_TABLE = "effect_agent_memory_receipts_v1";
+const StoredJson$1 = Schema.String.check(Schema.isMaxLength(16777216));
+const EncodedMemoryChange = Schema.Struct({
+	commandJson: StoredJson$1,
+	documentJson: StoredJson$1,
+	resultJson: StoredJson$1
+});
+const equivalentContent = Schema.toEquivalence(MemoryWrite.Wire.members[0].fields.content);
+const equivalentScopes = Schema.toEquivalence(MemoryWrite.Wire.members[0].fields.scopes);
+var MemoryMetadataRow = class extends Schema.Class("@effect-agent/storage-sqlite/MemoryMetadataRow")({ version: Schema.Int }) {};
+var MemoryTableRow = class extends Schema.Class("@effect-agent/storage-sqlite/MemoryTableRow")({ name: Schema.NonEmptyString }) {};
+var MemoryDocumentRow = class extends Schema.Class("@effect-agent/storage-sqlite/MemoryDocumentRow")({
+	namespace: MemoryNamespaceAddress,
+	source_id: MemoryKey.Wire.fields.id,
+	format_version: Schema.Int,
+	generation: Schema.Int,
+	revision: Schema.NonEmptyString,
+	document_json: StoredJson$1
+}) {};
+var MemoryReceiptRow = class extends Schema.Class("@effect-agent/storage-sqlite/MemoryReceiptRow")({
+	namespace: MemoryNamespaceAddress,
+	operation_id: MemoryWrite.Wire.members[0].fields.operationId,
+	source_id: MemoryKey.Wire.fields.id,
+	format_version: Schema.Int,
+	command_json: StoredJson$1,
+	result_json: StoredJson$1
+}) {};
+var MemoryChangeCountRow = class extends Schema.Class("@effect-agent/storage-sqlite/MemoryChangeCountRow")({ changed: Schema.Int }) {};
+var StoredMemoryCommand = class extends Schema.Class("@effect-agent/storage-sqlite/StoredMemoryCommand")({
+	version: Schema.Literal(STORAGE_VERSION),
+	value: MemoryWrite.Wire
+}) {};
+var StoredMemoryResult = class extends Schema.Class("@effect-agent/storage-sqlite/StoredMemoryResult")({
+	version: Schema.Literal(STORAGE_VERSION),
+	value: MemoryDocument.Wire
+}) {};
+const StoredVersionHeader = Schema.Struct({ version: Schema.Int });
+const storageError = (operation, reason = "unavailable") => MemoryStorageError.make({
+	operation,
+	reason
+});
+const query = (effect, operation) => effect.pipe(Effect.mapError(() => storageError(operation)));
+const decodeRows$2 = Effect.fn("SqliteMemoryStore.decodeRows")(function* (schema, rows, operation) {
+	return yield* Schema.decodeUnknownEffect(Schema.Array(schema))(rows).pipe(Effect.mapError(() => storageError(operation, "corrupt")));
+});
+const decodeInput$1 = Effect.fn("SqliteMemoryStore.decodeInput")(function* (schema, value, operation) {
+	return yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => storageError(operation, "invalid-input")));
+});
+const encodeJson = Effect.fn("SqliteMemoryStore.encodeJson")(function* (schema, value, operation) {
+	return yield* Schema.encodeEffect(Schema.fromJsonString(schema))(value).pipe(Effect.mapError(() => storageError(operation, "corrupt")));
+});
+const validateEncodedChange = Effect.fn("SqliteMemoryStore.validateEncodedChange")(function* (encoded, operation) {
+	yield* Schema.decodeEffect(EncodedMemoryChange)(encoded).pipe(Effect.mapError(() => storageError(operation, "invalid-input")));
+});
+const decodeVersionedJson = Effect.fn("SqliteMemoryStore.decodeVersionedJson")(function* (schema, value, operation) {
+	if ((yield* Schema.decodeEffect(Schema.fromJsonString(StoredVersionHeader))(value).pipe(Effect.mapError(() => storageError(operation, "corrupt")))).version !== STORAGE_VERSION) return yield* storageError(operation, "incompatible");
+	const decoded = yield* Schema.decodeEffect(Schema.fromJsonString(schema))(value).pipe(Effect.mapError(() => storageError(operation, "corrupt")));
+	if ((yield* encodeJson(schema, decoded, operation)) !== value) return yield* storageError(operation, "corrupt");
+	return decoded;
+});
+const validateDocument = Effect.fn("SqliteMemoryStore.validateDocument")(function* (document, key, operation) {
+	if (document.key.namespace.address !== key.namespace.address || document.key.id !== key.id || document.source.id !== key.id || document.source.revision !== String(document.generation) || document.generation === 1 !== (document.predecessor === null) || document.predecessor !== null && (document.predecessor.id !== key.id || document.predecessor.revision !== String(document.generation - 1))) return yield* storageError(operation, "corrupt");
+	return document;
+});
+const validateReceiptResult = Effect.fn("SqliteMemoryStore.validateReceiptResult")(function* (command, result, operation) {
+	if ((result.predecessor?.revision ?? null) !== command.expectedRevision) return yield* storageError(operation, "corrupt");
+	if (command._tag === "Put") {
+		if (result._tag !== "ActiveMemoryDocument" || result.source.locator !== command.locator) return yield* storageError(operation, "corrupt");
+		if (!equivalentContent(command.content, result.content) || !equivalentScopes(command.scopes, result.scopes)) return yield* storageError(operation, "corrupt");
+		return;
+	}
+	if (result._tag !== "WithdrawnMemoryDocument" || result.reason !== command.reason || result.predecessor === null || result.source.locator !== result.predecessor.locator) return yield* storageError(operation, "corrupt");
+});
+const initializeMemorySchema = Effect.fn("SqliteMemoryStore.initialize")(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const failpoint = yield* MemoryMutationFailpoint;
+	yield* failpoint.hit("memory:initialize:before");
+	yield* sql.withTransaction(Effect.gen(function* () {
+		yield* sql`
+          CREATE TABLE IF NOT EXISTS effect_agent_memory_metadata (
+            component TEXT PRIMARY KEY NOT NULL,
+            version INTEGER NOT NULL
+          )
+        `;
+		const metadataRows = yield* sql`
+          SELECT version
+          FROM effect_agent_memory_metadata
+          WHERE component = ${METADATA_COMPONENT}
+        `;
+		const metadata = yield* decodeRows$2(MemoryMetadataRow, metadataRows, "decode memory schema version");
+		if (metadata.length > 1) return yield* storageError("decode memory schema version", "corrupt");
+		const currentVersion = metadata[0]?.version;
+		if (currentVersion !== void 0 && currentVersion !== STORAGE_VERSION) return yield* storageError("initialize memory schema", "incompatible");
+		if (currentVersion === void 0) {
+			const tableRows = yield* sql`
+            SELECT name
+            FROM sqlite_master
+            WHERE type = 'table' AND name IN (${DOCUMENT_TABLE}, ${RECEIPT_TABLE})
+          `;
+			if ((yield* decodeRows$2(MemoryTableRow, tableRows, "inspect memory schema")).length > 0) return yield* storageError("initialize memory schema", "incompatible");
+			yield* sql`
+            CREATE TABLE effect_agent_memory_documents_v1 (
+              namespace TEXT NOT NULL,
+              source_id TEXT NOT NULL,
+              format_version INTEGER NOT NULL,
+              generation INTEGER NOT NULL,
+              revision TEXT NOT NULL,
+              document_json TEXT NOT NULL,
+              PRIMARY KEY (namespace, source_id)
+            )
+          `;
+			yield* sql`
+            CREATE TABLE effect_agent_memory_receipts_v1 (
+              namespace TEXT NOT NULL,
+              operation_id TEXT NOT NULL,
+              source_id TEXT NOT NULL,
+              format_version INTEGER NOT NULL,
+              command_json TEXT NOT NULL,
+              result_json TEXT NOT NULL,
+              PRIMARY KEY (namespace, operation_id)
+            )
+          `;
+			yield* sql`
+            INSERT INTO effect_agent_memory_metadata (component, version)
+            VALUES (${METADATA_COMPONENT}, ${STORAGE_VERSION})
+          `;
+		}
+		yield* sql`
+          SELECT namespace, source_id, format_version, generation, revision, document_json
+          FROM effect_agent_memory_documents_v1
+          LIMIT 0
+        `;
+		yield* sql`
+          SELECT namespace, operation_id, source_id, format_version, command_json, result_json
+          FROM effect_agent_memory_receipts_v1
+          LIMIT 0
+        `;
+	})).pipe(Effect.catchTag("SqlError", () => Effect.fail(storageError("initialize memory schema"))));
+	yield* failpoint.hit("memory:initialize:after");
+});
+const makeMemoryReader = Effect.fn("SqliteMemoryStore.makeReader")(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const readDocument = Effect.fn("SqliteMemoryStore.readDocument")(function* (key, operation) {
+		const rawRows = yield* query(sql`
+        SELECT namespace, source_id, format_version, generation, revision, document_json
+        FROM effect_agent_memory_documents_v1
+        WHERE namespace = ${key.namespace.address} AND source_id = ${key.id}
+      `, operation);
+		const rows = yield* decodeRows$2(MemoryDocumentRow, rawRows, operation);
+		if (rows.length === 0) return null;
+		if (rows.length !== 1) return yield* storageError(operation, "corrupt");
+		const row = rows[0];
+		if (row.format_version !== STORAGE_VERSION) return yield* storageError(operation, "incompatible");
+		const document = (yield* decodeVersionedJson(StoredMemoryResult, row.document_json, operation)).value;
+		yield* validateDocument(document, key, operation);
+		if (row.namespace !== key.namespace.address || row.source_id !== key.id || row.generation !== document.generation || row.revision !== document.source.revision) return yield* storageError(operation, "corrupt");
+		return document;
+	});
+	return {
+		get: Effect.fn("SqliteMemoryStore.get")(function* (key) {
+			const decodedKey = yield* decodeInput$1(MemoryKey.Wire, key, "get memory document");
+			return yield* readDocument(decodedKey, "get memory document");
+		}),
+		readDocument
+	};
+});
+const makeMemoryServices = Effect.fn("SqliteMemoryStore.make")(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const failpoint = yield* MemoryMutationFailpoint;
+	yield* initializeMemorySchema();
+	const { get, readDocument } = yield* makeMemoryReader();
+	const readReceipt = Effect.fn("SqliteMemoryStore.readReceipt")(function* (write, operation) {
+		const rawRows = yield* query(sql`
+        SELECT namespace, operation_id, source_id, format_version, command_json, result_json
+        FROM effect_agent_memory_receipts_v1
+        WHERE namespace = ${write.key.namespace.address} AND operation_id = ${write.operationId}
+      `, operation);
+		const rows = yield* decodeRows$2(MemoryReceiptRow, rawRows, operation);
+		if (rows.length === 0) return null;
+		if (rows.length !== 1) return yield* storageError(operation, "corrupt");
+		const row = rows[0];
+		if (row.format_version !== STORAGE_VERSION) return yield* storageError(operation, "incompatible");
+		const command = yield* decodeVersionedJson(StoredMemoryCommand, row.command_json, `${operation} command`);
+		const result = yield* decodeVersionedJson(StoredMemoryResult, row.result_json, `${operation} result`);
+		if (row.namespace !== command.value.key.namespace.address || row.operation_id !== command.value.operationId || row.source_id !== command.value.key.id || result.value.key.namespace.address !== command.value.key.namespace.address || result.value.key.id !== command.value.key.id) return yield* storageError(operation, "corrupt");
+		yield* validateDocument(result.value, command.value.key, operation);
+		yield* validateReceiptResult(command.value, result.value, operation);
+		return {
+			commandJson: row.command_json,
+			result: result.value
+		};
+	});
+	const change = Effect.fn("SqliteMemoryStore.change")(function* (write) {
+		const operation = "change memory document";
+		const decodedWrite = yield* decodeInput$1(MemoryWrite.Wire, write, operation);
+		const commandJson = yield* encodeJson(StoredMemoryCommand, StoredMemoryCommand.make({
+			version: STORAGE_VERSION,
+			value: decodedWrite
+		}), "encode memory command");
+		yield* failpoint.hit("memory:change:before");
+		const transactionResult = yield* sql.withTransaction(Effect.gen(function* () {
+			const receipt = yield* readReceipt(decodedWrite, operation);
+			if (receipt !== null) {
+				if (receipt.commandJson !== commandJson) return yield* MemoryOperationConflict.make({
+					key: decodedWrite.key,
+					operationId: decodedWrite.operationId
+				});
+				return {
+					document: receipt.result,
+					changed: false
+				};
+			}
+			const current = yield* readDocument(decodedWrite.key, operation);
+			const modifiedAt = yield* Clock.currentTimeMillis;
+			const next = yield* applyMemoryWrite(current, decodedWrite, modifiedAt);
+			const resultJson = yield* encodeJson(StoredMemoryResult, StoredMemoryResult.make({
+				version: STORAGE_VERSION,
+				value: next
+			}), "encode memory result");
+			const documentJson = resultJson;
+			yield* validateEncodedChange({
+				commandJson,
+				documentJson,
+				resultJson
+			}, operation);
+			if (current === null) yield* sql`
+                INSERT INTO effect_agent_memory_documents_v1 (
+                  namespace, source_id, format_version, generation, revision, document_json
+                ) VALUES (
+                  ${next.key.namespace.address}, ${next.key.id}, ${STORAGE_VERSION},
+                  ${next.generation}, ${next.source.revision}, ${documentJson}
+                )
+              `;
+			else yield* sql`
+                UPDATE effect_agent_memory_documents_v1
+                SET format_version = ${STORAGE_VERSION},
+                    generation = ${next.generation},
+                    revision = ${next.source.revision},
+                    document_json = ${documentJson}
+                WHERE namespace = ${next.key.namespace.address}
+                  AND source_id = ${next.key.id}
+                  AND generation = ${current.generation}
+                  AND revision = ${current.source.revision}
+              `;
+			const changedRows = yield* sql`
+              SELECT changes() AS changed
+            `;
+			const changed = yield* decodeRows$2(MemoryChangeCountRow, changedRows, operation);
+			if (changed.length !== 1 || changed[0].changed !== 1) return yield* storageError(operation, "corrupt");
+			yield* failpoint.hit("memory:change:after-state");
+			yield* sql`
+              INSERT INTO effect_agent_memory_receipts_v1 (
+                namespace, operation_id, source_id, format_version, command_json, result_json
+              ) VALUES (
+                ${decodedWrite.key.namespace.address}, ${decodedWrite.operationId}, ${decodedWrite.key.id},
+                ${STORAGE_VERSION}, ${commandJson}, ${resultJson}
+              )
+            `;
+			yield* failpoint.hit("memory:change:after-receipt");
+			return {
+				document: next,
+				changed: true
+			};
+		})).pipe(Effect.catchTag("SqlError", () => Effect.fail(storageError(operation))));
+		if (transactionResult.changed) yield* failpoint.hit("memory:change:after");
+		return transactionResult.document;
+	});
+	return Context.make(MemoryReader, MemoryReader.fromAdapter({ get })).pipe(Context.add(MemoryWriter, MemoryWriter.fromAdapter({ change })));
+});
+/** SQLite memory ports with the mutation failpoint kept injectable for recovery tests. */
+const memoryStoreLayerWithFailpoints = Layer.effectContext(makeMemoryServices());
+/** SQLite memory reader and writer with the production no-op mutation failpoint. */
+const memoryStoreLayer = memoryStoreLayerWithFailpoints.pipe(Layer.provide(MemoryMutationFailpoint.layer));
+/** Reads an existing memory schema without writes, transactions, or mutation failpoints. */
+const memoryReaderLayer = Layer.effect(MemoryReader, Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const operation = "open memory reader";
+	const tables = yield* query(sql`
+        SELECT name FROM sqlite_master
+        WHERE type = 'table' AND name IN (
+          'effect_agent_memory_metadata', ${DOCUMENT_TABLE}, ${RECEIPT_TABLE}
+        )
+      `, operation).pipe(Effect.flatMap((rows) => decodeRows$2(MemoryTableRow, rows, operation)));
+	if (tables.length !== 3) return yield* storageError(operation, tables.length === 0 ? "unavailable" : "incompatible");
+	const metadata = yield* query(sql`
+        SELECT version FROM effect_agent_memory_metadata WHERE component = ${METADATA_COMPONENT}
+      `, operation).pipe(Effect.flatMap((rows) => decodeRows$2(MemoryMetadataRow, rows, operation)));
+	if (metadata.length !== 1 || metadata[0].version !== STORAGE_VERSION) return yield* storageError(operation, "incompatible");
+	yield* query(sql`
+        SELECT namespace, source_id, format_version, generation, revision, document_json
+        FROM effect_agent_memory_documents_v1 LIMIT 0
+      `, operation);
+	const { get } = yield* makeMemoryReader();
+	return MemoryReader.fromAdapter({ get });
+}));
+//#endregion
 //#region src/sqlite-schedule-store.ts
-const StoredScheduleJson = Schema.String.check(Schema.isMaxLength(16 * 1024 * 1024));
+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,
@@ -3421,7 +3976,7 @@ const makeScheduleStore = Effect.gen(function* () {
 const scheduleStoreLayer = Layer.effect(ScheduleStore)(makeScheduleStore);
 //#endregion
 //#region src/sqlite-subscription-store.ts
-const StoredJson = Schema.String.check(Schema.isMaxLength(16 * 1024 * 1024));
+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({
@@ -3814,7 +4369,8 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
 				return false;
 			}
 			yield* failpoint.hit("subscription:catch-up:before");
-			if (!subscriptionCanSelect(record, accepted, Math.max(nowMillis, yield* Clock.currentTimeMillis), true)) return yield* error("conflict", "catch-up-eligibility");
+			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);
@@ -4004,6 +4560,6 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
 });
 const subscriptionStoreLayer = (partition) => Layer.effect(SubscriptionStore, makeSubscriptionStore(partition));
 //#endregion
-export { CurrentSqliteStorageVersion, SqliteAppendConflict, SqliteCheckpointConflict, SqliteFenceRejected, SqliteLedgerError, SqliteStorageCompatibilityError, SqliteStorageConfig, SqliteStorageConfigValue, SqliteStorageCorruptionError, SqliteStorageError, SqliteStorageFailpoint, SqliteStorageFailpointError, SqliteStorageFailpointLocation, SqliteWriteContention, layer, ledgerLayer, observationOffsetAt, scheduleStoreLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer, subscriptionStoreLayer, threadStoreLayer };
+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