@yielded/agent-storage-cloudflare 0.1.0-beta.173 → 0.1.0-beta.175

package/dist/DoMemoryStore.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { r as ownedState } from "./owned-state-BHzUi0eb.mjs";
+import { r as ownedState } from "./owned-state-B4QhezMp.mjs";
 import { SqlMemoryLimits, SqlStorageOwner, memoryStoreLayerWithFailpoints } from "@yielded/agent/sql-memory-store";
 import { Effect, Layer, Schema } from "effect";
 import * as SqlClientService from "effect/sql/SqlClient";

package/dist/DoMessageDeliveryStore.mjs

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { DoStorageConfig } from "./DoStorageConfig.mjs";
 import { DoStorageFailpoint } from "./DoStorageFailpoint.mjs";
-import { i as initializeDoJournal } from "./do-journal-_MdLGTd3.mjs";
+import { i as initializeDoJournal } from "./do-journal-7P3DUBz0.mjs";
 import { BrowserCrypto } from "@effect/platform-browser";
 import { SqlLifecycleSource } from "@yielded/agent-storage-sql/sql-lifecycle-publication";
 import { makeSqlMessageDeliveryStore } from "@yielded/agent-storage-sql/sql-message-delivery-store";

package/dist/DoStorageFailpoint.d.mts

@@ -1,9 +1,11 @@
 import { c as DoStorageFailpointError, l as DoStorageFailpointLocation } from "./DoStorageError-CxjMnzUA.mjs";
 import { Context, Effect, Layer } from "effect";
 declare namespace DoStorageFailpoint_d_exports {
-  export { DoStorageFailpoint, DoStorageFailpointHandler };
+  export { DoStorageFailpoint, DoStorageFailpointHandler, isDefaultDoStorageFailpoint };
 }
 export type DoStorageFailpointHandler = (location: DoStorageFailpointLocation) => Effect.Effect<void, DoStorageFailpointError>;
+/** @internal Select a plain native body only for the library's no-op handler. */
+export declare const isDefaultDoStorageFailpoint: (handler: DoStorageFailpointHandler) => boolean;
 declare const DoStorageFailpoint_base: Context.ServiceClass<DoStorageFailpoint, "@effect-agent/storage-cloudflare/DoStorageFailpoint", {
   readonly hit: DoStorageFailpointHandler;
 }>;

package/dist/DoStorageFailpoint.mjs

@@ -1,14 +1,19 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { Context, Effect, Layer } from "effect";
 //#region src/DoStorageFailpoint.ts
-var DoStorageFailpoint_exports = /* @__PURE__ */ __exportAll({ DoStorageFailpoint: () => DoStorageFailpoint });
+var DoStorageFailpoint_exports = /* @__PURE__ */ __exportAll({
+	DoStorageFailpoint: () => DoStorageFailpoint,
+	isDefaultDoStorageFailpoint: () => isDefaultDoStorageFailpoint
+});
 const noFailpoint = () => Effect.void;
+/** @internal Select a plain native body only for the library's no-op handler. */
+const isDefaultDoStorageFailpoint = (handler) => handler === noFailpoint;
 /** Explicit fault-injection authority used at Durable Object storage operation boundaries. */
 var DoStorageFailpoint = class extends Context.Service()("@effect-agent/storage-cloudflare/DoStorageFailpoint") {
 	/** Production default: no fault injection. */
 	static layer = Layer.succeed(this)({ hit: noFailpoint });
 };
 //#endregion
-export { DoStorageFailpoint, DoStorageFailpoint_exports as t };
+export { DoStorageFailpoint, isDefaultDoStorageFailpoint, DoStorageFailpoint_exports as t };
 
 //# sourceMappingURL=DoStorageFailpoint.mjs.map

package/dist/DoStorageFailpoint.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"DoStorageFailpoint.mjs","names":[],"sources":["../src/DoStorageFailpoint.ts"],"sourcesContent":["import { Context, Effect, Layer } from \"effect\";\n\nimport type { DoStorageFailpointError, DoStorageFailpointLocation } from \"./DoStorageError.ts\";\n\nexport type DoStorageFailpointHandler = (\n  location: DoStorageFailpointLocation,\n) => Effect.Effect<void, DoStorageFailpointError>;\n\nconst noFailpoint: DoStorageFailpointHandler = () => Effect.void;\n\n/** Explicit fault-injection authority used at Durable Object storage operation boundaries. */\nexport class DoStorageFailpoint extends Context.Service<\n  DoStorageFailpoint,\n  {\n    readonly hit: DoStorageFailpointHandler;\n  }\n>()(\"@effect-agent/storage-cloudflare/DoStorageFailpoint\") {\n  /** Production default: no fault injection. */\n  static readonly layer = Layer.succeed(this)({ hit: noFailpoint });\n}\n"],"mappings":";;;;AAQA,MAAM,oBAA+C,OAAO;;AAG5D,IAAa,qBAAb,cAAwC,QAAQ,QAK9C,CAAC,CAAC,qDAAqD,CAAC,CAAC;;CAEzD,OAAgB,QAAQ,MAAM,QAAQ,IAAI,CAAC,CAAC,EAAE,KAAK,YAAY,CAAC;AAClE"}
+{"version":3,"file":"DoStorageFailpoint.mjs","names":[],"sources":["../src/DoStorageFailpoint.ts"],"sourcesContent":["import { Context, Effect, Layer } from \"effect\";\n\nimport type { DoStorageFailpointError, DoStorageFailpointLocation } from \"./DoStorageError.ts\";\n\nexport type DoStorageFailpointHandler = (\n  location: DoStorageFailpointLocation,\n) => Effect.Effect<void, DoStorageFailpointError>;\n\nconst noFailpoint: DoStorageFailpointHandler = () => Effect.void;\n\n/** @internal Select a plain native body only for the library's no-op handler. */\nexport const isDefaultDoStorageFailpoint = (handler: DoStorageFailpointHandler): boolean =>\n  handler === noFailpoint;\n\n/** Explicit fault-injection authority used at Durable Object storage operation boundaries. */\nexport class DoStorageFailpoint extends Context.Service<\n  DoStorageFailpoint,\n  {\n    readonly hit: DoStorageFailpointHandler;\n  }\n>()(\"@effect-agent/storage-cloudflare/DoStorageFailpoint\") {\n  /** Production default: no fault injection. */\n  static readonly layer = Layer.succeed(this)({ hit: noFailpoint });\n}\n"],"mappings":";;;;;;;AAQA,MAAM,oBAA+C,OAAO;;AAG5D,MAAa,+BAA+B,YAC1C,YAAY;;AAGd,IAAa,qBAAb,cAAwC,QAAQ,QAK9C,CAAC,CAAC,qDAAqD,CAAC,CAAC;;CAEzD,OAAgB,QAAQ,MAAM,QAAQ,IAAI,CAAC,CAAC,EAAE,KAAK,YAAY,CAAC;AAClE"}

package/dist/DoStorageFailpointTesting.mjs

@@ -12,10 +12,7 @@ import { Effect } from "effect";
 * The handles stay injected: this package never imports `cloudflare:workers`, so the harness
 * that owns a `DurableObjectState` supplies the thunk.
 */
-const evictionFailpointHandler = (options) => (location) => options.isArmed(location).pipe(Effect.flatMap((armed) => armed ? Effect.sync(() => {
-	options.evict(location);
-	throw new Error(`Durable Object eviction did not interrupt execution at ${location}.`);
-}) : Effect.void));
+const evictionFailpointHandler = (options) => (location) => options.isArmed(location).pipe(Effect.flatMap((armed) => armed ? Effect.sync(() => options.evict(location)).pipe(Effect.andThen(Effect.die(/* @__PURE__ */ new Error(`Durable Object eviction did not interrupt execution at ${location}.`)))) : Effect.void));
 //#endregion
 export { evictionFailpointHandler };
 

package/dist/DoStorageFailpointTesting.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"DoStorageFailpointTesting.mjs","names":[],"sources":["../src/DoStorageFailpointTesting.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport type { DoStorageFailpointLocation } from \"./DoStorageError.ts\";\nimport type { DoStorageFailpointHandler } from \"./DoStorageFailpoint.ts\";\n\n/**\n * The DC-specific eviction failpoint mode: instead of failing typed, an armed hit evicts the\n * Durable Object through an injected `evict` thunk — in production-shaped harnesses that thunk\n * is `() => ctx.abort()`, the platform's real failure mode. `ctx.abort()` never returns (it\n * throws while destroying the in-memory instance and every in-flight implicit or explicit\n * storage transaction rolls back), so an armed hit ends the current Attempt exactly like an\n * unannounced platform eviction; DO storage — the only correctness-critical state — survives\n * for the next incarnation, which the persisted alarm wakes without any incoming request.\n *\n * The handles stay injected: this package never imports `cloudflare:workers`, so the harness\n * that owns a `DurableObjectState` supplies the thunk.\n */\nexport const evictionFailpointHandler =\n  (options: {\n    readonly isArmed: (location: DoStorageFailpointLocation) => Effect.Effect<boolean>;\n    /** Kills the incarnation — e.g. `() => ctx.abort()`. Typed `void` because the platform\n     * declares `abort` as returning, but it throws while destroying the instance. */\n    readonly evict: (location: DoStorageFailpointLocation) => void;\n  }): DoStorageFailpointHandler =>\n  (location) =>\n    options.isArmed(location).pipe(\n      Effect.flatMap((armed) =>\n        armed\n          ? // `ctx.abort()` throws while destroying the instance; that throw surfaces as a\n            // defect in the (already dying) incarnation. The defensive throw below keeps the\n            // guarantee — nothing after an armed hit may observe in-memory state — even if a\n            // harness supplies an evict thunk that returns.\n            Effect.sync((): never => {\n              options.evict(location);\n              throw new Error(\n                `Durable Object eviction did not interrupt execution at ${location}.`,\n              );\n            })\n          : Effect.void,\n      ),\n    );\n"],"mappings":";;;;;;;;;;;;;;AAiBA,MAAa,4BACV,aAMA,aACC,QAAQ,QAAQ,QAAQ,CAAC,CAAC,KACxB,OAAO,SAAS,UACd,QAKI,OAAO,WAAkB;CACvB,QAAQ,MAAM,QAAQ;CACtB,MAAM,IAAI,MACR,0DAA0D,SAAS,EACrE;AACF,CAAC,IACD,OAAO,IACb,CACF"}
+{"version":3,"file":"DoStorageFailpointTesting.mjs","names":[],"sources":["../src/DoStorageFailpointTesting.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport type { DoStorageFailpointLocation } from \"./DoStorageError.ts\";\nimport type { DoStorageFailpointHandler } from \"./DoStorageFailpoint.ts\";\n\n/**\n * The DC-specific eviction failpoint mode: instead of failing typed, an armed hit evicts the\n * Durable Object through an injected `evict` thunk — in production-shaped harnesses that thunk\n * is `() => ctx.abort()`, the platform's real failure mode. `ctx.abort()` never returns (it\n * throws while destroying the in-memory instance and every in-flight implicit or explicit\n * storage transaction rolls back), so an armed hit ends the current Attempt exactly like an\n * unannounced platform eviction; DO storage — the only correctness-critical state — survives\n * for the next incarnation, which the persisted alarm wakes without any incoming request.\n *\n * The handles stay injected: this package never imports `cloudflare:workers`, so the harness\n * that owns a `DurableObjectState` supplies the thunk.\n */\nexport const evictionFailpointHandler =\n  (options: {\n    readonly isArmed: (location: DoStorageFailpointLocation) => Effect.Effect<boolean>;\n    /** Kills the incarnation — e.g. `() => ctx.abort()`. Typed `void` because the platform\n     * declares `abort` as returning, but it throws while destroying the instance. */\n    readonly evict: (location: DoStorageFailpointLocation) => void;\n  }): DoStorageFailpointHandler =>\n  (location) =>\n    options.isArmed(location).pipe(\n      Effect.flatMap((armed) =>\n        armed\n          ? // `ctx.abort()` throws while destroying the instance; that throw surfaces as a\n            // defect in the (already dying) incarnation. The defensive defect below keeps the\n            // guarantee — nothing after an armed hit may observe in-memory state — even if a\n            // harness supplies an evict thunk that returns.\n            Effect.sync(() => options.evict(location)).pipe(\n              Effect.andThen(\n                Effect.die(\n                  // oxlint-disable-next-line effect/no-native-error -- A returning native eviction callback violates the host contract and must remain a defect.\n                  new Error(`Durable Object eviction did not interrupt execution at ${location}.`),\n                ),\n              ),\n            )\n          : Effect.void,\n      ),\n    );\n"],"mappings":";;;;;;;;;;;;;;AAiBA,MAAa,4BACV,aAMA,aACC,QAAQ,QAAQ,QAAQ,CAAC,CAAC,KACxB,OAAO,SAAS,UACd,QAKI,OAAO,WAAW,QAAQ,MAAM,QAAQ,CAAC,CAAC,CAAC,KACzC,OAAO,QACL,OAAO,oBAEL,IAAI,MAAM,0DAA0D,SAAS,EAAE,CACjF,CACF,CACF,IACA,OAAO,IACb,CACF"}

package/dist/{DoStorageVersion-NKnQU3eR.d.mts → DoStorageVersion-Mc7CXMdN.d.mts}

@@ -2,10 +2,10 @@ import "./DoStorageError-CxjMnzUA.mjs";
 import { Effect } from "effect";
 import "effect/sql/SqlClient";
 //#region src/internal/migrations.d.ts
-declare const CurrentDoStorageVersion = 27;
+declare const CurrentDoStorageVersion = 28;
 declare namespace DoStorageVersion_d_exports {
   export { CurrentDoStorageVersion };
 }
 //#endregion
 export { CurrentDoStorageVersion as n, DoStorageVersion_d_exports as t };
-//# sourceMappingURL=DoStorageVersion-NKnQU3eR.d.mts.map
+//# sourceMappingURL=DoStorageVersion-Mc7CXMdN.d.mts.map

package/dist/DoStorageVersion.d.mts

@@ -1,2 +1,2 @@
-import { n as CurrentDoStorageVersion } from "./DoStorageVersion-NKnQU3eR.mjs";
+import { n as CurrentDoStorageVersion } from "./DoStorageVersion-Mc7CXMdN.mjs";
 export { CurrentDoStorageVersion };

package/dist/DoStorageVersion.mjs

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { t as CurrentDoStorageVersion } from "./migrations-C3N9GN6A.mjs";
+import { t as CurrentDoStorageVersion } from "./migrations-CAO_akhD.mjs";
 //#region src/DoStorageVersion.ts
-var DoStorageVersion_exports = /* @__PURE__ */ __exportAll({ CurrentDoStorageVersion: () => 27 });
+var DoStorageVersion_exports = /* @__PURE__ */ __exportAll({ CurrentDoStorageVersion: () => 28 });
 //#endregion
 export { CurrentDoStorageVersion, DoStorageVersion_exports as t };
 

package/dist/DoSubmissionLedger.mjs

@@ -2,18 +2,18 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { DoStorageConfig } from "./DoStorageConfig.mjs";
 import { DoStorageFailpoint } from "./DoStorageFailpoint.mjs";
 import { DoLedgerError, DoStorageCorruptionError, DoStorageError } from "./DoStorageError.mjs";
-import { n as ownedRows } from "./owned-state-BHzUi0eb.mjs";
-import { i as initializeDoJournal, r as decodeRows } from "./do-journal-_MdLGTd3.mjs";
-import { l as prepareCanonicalAppend, o as storageConfigLayer, s as storageFailpointLayer } from "./DoThreadStore-CtyahRTW.mjs";
+import { n as ownedRows } from "./owned-state-B4QhezMp.mjs";
+import { i as initializeDoJournal, r as decodeRows } from "./do-journal-7P3DUBz0.mjs";
+import { l as prepareCanonicalAppend, o as storageConfigLayer, s as storageFailpointLayer } from "./DoThreadStore-CgIZQUNR.mjs";
 import { BrowserCrypto } from "@effect/platform-browser";
 import { Cause, Clock, Context, Crypto, DateTime, Effect, Layer, Option, Schema, Stream } from "effect";
 import * as SqlClientService from "effect/sql/SqlClient";
+import { SqliteClient } from "@effect/sql-sqlite-do";
 import { definitionJson, makeCanonicalStorage, recordBatchId, runKey } from "@yielded/agent-storage-sql/sql-canonical-storage";
 import { SqlStorageProgress } from "@yielded/agent-storage-sql/sql-storage-progress";
 import { canonicalRecordJson } from "@yielded/agent-storage-sql/sql-thread-archive-range";
-import { ApprovalDecision, CanonicalSequence, DefinitionDigests, Digest, PersistedJson, RecordEnvelope, SettlementOutcome, WorkerAdmission } from "@yielded/agent/records";
+import { ApprovalDecision, CanonicalSequence, DefinitionDigests, Digest, PersistedJson, RecordEnvelope, RecordId, SettlementOutcome, WorkerAdmission } from "@yielded/agent/records";
 import { AppendConflict, ThreadNotMaterialized, ThreadStoreDiagnostic, ThreadStoreError, makeTransferFactCheck } from "@yielded/agent/thread-store";
-import { SqliteClient } from "@effect/sql-sqlite-do";
 import { StorageOwner } from "@yielded/agent/run-storage";
 import { decodeAbortFact, decodeAdmissionFact, decodeApprovalFact, decodeResolutionFact } from "@yielded/agent-storage-sql/sql-admission-facts";
 import { InputMessage } from "@yielded/agent/messaging";
@@ -55,7 +55,7 @@ var SubmissionRow = class extends Schema.Class("SubmissionRow")({
 	receipt_id: BoundedIdentifier,
 	state: SubmissionState,
 	settled_outcome: Schema.NullOr(SettlementOutcome),
-	settled_record_id: Schema.NullOr(BoundedIdentifier),
+	settled_record_id: Schema.NullOr(BoundedIdentifier.pipe(Schema.decodeTo(RecordId))),
 	finalized_at: Schema.NullOr(BoundedTimestamp),
 	created_at: BoundedTimestamp,
 	ready_at: Schema.NullOr(BoundedTimestamp),
@@ -191,7 +191,7 @@ const decodeClaim = Schema.decodeUnknownEffect(Claim);
 const decodeSettlement = Schema.decodeUnknownEffect(Settlement);
 const decodeAbortIntent = Schema.decodeUnknownEffect(AbortIntent);
 const decodeInputAppliedMarker = Schema.decodeUnknownEffect(InputAppliedMarker);
-const decodeSubmissionSnapshotType = (input) => Schema.decodeEffect(Schema.toType(Schema.Struct(SubmissionSnapshot.fields)))(input).pipe(Effect.map((fields) => SubmissionSnapshot.make(fields)));
+const decodeSubmissionSnapshotType = (input) => SubmissionSnapshot.makeEffect(input).pipe(Effect.mapError((issue) => new Schema.SchemaError(issue)));
 const decodeSubmissionId = Schema.decodeUnknownEffect(SubmissionSnapshot.fields.submissionId);
 const decodeQueueSequence = Schema.decodeUnknownEffect(QueueSequence);
 const decodeUtcInstant = Schema.decodeUnknownEffect(Schema.DateTimeUtcFromString);
@@ -205,6 +205,26 @@ const decodeChildReservationSnapshotUnknown = Schema.decodeUnknownEffect(ChildBu
 const decodeChildAttachmentSnapshot = Schema.decodeUnknownEffect(ChildAttachmentSnapshot);
 const equivalentPersistedJson = Schema.toEquivalence(PersistedJson);
 const equivalentUnknownResolution = Schema.toEquivalence(UnknownResolution);
+const decodeAdmissionRequestType = Schema.decodeEffect(Schema.toType(AdmissionRequest));
+const decodeSubmissionLookupType = Schema.decodeEffect(Schema.toType(SubmissionLookup));
+const decodeClaimRequestType = Schema.decodeEffect(Schema.toType(ClaimRequest));
+const decodeMarkInputAppliedRequestType = Schema.decodeEffect(Schema.toType(MarkInputAppliedRequest));
+const decodeSettlementFinalizationType = Schema.decodeEffect(Schema.toType(SettlementFinalization));
+const decodeClaimJoiningRequestType = Schema.decodeEffect(Schema.toType(ClaimJoiningRequest));
+const decodeAbortIntentRequestType = Schema.decodeEffect(Schema.toType(AbortIntentRequest));
+const decodeRecoverySnapshotRequestType = Schema.decodeEffect(Schema.toType(RecoverySnapshotRequest));
+const SubmissionRows = Schema.Array(SubmissionRow);
+const ChildReservationRows = Schema.Array(ChildReservationRow);
+const MaxQueueSequenceRows = Schema.Array(MaxQueueSequenceRow);
+const SubmissionWorkItems = Schema.Array(SubmissionWorkItem);
+const decodeSubmissionWorkItems = Schema.decodeEffect(SubmissionWorkItems);
+const equivalentWorkerOrigin = Schema.toEquivalence(Schema.optional(WorkerAdmission.fields.origin));
+const decodeFirstWorkerAdmissions = Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ worker_admission_json: Schema.NullOr(BoundedStoredText) })));
+const CanonicalSettlementRows = Schema.Array(Schema.Struct({
+	batch_id: Schema.fromJsonString(BoundedIdentifier),
+	record_id: Schema.fromJsonString(BoundedIdentifier),
+	record_json: BoundedStoredText
+}));
 const isDoStorageError = Schema.is(DoStorageError);
 /** Wrap an adapter-internal failure into the port's LedgerError without erasing its tag. */
 const internalFailure = (operation) => (error) => LedgerError.make({
@@ -319,7 +339,7 @@ const makeServices = Effect.fnUntraced(function* () {
 		millis,
 		iso: new Date(millis).toISOString()
 	}));
-	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(SubmissionRows, "effect_agent_submissions", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
 	const readSubmission = Effect.fnUntraced(function* (operation, submissionId) {
 		const found = yield* cached(rows.submissions.by("submission_id", submissionId), operation);
 		return Option.fromUndefinedOr(found[0]);
@@ -354,11 +374,14 @@ const makeServices = Effect.fnUntraced(function* () {
 		}));
 		if (row.parent_submission_id === null !== (row.parent_tool_call_id === null)) return yield* corruptionFailure(operation, "effect_agent_submissions", row.submission_id, "A parent linkage must record both the parent Submission and the parent Tool Call.");
 		const admission = yield* decodeAdmissionFact(row).pipe(Effect.mapError(decodeFailure));
+		const settledAt = row.finalized_at === null ? void 0 : yield* decodeUtcInstant(row.finalized_at).pipe(Effect.mapError(decodeFailure));
 		const readyAt = row.ready_at === null ? void 0 : yield* decodeUtcInstant(row.ready_at).pipe(Effect.mapError(decodeFailure));
 		const snapshot = yield* decodeSubmissionSnapshotType({
 			...admission,
 			state: row.state,
 			...row.settled_outcome === null ? {} : { settledOutcome: row.settled_outcome },
+			...settledAt === void 0 ? {} : { settledAt },
+			...row.settled_record_id === null ? {} : { settledRecordId: row.settled_record_id },
 			...readyAt === void 0 ? {} : { readyAt }
 		}).pipe(Effect.mapError(decodeFailure));
 		submissions.set(row, snapshot);
@@ -370,11 +393,7 @@ const makeServices = Effect.fnUntraced(function* () {
 		const found = yield* sql`SELECT ${recordBatchId(sql)} AS batch_id, record_id, ${canonicalRecordJson(sql)} AS record_json
       FROM effect_agent_canonical_records WHERE thread_id = ${submission.thread_id}
       AND record_id = ${JSON.stringify(recordId)}`.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows(Schema.Array(Schema.Struct({
-			batch_id: Schema.fromJsonString(BoundedIdentifier),
-			record_id: Schema.fromJsonString(BoundedIdentifier),
-			record_json: BoundedStoredText
-		})), "effect_agent_canonical_records", recordId, found).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows(CanonicalSettlementRows, "effect_agent_canonical_records", recordId, found).pipe(Effect.mapError(internalFailure(operation)));
 		if (decoded.length === 0) return void 0;
 		const row = decoded[0];
 		if (decoded.length !== 1 || row.batch_id !== submissionSettlementBatchId(expected.submissionId) || row.record_id !== recordId) return yield* corruptionFailure(operation, "effect_agent_canonical_records", recordId, "Canonical settlement identity is inconsistent.");
@@ -407,7 +426,7 @@ const makeServices = Effect.fnUntraced(function* () {
 		const childRow = yield* readSubmission(operation, childSubmissionId);
 		return Option.isSome(childRow) && (yield* readCanonicalSettlement(operation, childRow.value)) !== void 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(ChildReservationRows, "effect_agent_child_reservations", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
 	const readChildReservation = Effect.fnUntraced(function* (operation, reservationId) {
 		const rows = yield* sql`
       SELECT ${sql.literal(CHILD_RESERVATION_COLUMNS)}
@@ -480,9 +499,9 @@ const makeServices = Effect.fnUntraced(function* () {
 		});
 	});
 	const capabilities = Effect.succeed(LedgerCapabilities.make({ durability: "durable-cloudflare" }));
-	const admit = Effect.fnUntraced(function* (request) {
+	const admit = Effect.fnUntraced(function* (request, options) {
 		const operation = "ledger admit";
-		const validated = yield* Schema.decodeEffect(Schema.toType(AdmissionRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
+		const validated = yield* decodeAdmissionRequestType(request).pipe(Effect.mapError(internalFailure(operation)));
 		const inputJson = yield* encodePersistedJsonText(validated.inputPayload).pipe(Effect.mapError(internalFailure(operation)));
 		yield* journal.checkValueBound(operation, inputJson).pipe(Effect.mapError(internalFailure(operation)));
 		const workerAdmissionJson = validated.workerAdmission === void 0 ? null : yield* Schema.encodeEffect(Schema.fromJsonString(WorkerAdmission))(validated.workerAdmission).pipe(Effect.mapError(internalFailure(operation)));
@@ -547,10 +566,10 @@ const makeServices = Effect.fnUntraced(function* () {
             SELECT worker_admission_json FROM effect_agent_submissions
             WHERE thread_id=${validated.threadId} ORDER BY queue_sequence LIMIT 1
           `.pipe(Effect.mapError(sqlFailure(operation)));
-			const first = yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ worker_admission_json: Schema.NullOr(BoundedStoredText) })))(firstRows).pipe(Effect.mapError(internalFailure(operation)));
+			const first = yield* decodeFirstWorkerAdmissions(firstRows).pipe(Effect.mapError(internalFailure(operation)));
 			if (first[0] !== void 0) {
 				const previous = first[0].worker_admission_json === null ? void 0 : yield* Schema.decodeEffect(Schema.fromJsonString(WorkerAdmission))(first[0].worker_admission_json).pipe(Effect.mapError(internalFailure(operation)));
-				if (!Schema.toEquivalence(Schema.optional(WorkerAdmission.fields.origin))(previous?.origin, validated.workerAdmission?.origin)) return yield* AdmissionPolicyError.make({
+				if (!equivalentWorkerOrigin(previous?.origin, validated.workerAdmission?.origin)) return yield* AdmissionPolicyError.make({
 					reason: "refused",
 					code: "worker-origin-conflict"
 				});
@@ -570,9 +589,10 @@ const makeServices = Effect.fnUntraced(function* () {
             FROM effect_agent_submissions
             WHERE thread_id = ${validated.threadId}
           `.pipe(Effect.mapError(sqlFailure(operation)));
-			const decodedMax = yield* decodeRows(Schema.Array(MaxQueueSequenceRow), "effect_agent_submissions", validated.threadId, maxRows).pipe(Effect.mapError(internalFailure(operation)));
+			const decodedMax = yield* decodeRows(MaxQueueSequenceRows, "effect_agent_submissions", validated.threadId, maxRows).pipe(Effect.mapError(internalFailure(operation)));
 			const queueSequence = yield* decodeQueueSequence((decodedMax[0]?.max_queue_sequence ?? 0) + 1).pipe(Effect.mapError(internalFailure(operation)));
 			const now = yield* currentInstant;
+			const ready = options?.readyIfInitialized === true && validated.workerAdmission === void 0 && (yield* journal.getThread(validated.threadId).pipe(Effect.mapError(internalFailure(operation)))).some((thread) => thread.tail_sequence > 0);
 			yield* sql`
             INSERT INTO effect_agent_submissions (
               submission_id,
@@ -588,6 +608,7 @@ const makeServices = Effect.fnUntraced(function* () {
               receipt_id,
               state,
               created_at,
+              ready_at,
               parent_submission_id,
               parent_tool_call_id,
               admission_group,
@@ -606,8 +627,9 @@ const makeServices = Effect.fnUntraced(function* () {
               ${inputJson},
               ${validated.inputDigest},
               ${mintedReceiptId},
-              'admitted',
+              ${ready ? "ready" : "admitted"},
               ${now.iso},
+              ${ready ? now.iso : null},
               ${validated.parentLinkage?.parentSubmissionId ?? null},
               ${validated.parentLinkage?.parentToolCallId ?? null},
               ${validated.admissionGroup ?? null},
@@ -619,6 +641,11 @@ const makeServices = Effect.fnUntraced(function* () {
 			if (queueSequence === 1) {
 				if ((yield* journal.getThread(validated.threadId).pipe(Effect.mapError(internalFailure(operation)))).length === 0) yield* journal.work.initialize(validated.threadId).pipe(Effect.mapError(internalFailure(operation)));
 			}
+			submissionViews.seedMatching(JSON.stringify([
+				"joining-suffix",
+				validated.threadId,
+				queueSequence
+			]), (row) => row.thread_id === validated.threadId && row.queue_sequence > queueSequence, [], 0);
 			rows.aborts.seed("submission_id", mintedSubmissionId, []);
 			rows.submissions.seed("joined_host_submission_id", mintedSubmissionId, []);
 			rows.approvals.seed("submission_id", mintedSubmissionId, []);
@@ -626,13 +653,18 @@ const makeServices = Effect.fnUntraced(function* () {
 			rows.childReservations.seed("parent_submission_id", mintedSubmissionId, []);
 			rows.childSettlements.seed("parent_submission_id", mintedSubmissionId, []);
 			yield* recordProgress("submission", operation);
-			return yield* decodeAdmissionResult({
+			const admitted = yield* decodeAdmissionResult({
 				submissionId: mintedSubmissionId,
 				receiptId: mintedReceiptId,
 				queueSequence,
-				state: "admitted",
+				state: ready ? "ready" : "admitted",
 				replayed: false
 			}).pipe(Effect.mapError(internalFailure(operation)));
+			if (ready && lifecycle !== void 0) yield* retainLifecycle(yield* requireSubmission(operation, mintedSubmissionId), {
+				_tag: "SubmissionReady",
+				submissionId: admitted.submissionId
+			});
+			return admitted;
 		}));
 		yield* hitFailpoint("ledger:admit:after", operation);
 		return result;
@@ -682,7 +714,7 @@ const makeServices = Effect.fnUntraced(function* () {
 	}, state.read);
 	const lookup = Effect.fnUntraced(function* (request) {
 		const operation = "ledger lookup";
-		const validated = yield* Schema.decodeEffect(Schema.toType(SubmissionLookup))(request).pipe(Effect.mapError(internalFailure(operation)));
+		const validated = yield* decodeSubmissionLookupType(request).pipe(Effect.mapError(internalFailure(operation)));
 		if (validated._tag === "SubmissionLookupById") {
 			const row = yield* readSubmission(operation, validated.submissionId);
 			if (Option.isNone(row)) return Option.none();
@@ -705,12 +737,23 @@ const makeServices = Effect.fnUntraced(function* () {
 	});
 	const selectHead = Effect.fn("DoSubmissionLedger.selectHead")(function* (request) {
 		const operation = "ledger select head";
-		const validated = yield* Schema.decodeEffect(Schema.toType(ClaimRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
+		const validated = yield* decodeClaimRequestType(request).pipe(Effect.mapError(internalFailure(operation)));
 		const attemptId = `attempt-${yield* mintUuid(operation)}`;
 		yield* hitFailpoint("ledger:claim:before", operation);
 		const claimed = yield* owner.withMutation(Effect.gen(function* () {
 			if (owner.hasOwner(validated.threadId)) return Option.none();
-			const headRows = yield* sql`
+			const active = yield* activeNonterminal;
+			const heads = [];
+			const limit = validated.handoff === void 0 ? 1 : validated.handoff.deferredSubmissionIds.length + 1;
+			if (active.length <= 128) {
+				const candidates = active.filter((row) => row.thread_id === validated.threadId).sort((left, right) => left.queue_sequence - right.queue_sequence);
+				for (const candidate of candidates) {
+					if (candidate.state === "unknown" && Option.isNone(yield* readAbortIntent(operation, candidate.submission_id))) continue;
+					heads.push(yield* requireSubmission(operation, candidate.submission_id));
+					if (heads.length === limit) break;
+				}
+			} else {
+				const headRows = yield* sql`
             SELECT ${submissionColumns}
             FROM effect_agent_submissions
             WHERE thread_id = ${validated.threadId}
@@ -724,7 +767,8 @@ const makeServices = Effect.fnUntraced(function* () {
             ORDER BY queue_sequence ASC
             LIMIT ${validated.handoff === void 0 ? 1 : validated.handoff.deferredSubmissionIds.length + 1}
           `.pipe(Effect.mapError(sqlFailure(operation)));
-			const heads = yield* decodeSubmissionRows(operation, validated.threadId, headRows);
+				heads.push(...yield* decodeSubmissionRows(operation, validated.threadId, headRows));
+			}
 			if (heads.length === 0) return Option.none();
 			let head = heads[0];
 			if (validated.handoff !== void 0) {
@@ -751,7 +795,7 @@ const makeServices = Effect.fnUntraced(function* () {
 	});
 	const markInputApplied = Effect.fnUntraced(function* (request) {
 		const operation = "ledger mark input applied";
-		const validated = yield* Schema.decodeEffect(Schema.toType(MarkInputAppliedRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
+		const validated = yield* decodeMarkInputAppliedRequestType(request).pipe(Effect.mapError(internalFailure(operation)));
 		yield* hitFailpoint("ledger:mark-input-applied:before", operation);
 		yield* inWriteTransaction(operation, Effect.gen(function* () {
 			const submission = yield* requireSubmission(operation, validated.submissionId);
@@ -896,7 +940,7 @@ const makeServices = Effect.fnUntraced(function* () {
 	});
 	const finalizeSettlement = Effect.fn("DoSubmissionLedger.finalizeSettlement")(function* (request) {
 		const operation = "ledger finalize settlement";
-		const validated = yield* Schema.decodeEffect(Schema.toType(SettlementFinalization))(request).pipe(Effect.mapError(internalFailure(operation)));
+		const validated = yield* decodeSettlementFinalizationType(request).pipe(Effect.mapError(internalFailure(operation)));
 		yield* hitFailpoint("ledger:finalize-settlement:before", operation);
 		const replay = yield* state.read(Effect.gen(function* () {
 			const submission = yield* readSubmission(operation, validated.submissionId);
@@ -1056,9 +1100,9 @@ const makeServices = Effect.fnUntraced(function* () {
 	});
 	const claimJoining = Effect.fnUntraced(function* (request) {
 		const operation = "ledger claim joining";
-		const validated = yield* Schema.decodeEffect(Schema.toType(ClaimJoiningRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
+		const validated = yield* decodeClaimJoiningRequestType(request).pipe(Effect.mapError(internalFailure(operation)));
 		yield* hitFailpoint("ledger:claim-joining:before", operation);
-		const claims = yield* inWriteTransaction(operation, Effect.gen(function* () {
+		const claims = yield* owner.withMutation(Effect.gen(function* () {
 			const host = yield* requireSubmission(operation, validated.hostSubmissionId);
 			if (host.thread_id !== validated.threadId) return yield* LedgerError.make({
 				operation,
@@ -1066,36 +1110,42 @@ const makeServices = Effect.fnUntraced(function* () {
 			});
 			yield* requireOwner(operation, host);
 			if ((yield* cached(rows.workerStops.by("thread_id", validated.threadId), operation)).length > 0) return [];
-			const laterRows = yield* sql`
-          SELECT ${submissionColumns}
-          FROM effect_agent_submissions
-          WHERE thread_id = ${validated.threadId}
-            AND queue_sequence > ${host.queue_sequence}
-          ORDER BY queue_sequence ASC
-        `.pipe(Effect.mapError(sqlFailure(operation)));
-			const later = yield* decodeSubmissionRows(operation, validated.threadId, laterRows);
-			const claimed = [];
-			for (const row of later) {
-				if (claimed.length >= validated.maxCount) break;
-				if ((row.state === "joining" || row.state === "joined") && row.joined_host_submission_id === validated.hostSubmissionId) continue;
-				if (row.state === "settled" && row.settled_outcome === "aborted") continue;
-				if (row.state !== "ready") break;
-				const canonical = yield* readCanonicalSettlement(operation, row);
-				if (canonical?.settlement.outcome === "aborted") continue;
-				if (canonical !== void 0) break;
-				yield* sql`
+			const later = yield* submissionViews.matching(JSON.stringify([
+				"joining-suffix",
+				validated.threadId,
+				host.queue_sequence
+			]), (row) => row.thread_id === validated.threadId && row.queue_sequence > host.queue_sequence, sql`
+              SELECT ${submissionColumns}
+              FROM effect_agent_submissions
+              WHERE thread_id = ${validated.threadId}
+                AND queue_sequence > ${host.queue_sequence}
+              ORDER BY queue_sequence ASC
+            `, 0).pipe(Effect.mapError((error) => error._tag === "SqlError" ? sqlFailure(operation)(error) : internalFailure(operation)(error)));
+			if (later.length === 0) return [];
+			return yield* inWriteTransaction(operation, Effect.gen(function* () {
+				const claimed = [];
+				for (const row of later) {
+					if (claimed.length >= validated.maxCount) break;
+					if ((row.state === "joining" || row.state === "joined") && row.joined_host_submission_id === validated.hostSubmissionId) continue;
+					if (row.state === "settled" && row.settled_outcome === "aborted") continue;
+					if (row.state !== "ready") break;
+					const canonical = yield* readCanonicalSettlement(operation, row);
+					if (canonical?.settlement.outcome === "aborted") continue;
+					if (canonical !== void 0) break;
+					yield* sql`
             UPDATE effect_agent_submissions
             SET state = 'joining', joined_host_submission_id = ${validated.hostSubmissionId}
             WHERE submission_id = ${row.submission_id}
            RETURNING *, ${definitionJson(sql)} AS agent_digests_json`.pipe(rows.submissions.write, Effect.mapError(internalFailure(operation)));
-				const inputPayload = yield* parseStoredJsonText(row.input_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", row.submission_id, error.message)));
-				claimed.push(yield* decodeJoiningClaim({
-					submissionId: row.submission_id,
-					queueSequence: row.queue_sequence,
-					inputPayload
-				}).pipe(Effect.mapError(internalFailure(operation))));
-			}
-			return claimed;
+					const inputPayload = yield* parseStoredJsonText(row.input_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", row.submission_id, error.message)));
+					claimed.push(yield* decodeJoiningClaim({
+						submissionId: row.submission_id,
+						queueSequence: row.queue_sequence,
+						inputPayload
+					}).pipe(Effect.mapError(internalFailure(operation))));
+				}
+				return claimed;
+			}));
 		}));
 		yield* hitFailpoint("ledger:claim-joining:after", operation);
 		return claims;
@@ -1665,20 +1715,21 @@ const makeServices = Effect.fnUntraced(function* () {
           ORDER BY thread_id ASC, queue_sequence ASC
           LIMIT ${SCAN_PAGE_SIZE}
         `).pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows(Schema.Array(SubmissionWorkItem), "effect_agent_submissions", "nonterminal_scan", rows, "SubmissionWorkItem").pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows(SubmissionWorkItems, "effect_agent_submissions", "nonterminal_scan", rows, "SubmissionWorkItem").pipe(Effect.mapError(internalFailure(operation)));
 		const last = decoded[decoded.length - 1];
 		return [decoded, last === void 0 || decoded.length < SCAN_PAGE_SIZE ? Option.none() : Option.some({
 			threadId: last.threadId,
 			queueSequence: last.queueSequence
 		})];
 	});
-	const scanNonterminal = Stream.unwrap(state.read(Effect.gen(function* () {
-		const active = yield* cached(workRows.matching("nonterminal", (row) => row.state !== "settled", sql`SELECT submission_id, thread_id, queue_sequence, principal, idempotency_key,
-              deployment_id, receipt_id, state
-              FROM effect_agent_submissions WHERE state <> 'settled' LIMIT 129`, 128), "ledger scan nonterminal");
-		if (active.length > 128) return Stream.paginate(void 0, scanPage);
+	const activeNonterminal = cached(workRows.matching("nonterminal", (row) => row.state !== "settled", sql`SELECT submission_id, thread_id, queue_sequence, principal, idempotency_key,
+          deployment_id, receipt_id, state
+          FROM effect_agent_submissions WHERE state <> 'settled' LIMIT 129`, 128), "ledger scan nonterminal");
+	const boundedNonterminal = state.read(Effect.gen(function* () {
+		const active = yield* activeNonterminal;
+		if (active.length > 128) return void 0;
 		const sorted = [...active].sort((left, right) => left.thread_id < right.thread_id ? -1 : left.thread_id > right.thread_id ? 1 : left.queue_sequence - right.queue_sequence);
-		const work = yield* Schema.decodeEffect(Schema.Array(SubmissionWorkItem))(sorted.map((row) => ({
+		return yield* decodeSubmissionWorkItems(sorted.map((row) => ({
 			submissionId: row.submission_id,
 			threadId: row.thread_id,
 			queueSequence: row.queue_sequence,
@@ -1688,11 +1739,13 @@ const makeServices = Effect.fnUntraced(function* () {
 			receiptId: row.receipt_id,
 			state: row.state
 		}))).pipe(Effect.mapError(internalFailure("ledger scan nonterminal")));
-		return Stream.fromIterable(work);
-	})));
+	}));
+	const pagedNonterminal = Stream.paginate(void 0, scanPage);
+	const scanNonterminal = Stream.unwrap(Effect.map(boundedNonterminal, (work) => work === void 0 ? pagedNonterminal : Stream.fromIterable(work)));
+	const listNonterminal = Effect.filterOrElse(boundedNonterminal, (work) => work !== void 0, () => Stream.runCollect(pagedNonterminal));
 	const readAbortIntentForSubmission = Effect.fnUntraced(function* (request) {
 		const operation = "ledger read abort intent";
-		const validated = yield* Schema.decodeEffect(Schema.toType(AbortIntentRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
+		const validated = yield* decodeAbortIntentRequestType(request).pipe(Effect.mapError(internalFailure(operation)));
 		return yield* state.read(Effect.gen(function* () {
 			const submission = yield* requireSubmission(operation, validated.submissionId);
 			const intent = yield* readAbortIntent(operation, validated.submissionId);
@@ -1701,7 +1754,7 @@ const makeServices = Effect.fnUntraced(function* () {
 	});
 	const loadRecoverySnapshot = Effect.fnUntraced(function* (request) {
 		const operation = "ledger load recovery snapshot";
-		const validated = yield* Schema.decodeEffect(Schema.toType(RecoverySnapshotRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
+		const validated = yield* decodeRecoverySnapshotRequestType(request).pipe(Effect.mapError(internalFailure(operation)));
 		return yield* state.read(Effect.gen(function* () {
 			const submissionRow = yield* requireSubmission(operation, validated.submissionId);
 			const submission = yield* decodeSubmissionSnapshot(operation, submissionRow);
@@ -1808,6 +1861,7 @@ const makeServices = Effect.fnUntraced(function* () {
 		beginChildBudgetRelease,
 		releaseChildBudget,
 		scanNonterminal,
+		listNonterminal,
 		loadRecoverySnapshot,
 		readAbortIntent: readAbortIntentForSubmission
 	})).pipe(Context.add(StorageOwner, owner), Context.add(SettlementPublisher, { publish }));