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

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 { 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", {
@@ -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;
+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));
@@ -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 }) {};
@@ -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;
@@ -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") {
@@ -3176,7 +3431,7 @@ 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-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 +3676,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 +4069,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 +4260,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