@yielded/agent-storage-cloudflare 0.1.0-beta.174 → 0.1.0-beta.176

package/dist/DoSubmissionLedger.mjs

@@ -2,24 +2,24 @@ 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-DcFh0YNo.mjs";
-import { i as initializeDoJournal, r as decodeRows } from "./do-journal-ZMAzzENZ.mjs";
-import { l as prepareCanonicalAppend, o as storageConfigLayer, s as storageFailpointLayer } from "./DoThreadStore-DyzOZDXK.mjs";
+import { n as ownedRows } from "./owned-state-BgGOA2Ak.mjs";
+import { i as initializeDoJournal, r as decodeRows } from "./do-journal-ySC3eXNv.mjs";
+import { l as prepareCanonicalAppend, o as storageConfigLayer, s as storageFailpointLayer } from "./DoThreadStore-DG0h5J6u.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, 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";
 import { runIdForSubmission } from "@yielded/agent/run-journal";
 import { SettlementPublicationResult, SettlementPublisher, validateCanonicalSettlement, validateJoinedSettlement, validatePublication } from "@yielded/agent/settlement-publisher";
-import { AbortCommand, AbortIntent, AbortIntentRequest, AdmissionAdmitted, AdmissionConflict, AdmissionFence, AdmissionGroup, AdmissionNotAdmitted, AdmissionPolicyError, AdmissionRequest, AdmissionResult, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildReservationStatus, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, FundingOwner, FundingOwnerRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, OwnershipLost, ParentLinkage, QueueSequence, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReservedChildBudget, RevertJoiningRequest, Settlement, SettlementConflict, SettlementFinalization, SubmissionAdmissionFence, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SubmissionWorkItem, SuspendRequest, SuspensionReason, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, UnknownResolutionKind, WorkerLedgerState, WorkerStopCommand, approvalDecisionsCover, settlementFailureFromRecord, submissionAbortRecordId, submissionSettlementBatchId, submissionSettlementRecordId, unknownResolutionKind, unknownResolutionMatchesResult, workerTerminalFromRecord } from "@yielded/agent/submission-ledger";
+import { AbortCommand, AbortIntent, AbortIntentRequest, AdmissionAdmitted, AdmissionConflict, AdmissionFence, AdmissionGroup, AdmissionNotAdmitted, AdmissionPolicyError, AdmissionRequest, AdmissionResult, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildReservationStatus, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, FundingOwner, FundingOwnerRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, OwnershipLost, ParentLinkage, QueueSequence, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReservedChildBudget, RevertJoiningRequest, Settlement, SettlementConflict, SettlementFinalization, SubmissionAdmissionFence, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SubmissionWorkItem, SuspendRequest, SuspensionReason, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, UnknownResolutionKind, WorkerLedgerState, WorkerStopCommand, approvalDecisionsCover, settlementFailureFromRecord, submissionAbortRecordId, submissionInputBatchId, submissionInputRecordId, submissionSettlementBatchId, submissionSettlementRecordId, unknownResolutionKind, unknownResolutionMatchesResult, workerTerminalFromRecord } from "@yielded/agent/submission-ledger";
 import { AssignmentTerminal } from "@yielded/agent/worker";
 //#region src/DoSubmissionLedger.ts
 var DoSubmissionLedger_exports = /* @__PURE__ */ __exportAll({
@@ -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]);
@@ -373,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.");
@@ -410,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)}
@@ -483,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)));
@@ -508,8 +524,7 @@ const makeServices = Effect.fnUntraced(function* () {
 		yield* hitFailpoint("ledger:admit:before", operation);
 		const result = yield* inWriteTransaction(operation, Effect.gen(function* () {
 			const keyRowKey = `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`;
-			const existingRows = yield* byKey(validated, operation);
-			const existing = yield* decodeSubmissionRows(operation, keyRowKey, existingRows);
+			const existing = yield* byKey(validated, operation);
 			if (existing.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", keyRowKey, "An admission idempotency key returned more than one row.");
 			if (existing.length === 1) {
 				const sameLinkage = validated.parentLinkage === void 0 ? existing[0].parent_submission_id === null && existing[0].parent_tool_call_id === null : existing[0].parent_submission_id === validated.parentLinkage.parentSubmissionId && existing[0].parent_tool_call_id === validated.parentLinkage.parentToolCallId;
@@ -550,10 +565,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"
 				});
@@ -573,9 +588,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,
@@ -591,6 +607,7 @@ const makeServices = Effect.fnUntraced(function* () {
               receipt_id,
               state,
               created_at,
+              ready_at,
               parent_submission_id,
               parent_tool_call_id,
               admission_group,
@@ -609,8 +626,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},
@@ -622,6 +640,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, []);
@@ -629,13 +652,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;
@@ -685,14 +713,13 @@ 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();
 			return Option.some(yield* decodeSubmissionSnapshot(operation, row.value));
 		}
-		const foundRows = yield* byKey(validated, operation);
-		const decoded = yield* decodeSubmissionRows(operation, `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`, foundRows);
+		const decoded = yield* byKey(validated, operation);
 		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`, "An admission idempotency key returned more than one row.");
 		if (decoded.length === 0) return Option.none();
 		return Option.some(yield* decodeSubmissionSnapshot(operation, decoded[0]));
@@ -700,20 +727,30 @@ const makeServices = Effect.fnUntraced(function* () {
 	const resolveAdmission = Effect.fnUntraced(function* (request) {
 		const operation = "ledger resolve admission";
 		const validated = yield* Schema.decodeEffect(Schema.toType(SubmissionLookupByKey))(request).pipe(Effect.mapError(internalFailure(operation)));
-		const foundRows = yield* byKey(validated, operation);
-		const decoded = yield* decodeSubmissionRows(operation, `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`, foundRows);
+		const decoded = yield* byKey(validated, operation);
 		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`, "An admission idempotency key returned more than one row.");
 		if (decoded.length === 0) return AdmissionNotAdmitted.make();
 		return AdmissionAdmitted.make({ submission: yield* decodeSubmissionSnapshot(operation, decoded[0]) });
 	});
 	const 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}
@@ -727,7 +764,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) {
@@ -752,31 +790,76 @@ const makeServices = Effect.fnUntraced(function* () {
 		yield* hitFailpoint("ledger:claim:after", operation);
 		return claimed;
 	});
+	const markInputAppliedInTransaction = Effect.fnUntraced(function* (validated) {
+		const operation = "ledger mark input applied";
+		const submission = yield* requireSubmission(operation, validated.submissionId);
+		yield* requireOwner(operation, submission);
+		if (submission.input_applied_record_id !== null) {
+			if (submission.input_applied_record_id === validated.recordId && submission.input_applied_sequence === validated.sequence) return;
+			return yield* corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, "A different canonical input marker is already recorded for this Submission.");
+		}
+		yield* sql`
+    UPDATE effect_agent_submissions
+    SET
+      input_applied_record_id = ${validated.recordId},
+      input_applied_sequence = ${validated.sequence},
+      state = CASE
+        WHEN state IN ('admitted', 'ready') THEN 'input-applied'
+        ELSE state
+      END
+    WHERE submission_id = ${validated.submissionId}
+   RETURNING *, ${definitionJson(sql)} AS agent_digests_json`.pipe(rows.submissions.write, Effect.mapError(internalFailure(operation)));
+	});
 	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);
-			yield* requireOwner(operation, submission);
-			if (submission.input_applied_record_id !== null) {
-				if (submission.input_applied_record_id === validated.recordId && submission.input_applied_sequence === validated.sequence) return;
-				return yield* corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, "A different canonical input marker is already recorded for this Submission.");
-			}
-			yield* sql`
-          UPDATE effect_agent_submissions
-          SET
-            input_applied_record_id = ${validated.recordId},
-            input_applied_sequence = ${validated.sequence},
-            state = CASE
-              WHEN state IN ('admitted', 'ready') THEN 'input-applied'
-              ELSE state
-            END
-          WHERE submission_id = ${validated.submissionId}
-         RETURNING *, ${definitionJson(sql)} AS agent_digests_json`.pipe(rows.submissions.write, Effect.mapError(internalFailure(operation)));
-		}));
+		yield* inWriteTransaction(operation, markInputAppliedInTransaction(validated));
 		yield* hitFailpoint("ledger:mark-input-applied:after", operation);
 	});
+	const appendInput = Effect.fnUntraced(function* (submissionId, request) {
+		const operation = "append original input and context";
+		const prepared = yield* prepareCanonicalAppend(request).pipe(Effect.provideService(Crypto.Crypto, crypto));
+		const record = prepared.request.batch.records[0];
+		const context = prepared.request.executions?.flatMap((update) => update.facts ?? []).find(({ payload }) => payload._tag === "RunContextRecorded");
+		if (prepared.request.executions?.length !== 1 || prepared.request.executions[0]?.previousRevision !== 0 || prepared.request.batch.records.length !== 1 || record?.payload._tag !== "UserInputRecorded" || record.payload.kind !== "user" || record.payload.submissionId !== submissionId || record.payload.runId !== runIdForSubmission(submissionId) || record.recordId !== submissionInputRecordId(submissionId) || prepared.request.batch.batchId !== submissionInputBatchId(submissionId) || context?.payload._tag === "RunContextRecorded" && context.payload.historyThrough !== prepared.request.expectedTailSequence) return yield* ThreadStoreError.make({
+			operation,
+			message: "Original input publication has a different context boundary"
+		});
+		const mapError = (cause) => ThreadStoreError.make({
+			operation,
+			message: cause.message,
+			cause
+		});
+		yield* journal.prepareAppend(prepared.raw).pipe(Effect.mapError(mapError));
+		return yield* owner.withProgress(prepared.request.threadId, owner.withMutation(Effect.gen(function* () {
+			yield* hitFailpoint("append:before", operation);
+			yield* hitFailpoint("ledger:mark-input-applied:before", operation);
+			const result = yield* journal.withWriteTransaction(operation)(Effect.gen(function* () {
+				const submission = yield* requireSubmission(operation, submissionId);
+				yield* requireOwner(operation, submission);
+				if (submission.thread_id !== prepared.request.threadId) return yield* LedgerError.make({
+					operation,
+					message: "Original input belongs to another Thread"
+				});
+				const result = yield* journal.appendPrepared(prepared.raw);
+				yield* markInputAppliedInTransaction(MarkInputAppliedRequest.make({
+					submissionId,
+					recordId: record.recordId,
+					sequence: result.firstSequence
+				}));
+				return result;
+			})).pipe(Effect.mapError((error) => error._tag === "DoAppendConflict" ? AppendConflict.make({
+				threadId: prepared.request.threadId,
+				batchId: prepared.request.batch.batchId,
+				reason: error.reason,
+				...error.actualTailSequence === void 0 ? {} : { actualTailSequence: error.actualTailSequence }
+			}) : error._tag === "OwnershipLost" ? error : mapError(error)));
+			yield* hitFailpoint("ledger:mark-input-applied:after", operation);
+			yield* hitFailpoint("append:after", operation);
+			return result;
+		}).pipe(Effect.mapError((error) => error._tag === "OwnershipLost" || error._tag === "ThreadStoreError" || error._tag === "AppendConflict" ? error : mapError(error)))));
+	});
 	const publish = Effect.fn("DoSubmissionLedger.publishSettlement")(function* (input) {
 		const operation = "publish settlement";
 		const { request, record, settlement } = yield* validatePublication(input);
@@ -899,7 +982,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);
@@ -1059,9 +1142,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,
@@ -1069,36 +1152,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;
@@ -1668,20 +1757,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,
@@ -1691,11 +1781,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);
@@ -1704,7 +1796,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);
@@ -1717,8 +1809,8 @@ const makeServices = Effect.fnUntraced(function* () {
 			const abortRow = yield* readAbortIntent(operation, validated.submissionId);
 			if (Option.isSome(abortRow)) abortIntent = yield* abortIntentFromRow(operation, submissionRow, validated.submissionId, abortRow.value);
 			const joinRows = (yield* cached(rows.submissions.by("joined_host_submission_id", validated.submissionId), operation)).filter((row) => row.joined_host_submission_id === validated.submissionId).sort((a, b) => a.queue_sequence - b.queue_sequence);
-			const joinSubmissions = yield* decodeSubmissionRows(operation, validated.submissionId, joinRows);
-			const joins = yield* Effect.forEach(joinSubmissions, (row) => decodeJoinSnapshot({
+			const joins = [];
+			for (const row of joinRows) joins.push(yield* decodeJoinSnapshot({
 				submissionId: row.submission_id,
 				state: row.state,
 				hostSubmissionId: validated.submissionId
@@ -1734,16 +1826,18 @@ const makeServices = Effect.fnUntraced(function* () {
 				}).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submissions", validated.submissionId, error.message)));
 			}
 			const decisionRows = yield* readApprovalDecisions(operation, validated.submissionId);
-			const approvalDecisions = yield* Effect.forEach(decisionRows, (row) => approvalIntentFromRow(operation, row));
+			const approvalDecisions = [];
+			for (const row of decisionRows) approvalDecisions.push(yield* approvalIntentFromRow(operation, row));
 			const resolutionRows = yield* readUnknownResolutions(operation, validated.submissionId);
-			const unknownResolutions = yield* Effect.forEach(resolutionRows, (row) => unknownResolutionIntentFromRow(operation, row));
+			const unknownResolutions = [];
+			for (const row of resolutionRows) unknownResolutions.push(yield* unknownResolutionIntentFromRow(operation, row));
 			const childReservationRows = (yield* cached(rows.childReservations.by("parent_submission_id", validated.submissionId), operation)).filter((row) => row.parent_submission_id === validated.submissionId).sort((a, b) => a.parent_tool_call_id.localeCompare(b.parent_tool_call_id));
-			const decodedChildReservations = yield* decodeChildReservationRows(operation, validated.submissionId, childReservationRows);
-			const childReservations = yield* Effect.forEach(decodedChildReservations, (row) => childReservationSnapshotFromRow(operation, row));
+			const childReservations = [];
+			for (const row of childReservationRows) childReservations.push(yield* childReservationSnapshotFromRow(operation, row));
 			const markers = yield* readChildSettlementMarkers(operation, validated.submissionId);
 			const markersByChild = new Map(markers.map((row) => [row.child_submission_id, row]));
 			const childAttachments = [];
-			for (const row of decodedChildReservations) {
+			for (const row of childReservationRows) {
 				if (row.child_submission_id === null) continue;
 				const child = yield* readSubmission(operation, row.child_submission_id);
 				if (Option.isSome(child)) {
@@ -1794,6 +1888,7 @@ const makeServices = Effect.fnUntraced(function* () {
 		resolveAdmission,
 		selectHead,
 		markInputApplied,
+		appendInput,
 		finalizeSettlement: (request) => owner.withMutation(finalizeSettlement(request)),
 		requestAbort,
 		stopWorker,
@@ -1811,6 +1906,7 @@ const makeServices = Effect.fnUntraced(function* () {
 		beginChildBudgetRelease,
 		releaseChildBudget,
 		scanNonterminal,
+		listNonterminal,
 		loadRecoverySnapshot,
 		readAbortIntent: readAbortIntentForSubmission
 	})).pipe(Context.add(StorageOwner, owner), Context.add(SettlementPublisher, { publish }));