@effect-agent/storage-sqlite 0.1.0-beta.36 → 0.1.0-beta.38

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { AbortCommand, AbortIntent, AdmissionAdmitted, AdmissionConflict, AdmissionNotAdmitted, AdmissionRequest, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecision, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildReservationStatus, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, ConversationCheckpoint, ConversationExport, ConversationExportRequest, ConversationMaterialization, ConversationNotMaterialized, ConversationObservation, ConversationRead, ConversationStore, ConversationStoreError, ConversationTail, ConversationTailRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, Digest, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, ParentLinkage, PersistedJson, ProducerEpoch, QueueSequence, RecordEnvelope, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, Settlement, SettlementConflict, SettlementFinalization, SettlementOutcome, SettlementReservation, SettlementReservationSnapshot, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SuspendRequest, SuspensionReason, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, digestCanonicalBatch, settlementFailureFromRecord, submissionAbortRecordId } from "@effect-agent/session";
-import { Clock, Context, Crypto, DateTime, Duration, Effect, Exit, Layer, Option, Ref, Schema, Stream } from "effect";
+import { AbortCommand, AbortIntent, AdmissionAdmitted, AdmissionConflict, AdmissionNotAdmitted, AdmissionRequest, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecision, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildReservationStatus, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, ConversationCheckpoint, ConversationExport, ConversationExportRequest, ConversationMaterialization, ConversationNotMaterialized, ConversationObservation, ConversationRead, ConversationStore, ConversationStoreError, ConversationTail, ConversationTailRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, Digest, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, ParentLinkage, PersistedJson, ProducerEpoch, QueueSequence, RecordEnvelope, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleId, ScheduleInstant, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, Settlement, SettlementConflict, SettlementFinalization, SettlementOutcome, SettlementReservation, SettlementReservationSnapshot, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SuspendRequest, SuspensionReason, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, applyScheduleChange, defaultSchedulingLimits, digestCanonicalBatch, scheduleDeadline, scheduleUsesCapacity, settlementFailureFromRecord, submissionAbortRecordId } from "@effect-agent/session";
+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";
@@ -130,7 +130,7 @@ var SqliteStorageFailpointError = class extends Schema.TaggedError()("SqliteStor
 };
 //#endregion
 //#region src/migrations.ts
-const CurrentSqliteStorageVersion = 4;
+const CurrentSqliteStorageVersion = 5;
 const sqliteMigrations = SqliteMigrator.fromRecord({
 	"1_current_persistent_conversation_foundation": Effect.gen(function* () {
 		const sql = yield* SqlClient.SqlClient;
@@ -360,9 +360,81 @@ const sqliteMigrations = SqliteMigrator.fromRecord({
       )
     `.withoutTransform;
 		yield* sql`PRAGMA user_version = 4`.withoutTransform;
+	}),
+	"5_durable_schedules": Effect.gen(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		yield* sql`
+      CREATE TABLE effect_agent_schedules (
+        tenant_id TEXT NOT NULL,
+        owner_id TEXT NOT NULL,
+        schedule_id TEXT NOT NULL,
+        deadline_at_millis INTEGER,
+        record_json TEXT NOT NULL,
+        PRIMARY KEY (tenant_id, owner_id, schedule_id)
+      )
+    `.withoutTransform;
+		yield* sql`
+      CREATE INDEX effect_agent_schedules_deadline
+        ON effect_agent_schedules (deadline_at_millis, tenant_id, owner_id, schedule_id)
+        WHERE deadline_at_millis IS NOT NULL
+    `.withoutTransform;
+		yield* sql`
+      CREATE INDEX effect_agent_schedules_owner_deadline
+        ON effect_agent_schedules (tenant_id, owner_id, deadline_at_millis, schedule_id)
+        WHERE deadline_at_millis IS NOT NULL
+    `.withoutTransform;
+		yield* sql`PRAGMA user_version = 5`.withoutTransform;
 	})
 });
 //#endregion
+//#region src/sqlite-storage-config.ts
+const ObservationPollInterval = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const BusyTimeoutMillis = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const OwnershipLeaseMillis = Schema.Int.check(Schema.isGreaterThan(0));
+/**
+* Validated construction configuration consumed by the SQLite storage Layer. The database
+* identity itself belongs to the SqlClient Layer; duplicating it here could silently diverge
+* from the connection actually in use.
+*/
+var SqliteStorageConfigValue = class extends Schema.Class("@effect-agent/storage-sqlite/SqliteStorageConfigValue")({
+	observationPollInterval: ObservationPollInterval,
+	/** Bounded SQLITE_BUSY retry window for write-lock acquisition, in milliseconds. */
+	busyTimeout: BusyTimeoutMillis,
+	/**
+	* Submission ownership lease duration in milliseconds (D5). The lease is a liveness hint
+	* that makes an abandoned claim reclaimable; correctness never depends on it because every
+	* canonical append is fenced by producer epoch. Convenience layers default this to
+	* `DEFAULT_OWNERSHIP_LEASE_DURATION` from `@effect-agent/session`.
+	*/
+	ownershipLeaseDuration: OwnershipLeaseMillis,
+	/**
+	* Re-verify every stored payload and digest chain while opening the store. Per-operation
+	* Schema decoding and the digest chain already fail clearly on corrupt rows, so the full
+	* scan is an explicit opt-in integrity audit rather than a startup requirement.
+	*/
+	verifyOnOpen: Schema.Boolean
+}) {};
+/** Explicit SQLite storage configuration authority. */
+var SqliteStorageConfig = class extends Context.Service()("@effect-agent/storage-sqlite/SqliteStorageConfig") {};
+//#endregion
+//#region src/sqlite-storage-failpoint.ts
+const noFailpoint = () => Effect.void;
+/** Test-only control for replacing the active SQLite failpoint handler. */
+var SqliteStorageFailpointTestControl = class extends Context.Service()("@effect-agent/storage-sqlite/SqliteStorageFailpointTestControl") {};
+/** Explicit fault-injection authority used at SQLite operation boundaries. */
+var SqliteStorageFailpoint = class SqliteStorageFailpoint extends Context.Service()("@effect-agent/storage-sqlite/SqliteStorageFailpoint") {
+	/** Production default: no fault injection. */
+	static layer = Layer.succeed(this)({ hit: noFailpoint });
+	/** Reusable test Layer with a control service backed by the same handler Ref. */
+	static layerTest = Layer.effectContext(Effect.gen(function* () {
+		const handler = yield* Ref.make(noFailpoint);
+		return Context.make(SqliteStorageFailpoint, SqliteStorageFailpoint.of({ hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))) })).pipe(Context.add(SqliteStorageFailpointTestControl, SqliteStorageFailpointTestControl.of({
+			clear: Ref.set(handler, noFailpoint),
+			setHandler: (next) => Ref.set(handler, next)
+		})));
+	}));
+};
+//#endregion
 //#region src/sqlite-journal.ts
 const BoundedStoredText$1 = Schema.String.check(Schema.isMaxLength(16 * 1024 * 1024));
 const BoundedIdentifier$1 = Schema.NonEmptyString.check(Schema.isMaxLength(1024));
@@ -441,40 +513,42 @@ var RawConversationExport = class extends Schema.Class("@effect-agent/storage-sq
 	conversation: ConversationRow,
 	records: Schema.Array(RecordRow)
 }) {};
-const noFailpoint$1 = () => Effect.void;
 const storageError = (operation) => (error) => SqliteStorageError.make({
 	cause: error,
 	operation,
 	message: error.message
 });
 /** Decode raw SQLite rows against a Schema, reporting failures as typed corruption. */
-const decodeRows = Effect.fn("SqliteJournal.decodeRows")((schema, table, rowKey, rows) => Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError((error) => SqliteStorageCorruptionError.make({
+const decodeRows$1 = Effect.fn("SqliteJournal.decodeRows")((schema, table, rowKey, rows) => Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError((error) => SqliteStorageCorruptionError.make({
 	table,
 	rowKey,
 	message: String(error)
 }))));
 /** Decode exactly one raw SQLite row against a Schema, reporting failures as typed corruption. */
-const decodeSingleRow = Effect.fn("SqliteJournal.decodeSingleRow")((schema, table, rowKey, rows) => decodeRows(schema, table, rowKey, rows).pipe(Effect.flatMap((decoded) => decoded.length === 1 ? Effect.succeed(decoded[0]) : Effect.fail(SqliteStorageCorruptionError.make({
+const decodeSingleRow = Effect.fn("SqliteJournal.decodeSingleRow")((schema, table, rowKey, rows) => decodeRows$1(schema, table, rowKey, rows).pipe(Effect.flatMap((decoded) => decoded.length === 1 ? Effect.succeed(decoded[0]) : Effect.fail(SqliteStorageCorruptionError.make({
 	table,
 	rowKey,
 	message: `Expected exactly one row but found ${decoded.length}.`
 })))));
-const ensureCurrentStorage = Effect.fn("SqliteJournal.ensureCurrentStorage")(function* (sql, failpoint = noFailpoint$1, busyTimeoutMillis = 5e3) {
+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 = ${busyTimeoutMillis}`).pipe(Effect.mapError(storageError("configure busy timeout")));
+	yield* sql.unsafe(`PRAGMA busy_timeout = ${busyTimeout}`).pipe(Effect.mapError(storageError("configure busy timeout")));
 	const journalModeRows = yield* sql`PRAGMA journal_mode`.pipe(Effect.mapError(storageError("read journal mode")));
 	const journalMode = yield* decodeSingleRow(Schema.Array(SqliteJournalModeRow), "pragma_journal_mode", "singleton", journalModeRows);
 	if (journalMode.journal_mode.toLowerCase() !== "wal") return yield* SqliteStorageCompatibilityError.make({
 		actualVersion: 0,
-		supportedVersion: 4,
+		supportedVersion: 5,
 		message: `SQLite WAL mode is required; the database reported ${journalMode.journal_mode}.`
 	});
 	const versionRows = yield* sql`PRAGMA user_version`.pipe(Effect.mapError(storageError("read storage version")));
 	const version = yield* decodeSingleRow(Schema.Array(SqliteVersionRow), "pragma_user_version", "singleton", versionRows);
-	if (version.user_version !== 0 && version.user_version !== 4) return yield* SqliteStorageCompatibilityError.make({
+	if (version.user_version !== 0 && version.user_version !== 5) return yield* SqliteStorageCompatibilityError.make({
 		actualVersion: version.user_version,
-		supportedVersion: 4,
-		message: `The SQLite file uses private-development storage version ${version.user_version}; this build supports exactly version 4. Reset the database file explicitly; automatic stored-data migrations are not provided during private development.`
+		supportedVersion: 5,
+		message: `The SQLite file uses private-development storage version ${version.user_version}; this build supports exactly version 5. Reset the database file explicitly; automatic stored-data migrations are not provided during private development.`
 	});
 	if (version.user_version === 0) {
 		const existingRows = yield* sql`
@@ -484,12 +558,12 @@ const ensureCurrentStorage = Effect.fn("SqliteJournal.ensureCurrentStorage")(fun
         AND name LIKE 'effect_agent_%'
       ORDER BY name
     `.pipe(Effect.mapError(storageError("inspect unversioned storage")));
-		if ((yield* decodeRows(Schema.Array(SqliteNameRow), "sqlite_master", "effect_agent_%", existingRows)).length > 0) return yield* SqliteStorageCompatibilityError.make({
+		if ((yield* decodeRows$1(Schema.Array(SqliteNameRow), "sqlite_master", "effect_agent_%", existingRows)).length > 0) return yield* SqliteStorageCompatibilityError.make({
 			actualVersion: 0,
-			supportedVersion: 4,
+			supportedVersion: 5,
 			message: "The SQLite file contains unversioned Effect Agent tables. Reset it explicitly; refusing to mutate ambiguous stored data."
 		});
-		yield* SqliteMigrator.run({ loader: sqliteMigrations }).pipe(Effect.provideService(SqlClient.SqlClient, sql), Effect.mapError((error) => SqliteStorageError.make({
+		yield* SqliteMigrator.run({ loader: sqliteMigrations }).pipe(Effect.mapError((error) => SqliteStorageError.make({
 			cause: error,
 			operation: "initialize current storage",
 			message: error.message
@@ -510,18 +584,16 @@ const ensureCurrentStorage = Effect.fn("SqliteJournal.ensureCurrentStorage")(fun
         'effect_agent_settlement_reservations',
         'effect_agent_abort_intents',
         'effect_agent_approval_decisions',
-        'effect_agent_unknown_resolutions'
+        'effect_agent_unknown_resolutions',
+        'effect_agent_schedules'
       )
     ORDER BY name
   `.pipe(Effect.mapError(storageError("verify storage tables")));
-	if ((yield* decodeRows(Schema.Array(SqliteNameRow), "sqlite_master", "required_tables", requiredRows)).length !== 11) return yield* SqliteStorageCompatibilityError.make({
-		actualVersion: 4,
-		supportedVersion: 4,
+	if ((yield* decodeRows$1(Schema.Array(SqliteNameRow), "sqlite_master", "required_tables", requiredRows)).length !== 12) return yield* SqliteStorageCompatibilityError.make({
+		actualVersion: 5,
+		supportedVersion: 5,
 		message: "The SQLite file claims the current format but is missing required tables. Reset the corrupt private-development data."
 	});
-	return makeJournal(sql, failpoint);
-});
-const makeJournal = (sql, failpoint) => {
 	const classifyWriteFailure = (operation) => (error) => error.reason._tag === "LockTimeoutError" ? SqliteWriteContention.make({
 		cause: error,
 		operation,
@@ -585,7 +657,7 @@ const makeJournal = (sql, failpoint) => {
           FROM effect_agent_conversations
           WHERE conversation_id = ${conversationId}
         `.pipe(Effect.mapError(storageError("read materialized conversation")));
-			const existing = yield* decodeRows(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, existingRows);
+			const existing = yield* decodeRows$1(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, existingRows);
 			if (existing.length > 1) return yield* SqliteStorageCorruptionError.make({
 				table: "effect_agent_conversations",
 				rowKey: conversationId,
@@ -632,7 +704,7 @@ const makeJournal = (sql, failpoint) => {
       FROM effect_agent_conversations
       WHERE conversation_id = ${conversationId}
     `.pipe(Effect.mapError(storageError("read conversation")));
-		return yield* decodeRows(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, rows);
+		return yield* decodeRows$1(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, rows);
 	});
 	const append = Effect.fn("SqliteJournal.append")(function* (request) {
 		if (request.conversationId.length > MAX_IDENTIFIER_LENGTH || request.batchId.length > MAX_IDENTIFIER_LENGTH || storedTextBytes(request.batchJson) > MAX_STORED_TEXT_BYTES || storedTextBytes(request.batchDigest) > MAX_STORED_TEXT_BYTES || storedTextBytes(request.tailDigest) > MAX_STORED_TEXT_BYTES || request.records.some((record) => record.recordId.length > MAX_IDENTIFIER_LENGTH || storedTextBytes(record.recordJson) > MAX_STORED_TEXT_BYTES)) return yield* SqliteStorageError.make({
@@ -674,7 +746,7 @@ const makeJournal = (sql, failpoint) => {
           WHERE conversation_id = ${request.conversationId}
             AND batch_id = ${request.batchId}
         `.pipe(Effect.mapError(storageError("read idempotent batch")));
-			const batches = yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${request.conversationId}/${request.batchId}`, batchRows);
+			const batches = yield* decodeRows$1(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${request.conversationId}/${request.batchId}`, batchRows);
 			if (batches.length > 1) return yield* SqliteStorageCorruptionError.make({
 				table: "effect_agent_canonical_batches",
 				rowKey: `${request.conversationId}/${request.batchId}`,
@@ -715,7 +787,7 @@ const makeJournal = (sql, failpoint) => {
             AND record_id IN ${sql.in(recordIds)}
           ORDER BY sequence
         `.pipe(Effect.mapError(storageError("check canonical record identities")));
-			const existingRecords = yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}/record_ids`, existingRecordRows);
+			const existingRecords = yield* decodeRows$1(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}/record_ids`, existingRecordRows);
 			if (existingRecords.length > 0) return yield* SqliteAppendConflict.make({
 				message: `Canonical record ID ${existingRecords[0].record_id} already exists.`,
 				reason: "record-identity"
@@ -799,7 +871,7 @@ const makeJournal = (sql, failpoint) => {
       ORDER BY sequence
       LIMIT ${request.limit}
     `.pipe(Effect.mapError(storageError("read canonical records")));
-		return yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}>${request.fromSequenceExclusive}`, rows);
+		return yield* decodeRows$1(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}>${request.fromSequenceExclusive}`, rows);
 	});
 	const exportConversation = Effect.fn("SqliteJournal.exportConversation")(function* (conversationId) {
 		return yield* withReadTransaction("export transaction")(Effect.gen(function* () {
@@ -851,9 +923,9 @@ const makeJournal = (sql, failpoint) => {
           `.pipe(Effect.mapError(storageError("export checkpoints")));
 			return RawConversationExport.make({
 				conversation,
-				batches: yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", conversationId, batchRows),
-				records: yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", conversationId, recordRows),
-				checkpoints: yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", conversationId, checkpointRows)
+				batches: yield* decodeRows$1(Schema.Array(BatchRow), "effect_agent_canonical_batches", conversationId, batchRows),
+				records: yield* decodeRows$1(Schema.Array(RecordRow), "effect_agent_canonical_records", conversationId, recordRows),
+				checkpoints: yield* decodeRows$1(Schema.Array(CheckpointRow), "effect_agent_checkpoints", conversationId, checkpointRows)
 			});
 		}));
 	});
@@ -885,7 +957,7 @@ const makeJournal = (sql, failpoint) => {
           WHERE conversation_id = ${checkpoint.conversationId}
             AND through_sequence = ${checkpoint.throughSequence}
         `.pipe(Effect.mapError(storageError("read idempotent checkpoint")));
-			const existing = yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${checkpoint.conversationId}/${checkpoint.throughSequence}`, checkpointRows);
+			const existing = yield* decodeRows$1(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${checkpoint.conversationId}/${checkpoint.throughSequence}`, checkpointRows);
 			if (existing.length > 1) return yield* SqliteStorageCorruptionError.make({
 				table: "effect_agent_checkpoints",
 				rowKey: `${checkpoint.conversationId}/${checkpoint.throughSequence}`,
@@ -923,7 +995,7 @@ const makeJournal = (sql, failpoint) => {
       ORDER BY through_sequence DESC
       LIMIT 1
     `.pipe(Effect.mapError(storageError("load checkpoint")));
-		return yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${conversationId}<=${atOrBeforeSequence}`, rows);
+		return yield* decodeRows$1(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${conversationId}<=${atOrBeforeSequence}`, rows);
 	});
 	return {
 		append,
@@ -947,7 +1019,7 @@ const makeJournal = (sql, failpoint) => {
       WHERE conversation_id = ${conversationId}
         AND last_sequence = ${sequence}
     `.pipe(Effect.mapError(storageError("read canonical digest at sequence")));
-			return (yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${conversationId}/${sequence}`, rows)).map((batch) => batch.tail_digest);
+			return (yield* decodeRows$1(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${conversationId}/${sequence}`, rows)).map((batch) => batch.tail_digest);
 		}),
 		loadCheckpoint,
 		materialize,
@@ -997,65 +1069,16 @@ const makeJournal = (sql, failpoint) => {
             ORDER BY conversation_id, through_sequence
           `.pipe(Effect.mapError(storageError("scan checkpoints")));
 				return {
-					conversations: yield* decodeRows(Schema.Array(ConversationRow), "effect_agent_conversations", "startup_scan", conversations),
-					batches: yield* decodeRows(Schema.Array(BatchRow), "effect_agent_canonical_batches", "startup_scan", batches),
-					records: yield* decodeRows(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
-					checkpoints: yield* decodeRows(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
+					conversations: yield* decodeRows$1(Schema.Array(ConversationRow), "effect_agent_conversations", "startup_scan", conversations),
+					batches: yield* decodeRows$1(Schema.Array(BatchRow), "effect_agent_canonical_batches", "startup_scan", batches),
+					records: yield* decodeRows$1(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
+					checkpoints: yield* decodeRows$1(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
 				};
 			}));
 		}),
 		withWriteTransaction
 	};
-};
-const initializeSqliteJournal = ensureCurrentStorage;
-//#endregion
-//#region src/sqlite-storage-config.ts
-const ObservationPollInterval = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-const BusyTimeoutMillis = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-const OwnershipLeaseMillis = Schema.Int.check(Schema.isGreaterThan(0));
-/**
-* Validated construction configuration consumed by the SQLite storage Layer. The database
-* identity itself belongs to the SqlClient Layer; duplicating it here could silently diverge
-* from the connection actually in use.
-*/
-var SqliteStorageConfigValue = class extends Schema.Class("@effect-agent/storage-sqlite/SqliteStorageConfigValue")({
-	observationPollInterval: ObservationPollInterval,
-	/** Bounded SQLITE_BUSY retry window for write-lock acquisition, in milliseconds. */
-	busyTimeout: BusyTimeoutMillis,
-	/**
-	* Submission ownership lease duration in milliseconds (D5). The lease is a liveness hint
-	* that makes an abandoned claim reclaimable; correctness never depends on it because every
-	* canonical append is fenced by producer epoch. Convenience layers default this to
-	* `DEFAULT_OWNERSHIP_LEASE_DURATION` from `@effect-agent/session`.
-	*/
-	ownershipLeaseDuration: OwnershipLeaseMillis,
-	/**
-	* Re-verify every stored payload and digest chain while opening the store. Per-operation
-	* Schema decoding and the digest chain already fail clearly on corrupt rows, so the full
-	* scan is an explicit opt-in integrity audit rather than a startup requirement.
-	*/
-	verifyOnOpen: Schema.Boolean
-}) {};
-/** Explicit SQLite storage configuration authority. */
-var SqliteStorageConfig = class extends Context.Service()("@effect-agent/storage-sqlite/SqliteStorageConfig") {};
-//#endregion
-//#region src/sqlite-storage-failpoint.ts
-const noFailpoint = () => Effect.void;
-/** Test-only control for replacing the active SQLite failpoint handler. */
-var SqliteStorageFailpointTestControl = class extends Context.Service()("@effect-agent/storage-sqlite/SqliteStorageFailpointTestControl") {};
-/** Explicit fault-injection authority used at SQLite operation boundaries. */
-var SqliteStorageFailpoint = class SqliteStorageFailpoint extends Context.Service()("@effect-agent/storage-sqlite/SqliteStorageFailpoint") {
-	/** Production default: no fault injection. */
-	static layer = Layer.succeed(this)({ hit: noFailpoint });
-	/** Reusable test Layer with a control service backed by the same handler Ref. */
-	static layerTest = Layer.effectContext(Effect.gen(function* () {
-		const handler = yield* Ref.make(noFailpoint);
-		return Context.make(SqliteStorageFailpoint, SqliteStorageFailpoint.of({ hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))) })).pipe(Context.add(SqliteStorageFailpointTestControl, SqliteStorageFailpointTestControl.of({
-			clear: Ref.set(handler, noFailpoint),
-			setHandler: (next) => Ref.set(handler, next)
-		})));
-	}));
-};
+});
 //#endregion
 //#region src/sqlite-conversation-store.ts
 const OffsetText = Schema.String.check(Schema.isMaxLength(4 * 1024));
@@ -1258,9 +1281,8 @@ const decodeStartupPayloads = Effect.fn("SqliteConversationStore.decodeStartupPa
 const makeServices$1 = Effect.fn("SqliteConversationStore.makeServices")(function* () {
 	const config = yield* SqliteStorageConfig;
 	const failpoint = yield* SqliteStorageFailpoint;
-	const sql = yield* SqlClient.SqlClient;
 	const crypto = yield* Crypto.Crypto;
-	const journal = yield* initializeSqliteJournal(sql, failpoint.hit, config.busyTimeout);
+	const journal = yield* initializeSqliteJournal();
 	if (config.verifyOnOpen) yield* decodeStartupPayloads(journal, crypto);
 	const provideCrypto = (effect) => Effect.provideService(effect, Crypto.Crypto, crypto);
 	const hitFailpoint = Effect.fn("SqliteConversationStore.hitFailpoint")((location) => failpoint.hit(location).pipe(Effect.mapError((error) => storeError(`storage failpoint ${location}`, error))));
@@ -1654,7 +1676,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 	const failpoint = yield* SqliteStorageFailpoint;
 	const sql = yield* SqlClient.SqlClient;
 	const crypto = yield* Crypto.Crypto;
-	const journal = yield* initializeSqliteJournal(sql, failpoint.hit, config.busyTimeout);
+	const journal = yield* initializeSqliteJournal();
 	const hitFailpoint = (location, operation) => failpoint.hit(location).pipe(Effect.mapError((error) => internalFailure(operation)(error)));
 	/**
 	* Run one ledger mutation under the journal's `BEGIN IMMEDIATE` write transaction so
@@ -1669,7 +1691,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(Schema.Array(SubmissionRow), "effect_agent_submissions", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
+	const decodeSubmissionRows = (operation, rowKey, rows) => decodeRows$1(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)}
@@ -1700,7 +1722,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(Schema.Array(OwnershipRow), "effect_agent_submission_ownership", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows$1(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]);
 	});
@@ -1765,7 +1787,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(Schema.Array(ReservationRow), "effect_agent_settlement_reservations", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows$1(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]);
 	});
@@ -1780,11 +1802,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(Schema.Array(AbortIntentRow), "effect_agent_abort_intents", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows$1(Schema.Array(AbortIntentRow), "effect_agent_abort_intents", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_abort_intents", submissionId, "An abort intent primary key returned more than one row.");
 		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
 	});
-	const decodeChildReservationRows = (operation, rowKey, rows) => decodeRows(Schema.Array(ChildReservationRow), "effect_agent_child_reservations", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
+	const decodeChildReservationRows = (operation, rowKey, rows) => decodeRows$1(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)}
@@ -1837,7 +1859,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(Schema.Array(ApprovalDecisionRow), "effect_agent_approval_decisions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		return yield* decodeRows$1(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({
@@ -1862,7 +1884,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(Schema.Array(UnknownResolutionRow), "effect_agent_unknown_resolutions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		return yield* decodeRows$1(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)));
@@ -1893,7 +1915,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         WHERE conversation_id = ${conversationId}
           AND record_id = ${recordId}
       `.pipe(Effect.mapError(sqlFailure(operation)));
-		return (yield* decodeRows(Schema.Array(CanonicalRecordIdRow), "effect_agent_canonical_records", `${conversationId}/${recordId}`, rows).pipe(Effect.mapError(internalFailure(operation)))).length === 0 ? void 0 : recordId;
+		return (yield* decodeRows$1(Schema.Array(CanonicalRecordIdRow), "effect_agent_canonical_records", `${conversationId}/${recordId}`, rows).pipe(Effect.mapError(internalFailure(operation)))).length === 0 ? void 0 : recordId;
 	});
 	const abortIntentFromRow = Effect.fn("SqliteSubmissionLedger.abortIntentFromRow")(function* (operation, submission, submissionId, row) {
 		const canonicalRecordId = yield* canonicalAbortRecordId(operation, submission.conversation_id, submissionId);
@@ -1947,7 +1969,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             FROM effect_agent_submissions
             WHERE conversation_id = ${validated.conversationId}
           `.pipe(Effect.mapError(sqlFailure(operation)));
-			const decodedMax = yield* decodeRows(Schema.Array(MaxQueueSequenceRow), "effect_agent_submissions", validated.conversationId, maxRows).pipe(Effect.mapError(internalFailure(operation)));
+			const decodedMax = yield* decodeRows$1(Schema.Array(MaxQueueSequenceRow), "effect_agent_submissions", validated.conversationId, maxRows).pipe(Effect.mapError(internalFailure(operation)));
 			const queueSequence = yield* decodeQueueSequence((decodedMax[0]?.max_queue_sequence ?? 0) + 1).pipe(Effect.mapError(internalFailure(operation)));
 			const now = yield* currentInstant;
 			yield* sql`
@@ -3094,6 +3116,251 @@ 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
-export { CurrentSqliteStorageVersion, SqliteAppendConflict, SqliteCheckpointConflict, SqliteFenceRejected, SqliteLedgerError, SqliteStorageCompatibilityError, SqliteStorageConfig, SqliteStorageConfigValue, SqliteStorageCorruptionError, SqliteStorageError, SqliteStorageFailpoint, SqliteStorageFailpointError, SqliteStorageFailpointLocation, SqliteStorageFailpointTestControl, SqliteWriteContention, conversationStoreLayer, layer, ledgerLayer, observationOffsetAt, sqliteMigrations, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer };
+//#region src/sqlite-schedule-store.ts
+const StoredScheduleJson = Schema.String.check(Schema.isMaxLength(16 * 1024 * 1024));
+const StoredDeadline = Schema.NullOr(ScheduleInstant);
+var ScheduleRow = class extends Schema.Class("@effect-agent/storage-sqlite/ScheduleRow")({
+	tenant_id: ScheduleOwner.fields.tenantId,
+	owner_id: ScheduleOwner.fields.ownerId,
+	schedule_id: ScheduleId,
+	deadline_at_millis: StoredDeadline,
+	record_json: StoredScheduleJson
+}) {};
+const ScheduleDueRow = Schema.Struct({
+	tenant_id: ScheduleOwner.fields.tenantId,
+	owner_id: ScheduleOwner.fields.ownerId,
+	schedule_id: ScheduleId,
+	deadline_at_millis: ScheduleInstant
+});
+var ScheduleCountRow = class extends Schema.Class("@effect-agent/storage-sqlite/ScheduleCountRow")({ schedule_count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) }) {};
+var ScheduleDeadlineRow = class extends Schema.Class("@effect-agent/storage-sqlite/ScheduleDeadlineRow")({ deadline_at_millis: StoredDeadline }) {};
+const unavailable = (operation) => ScheduleStorageError.make({
+	operation,
+	reason: "unavailable"
+});
+const corrupt = (operation) => ScheduleStorageError.make({
+	operation,
+	reason: "corrupt"
+});
+const decodeRows = Effect.fn("SqliteScheduleStore.decodeRows")(function* (schema, rows, operation) {
+	return yield* Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError(() => corrupt(operation)));
+});
+const decodeRecord = Effect.fn("SqliteScheduleStore.decodeRecord")(function* (row) {
+	const record = yield* Schema.decodeEffect(Schema.fromJsonString(ScheduleRecord))(row.record_json).pipe(Effect.mapError(() => corrupt("decode schedule")));
+	if (record.owner.tenantId !== row.tenant_id || record.owner.ownerId !== row.owner_id || record.scheduleId !== row.schedule_id || scheduleDeadline(record) !== row.deadline_at_millis) return yield* corrupt("decode schedule identity");
+	return record;
+});
+const encodeRecord = Effect.fn("SqliteScheduleStore.encodeRecord")(function* (record) {
+	return yield* Schema.encodeEffect(Schema.fromJsonString(ScheduleRecord))(record).pipe(Effect.mapError(() => corrupt("encode schedule")));
+});
+const decodeInput = Effect.fn("SqliteScheduleStore.decodeInput")(function* (operation, schema, value) {
+	return yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => corrupt(operation)));
+});
+const makeScheduleStore = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const scheduleFailpoint = yield* ScheduleFailpoint;
+	yield* initializeSqliteJournal();
+	const readRows = Effect.fn("SqliteScheduleStore.readRows")(function* (key, operation) {
+		const rows = yield* sql`
+      SELECT tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
+      FROM effect_agent_schedules
+      WHERE tenant_id = ${key.owner.tenantId}
+        AND owner_id = ${key.owner.ownerId}
+        AND schedule_id = ${key.scheduleId}
+    `.pipe(Effect.mapError(() => unavailable(operation)));
+		return yield* decodeRows(Schema.Array(ScheduleRow), rows, operation);
+	});
+	const readOne = Effect.fn("SqliteScheduleStore.readOne")(function* (key, operation) {
+		const rows = yield* readRows(key, operation);
+		if (rows.length === 0) return null;
+		if (rows.length !== 1) return yield* corrupt(operation);
+		return yield* decodeRecord(rows[0]);
+	});
+	const insert = Effect.fn("SqliteScheduleStore.insert")(function* (record, ownerLimit) {
+		const operation = "insert schedule";
+		const canonical = yield* decodeInput(operation, ScheduleRecord, record);
+		const recordJson = yield* encodeRecord(canonical);
+		const result = yield* sql.withTransaction(Effect.gen(function* () {
+			const existing = yield* readOne(canonical, operation);
+			if (existing !== null) {
+				if (existing.creationFingerprint === canonical.creationFingerprint) return {
+					record: existing,
+					inserted: false
+				};
+				return yield* ScheduleConflict.make({
+					reason: "creation",
+					key: {
+						owner: canonical.owner,
+						scheduleId: canonical.scheduleId
+					}
+				});
+			}
+			const rawCounts = yield* sql`
+            SELECT COUNT(*) AS schedule_count
+            FROM effect_agent_schedules
+            WHERE tenant_id = ${canonical.owner.tenantId}
+              AND owner_id = ${canonical.owner.ownerId}
+              AND (json_extract(record_json, '$.pending') IS NOT NULL OR
+                (json_extract(record_json, '$.state') != 'cancelled' AND json_extract(record_json, '$.nextAtMillis') IS NOT NULL))
+          `.pipe(Effect.mapError(() => unavailable(operation)));
+			const counts = yield* decodeRows(Schema.Array(ScheduleCountRow), rawCounts, operation);
+			if (counts.length !== 1) return yield* corrupt(operation);
+			if (counts[0].schedule_count >= ownerLimit) return yield* ScheduleCapacityError.make({ limit: ownerLimit });
+			yield* scheduleFailpoint.hit("schedule:insert:before");
+			yield* sql`
+            INSERT INTO effect_agent_schedules (
+              tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
+            ) VALUES (
+              ${canonical.owner.tenantId},
+              ${canonical.owner.ownerId},
+              ${canonical.scheduleId},
+              ${scheduleDeadline(canonical)},
+              ${recordJson}
+            )
+          `.pipe(Effect.mapError(() => unavailable(operation)));
+			return {
+				record: canonical,
+				inserted: true
+			};
+		})).pipe(Effect.catchTag("SqlError", () => Effect.fail(unavailable(operation))));
+		if (result.inserted) yield* scheduleFailpoint.hit("schedule:insert:after");
+		return result.record;
+	});
+	const get = Effect.fn("SqliteScheduleStore.get")(function* (key) {
+		const decodedKey = yield* decodeInput("get schedule", ScheduleKey, key);
+		return yield* readOne(decodedKey, "get schedule");
+	});
+	const list = Effect.fn("SqliteScheduleStore.list")(function* (request) {
+		const operation = "list schedules";
+		const decodedRequest = yield* decodeInput(operation, SchedulePageRequest, request);
+		const rows = decodedRequest.after === void 0 ? yield* sql`
+            SELECT tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
+            FROM effect_agent_schedules
+            WHERE tenant_id = ${decodedRequest.owner.tenantId}
+              AND owner_id = ${decodedRequest.owner.ownerId}
+            ORDER BY schedule_id
+            LIMIT ${decodedRequest.limit + 1}
+          `.pipe(Effect.mapError(() => unavailable(operation))) : yield* sql`
+            SELECT tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
+            FROM effect_agent_schedules
+            WHERE tenant_id = ${decodedRequest.owner.tenantId}
+              AND owner_id = ${decodedRequest.owner.ownerId}
+              AND schedule_id > ${decodedRequest.after}
+            ORDER BY schedule_id
+            LIMIT ${decodedRequest.limit + 1}
+          `.pipe(Effect.mapError(() => unavailable(operation)));
+		const decoded = yield* decodeRows(Schema.Array(ScheduleRow), rows, operation);
+		const records = yield* Effect.forEach(decoded, decodeRecord);
+		const hasNext = records.length > decodedRequest.limit;
+		const items = hasNext ? records.slice(0, decodedRequest.limit) : records;
+		return {
+			items,
+			next: hasNext ? items.at(-1)?.scheduleId ?? null : null
+		};
+	});
+	const change = Effect.fn("SqliteScheduleStore.change")(function* (key, change, ownerLimit = defaultSchedulingLimits.maxSchedulesPerOwner) {
+		const operation = "change schedule";
+		const decodedKey = yield* decodeInput(operation, ScheduleKey, key);
+		const decodedChange = yield* decodeInput(operation, ScheduleChange, change);
+		const result = yield* sql.withTransaction(Effect.gen(function* () {
+			const current = yield* readOne(decodedKey, operation);
+			if (current === null) return yield* ScheduleNotFound.make({ key: decodedKey });
+			const transition = applyScheduleChange(current, decodedChange);
+			if (Result.isFailure(transition)) return yield* transition.failure;
+			const next = transition.success;
+			if (!scheduleUsesCapacity(current) && scheduleUsesCapacity(next)) {
+				const rawCounts = yield* sql`
+              SELECT COUNT(*) AS schedule_count FROM effect_agent_schedules
+              WHERE tenant_id = ${key.owner.tenantId} AND owner_id = ${key.owner.ownerId}
+                AND (json_extract(record_json, '$.pending') IS NOT NULL OR
+                  (json_extract(record_json, '$.state') != 'cancelled' AND json_extract(record_json, '$.nextAtMillis') IS NOT NULL))
+            `.pipe(Effect.mapError(() => unavailable(operation)));
+				const counts = yield* decodeRows(Schema.Array(ScheduleCountRow), rawCounts, operation);
+				if (counts.length !== 1) return yield* corrupt(operation);
+				if (counts[0].schedule_count >= ownerLimit) return yield* ScheduleCapacityError.make({ limit: ownerLimit });
+			}
+			if (next === current) return {
+				record: current,
+				changed: false
+			};
+			const recordJson = yield* encodeRecord(next);
+			yield* scheduleFailpoint.hit(`schedule:${decodedChange._tag.toLowerCase()}:before`);
+			yield* sql`
+            UPDATE effect_agent_schedules
+            SET deadline_at_millis = ${scheduleDeadline(next)}, record_json = ${recordJson}
+            WHERE tenant_id = ${decodedKey.owner.tenantId}
+              AND owner_id = ${decodedKey.owner.ownerId}
+              AND schedule_id = ${decodedKey.scheduleId}
+          `.pipe(Effect.mapError(() => unavailable(operation)));
+			return {
+				record: next,
+				changed: true
+			};
+		})).pipe(Effect.catchTag("SqlError", () => Effect.fail(unavailable(operation))));
+		if (result.changed) yield* scheduleFailpoint.hit(`schedule:${decodedChange._tag.toLowerCase()}:after`);
+		return result.record;
+	});
+	const due = Effect.fn("SqliteScheduleStore.due")(function* (nowMillis, limit, owner, after) {
+		const operation = "query due schedules";
+		const decodedOwner = owner === void 0 ? void 0 : yield* decodeInput(operation, ScheduleOwner, owner);
+		const cursor = after === void 0 ? void 0 : yield* Schema.decodeUnknownEffect(ScheduleDueCursor)(after).pipe(Effect.mapError(() => corrupt(operation)));
+		const continuation = cursor === void 0 ? sql`1 = 1` : sql`
+      (deadline_at_millis, tenant_id, owner_id, schedule_id) >
+      (${cursor.deadlineAtMillis}, ${cursor.owner.tenantId}, ${cursor.owner.ownerId}, ${cursor.scheduleId})`;
+		const rows = decodedOwner === void 0 ? yield* sql`
+            SELECT tenant_id, owner_id, schedule_id, deadline_at_millis
+            FROM effect_agent_schedules
+            WHERE deadline_at_millis <= ${nowMillis} AND ${continuation}
+            ORDER BY deadline_at_millis, tenant_id, owner_id, schedule_id
+            LIMIT ${limit}
+          `.pipe(Effect.mapError(() => unavailable(operation))) : yield* sql`
+            SELECT tenant_id, owner_id, schedule_id, deadline_at_millis
+            FROM effect_agent_schedules
+            WHERE tenant_id = ${decodedOwner.tenantId}
+              AND owner_id = ${decodedOwner.ownerId}
+              AND deadline_at_millis <= ${nowMillis} AND ${continuation}
+            ORDER BY deadline_at_millis, schedule_id
+            LIMIT ${limit}
+          `.pipe(Effect.mapError(() => unavailable(operation)));
+		return (yield* decodeRows(Schema.Array(ScheduleDueRow), rows, operation)).map((row) => ({
+			owner: {
+				tenantId: row.tenant_id,
+				ownerId: row.owner_id
+			},
+			scheduleId: row.schedule_id,
+			deadlineAtMillis: row.deadline_at_millis
+		}));
+	});
+	const nextDeadline = Effect.fn("SqliteScheduleStore.nextDeadline")(function* (owner) {
+		const operation = "query next schedule deadline";
+		const decodedOwner = owner === void 0 ? void 0 : yield* decodeInput(operation, ScheduleOwner, owner);
+		const rows = decodedOwner === void 0 ? yield* sql`
+          SELECT MIN(deadline_at_millis) AS deadline_at_millis
+          FROM effect_agent_schedules
+          WHERE deadline_at_millis IS NOT NULL
+        `.pipe(Effect.mapError(() => unavailable(operation))) : yield* sql`
+          SELECT MIN(deadline_at_millis) AS deadline_at_millis
+          FROM effect_agent_schedules
+          WHERE tenant_id = ${decodedOwner.tenantId}
+            AND owner_id = ${decodedOwner.ownerId}
+            AND deadline_at_millis IS NOT NULL
+        `.pipe(Effect.mapError(() => unavailable(operation)));
+		const decoded = yield* decodeRows(Schema.Array(ScheduleDeadlineRow), rows, operation);
+		if (decoded.length !== 1) return yield* corrupt(operation);
+		return decoded[0].deadline_at_millis;
+	});
+	return ScheduleStore.of({
+		insert,
+		get,
+		list,
+		change,
+		due,
+		nextDeadline
+	});
+});
+/** SQLite implementation of the atomic ScheduleStore port. */
+const scheduleStoreLayer = Layer.effect(ScheduleStore)(makeScheduleStore);
+//#endregion
+export { CurrentSqliteStorageVersion, SqliteAppendConflict, SqliteCheckpointConflict, SqliteFenceRejected, SqliteLedgerError, SqliteStorageCompatibilityError, SqliteStorageConfig, SqliteStorageConfigValue, SqliteStorageCorruptionError, SqliteStorageError, SqliteStorageFailpoint, SqliteStorageFailpointError, SqliteStorageFailpointLocation, SqliteStorageFailpointTestControl, SqliteWriteContention, conversationStoreLayer, layer, ledgerLayer, observationOffsetAt, scheduleStoreLayer, sqliteMigrations, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer };
 
 //# sourceMappingURL=index.mjs.map