@effect-agent/storage-sqlite 0.1.0-beta.42 → 0.1.0-beta.45

package/src/sqlite-ledger.ts

@@ -277,12 +277,15 @@ const decodeSuspensionSnapshot = Schema.decodeUnknownEffect(SuspensionSnapshot);
 const decodeApprovalDecisionIntent = Schema.decodeUnknownEffect(ApprovalDecisionIntent);
 const decodeUnknownResolutionIntent = Schema.decodeUnknownEffect(UnknownResolutionIntent);
 const decodeParentLinkage = Schema.decodeUnknownEffect(ParentLinkage);
+
 const decodeChildReservationSnapshotUnknown = Schema.decodeUnknownEffect(
   ChildBudgetReservationSnapshot,
 );
+
 const decodeChildAttachmentSnapshot = Schema.decodeUnknownEffect(ChildAttachmentSnapshot);
 const equivalentPersistedJson = Schema.toEquivalence(PersistedJson);
 const equivalentUnknownResolution = Schema.toEquivalence(UnknownResolution);
+
 const isSqliteTransactionFailure = Schema.is(
   Schema.Union([SqliteStorageError, SqliteWriteContention]),
 );
@@ -309,6 +312,7 @@ const sqlFailure =
             operation,
             message: error.message,
           });
+
     return internalFailure(operation)(internal);
   };
 
@@ -390,7 +394,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       FROM effect_agent_submissions
       WHERE submission_id = ${submissionId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
+
     const decoded = yield* decodeSubmissionRows(operation, submissionId, rows);
+
     if (decoded.length > 1) {
       return yield* corruptionFailure(
         operation,
@@ -399,6 +405,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         "A submission primary key returned more than one row.",
       );
     }
+
     return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
   });
 
@@ -407,12 +414,14 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     submissionId: string,
   ): Effect.fn.Return<SubmissionRow, LedgerError> {
     const submission = yield* readSubmission(operation, submissionId);
+
     if (Option.isNone(submission)) {
       return yield* LedgerError.make({
         operation,
         message: `Unknown submission ${submissionId}.`,
       });
     }
+
     return submission.value;
   });
 
@@ -431,12 +440,14 @@ 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)));
+
     if (decoded.length > 1) {
       return yield* corruptionFailure(
         operation,
@@ -445,6 +456,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         "An ownership primary key returned more than one row.",
       );
     }
+
     return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
   });
 
@@ -455,6 +467,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     const threads = yield* journal
       .getThread(threadId)
       .pipe(Effect.mapError(internalFailure(operation)));
+
     return threads.length === 0 ? EPOCH_ZERO : threads[0].producer_epoch;
   });
 
@@ -469,13 +482,17 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     ownershipToken: string,
   ): Effect.fn.Return<OwnershipRow, OwnershipLost | LedgerError> {
     const ownership = yield* readOwnership(operation, submission.submission_id);
+
     if (Option.isNone(ownership) || ownership.value.ownership_token !== ownershipToken) {
       const actualEpoch = yield* threadEpoch(operation, submission.thread_id);
+
       const submissionId = yield* Schema.decodeUnknownEffect(
         SubmissionSnapshot.fields.submissionId,
       )(submission.submission_id).pipe(Effect.mapError(internalFailure(operation)));
+
       return yield* OwnershipLost.make({ submissionId, actualEpoch });
     }
+
     return ownership.value;
   });
 
@@ -494,6 +511,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           ),
         ),
       );
+
       const inputPayload = yield* parseStoredJsonText(row.input_json).pipe(
         Effect.mapError((error) =>
           corruptionFailure(
@@ -504,6 +522,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           ),
         ),
       );
+
       if ((row.parent_submission_id === null) !== (row.parent_tool_call_id === null)) {
         return yield* corruptionFailure(
           operation,
@@ -512,6 +531,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           "A parent linkage must record both the parent Submission and the parent Tool Call.",
         );
       }
+
       return yield* decodeSubmissionSnapshotUnknown({
         submissionId: row.submission_id,
         threadId: row.thread_id,
@@ -566,12 +586,14 @@ 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)));
+
     if (decoded.length > 1) {
       return yield* corruptionFailure(
         operation,
@@ -580,6 +602,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         "A settlement reservation primary key returned more than one row.",
       );
     }
+
     return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
   });
 
@@ -597,12 +620,14 @@ 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)));
+
     if (decoded.length > 1) {
       return yield* corruptionFailure(
         operation,
@@ -611,6 +636,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         "An abort intent primary key returned more than one row.",
       );
     }
+
     return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
   });
 
@@ -631,7 +657,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       FROM effect_agent_child_reservations
       WHERE reservation_id = ${reservationId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
+
     const decoded = yield* decodeChildReservationRows(operation, reservationId, rows);
+
     if (decoded.length > 1) {
       return yield* corruptionFailure(
         operation,
@@ -640,6 +668,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         "A child reservation primary key returned more than one row.",
       );
     }
+
     return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
   });
 
@@ -656,11 +685,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       WHERE parent_submission_id = ${parentSubmissionId}
         AND parent_tool_call_id = ${parentToolCallId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
+
     const decoded = yield* decodeChildReservationRows(
       operation,
       `${parentSubmissionId}/${parentToolCallId}`,
       rows,
     );
+
     if (decoded.length > 1) {
       return yield* corruptionFailure(
         operation,
@@ -669,6 +700,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         "A parent Tool Call returned more than one child reservation.",
       );
     }
+
     return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
   });
 
@@ -685,13 +717,16 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         row.reservation_id,
         error.message,
       );
+
     const allocation = yield* parseStoredJsonText(row.allocation_json).pipe(
       Effect.mapError(rowFailure),
     );
+
     const accounting =
       row.accounting_json === null
         ? undefined
         : yield* parseStoredJsonText(row.accounting_json).pipe(Effect.mapError(rowFailure));
+
     return yield* decodeChildReservationSnapshotUnknown({
       reservationId: row.reservation_id,
       parentSubmissionId: row.parent_submission_id,
@@ -724,6 +759,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",
@@ -775,6 +811,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",
@@ -800,6 +837,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         ),
       ),
     );
+
     return yield* decodeUnknownResolutionIntent({
       submissionId: row.submission_id,
       toolCallId: row.tool_call_id,
@@ -826,6 +864,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       submission: SubmissionRow,
     ): Effect.fn.Return<ReadonlyArray<typeof ToolCallIdSchema.Type>, LedgerError> {
       if (submission.unknown_tool_call_ids_json === null) return [];
+
       return yield* decodeToolCallIdsText(submission.unknown_tool_call_ids_json).pipe(
         Effect.mapError((error) =>
           corruptionFailure(
@@ -851,18 +890,21 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       submissionId: SubmissionId,
     ): Effect.fn.Return<string | undefined, LedgerError> {
       const recordId = submissionAbortRecordId(submissionId);
+
       const rows = yield* sql<Record<string, unknown>>`
         SELECT record_id
         FROM effect_agent_canonical_records
         WHERE thread_id = ${threadId}
           AND record_id = ${recordId}
       `.pipe(Effect.mapError(sqlFailure(operation)));
+
       const decoded = yield* decodeRows(
         Schema.Array(CanonicalRecordIdRow),
         "effect_agent_canonical_records",
         `${threadId}/${recordId}`,
         rows,
       ).pipe(Effect.mapError(internalFailure(operation)));
+
       return decoded.length === 0 ? undefined : recordId;
     },
   );
@@ -878,6 +920,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       submission.thread_id,
       submissionId,
     );
+
     return yield* decodeAbortIntent({
       submissionId: row.submission_id,
       author: row.author,
@@ -901,22 +944,29 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   const admit: SubmissionLedger["Service"]["admit"] = Effect.fn("SqliteSubmissionLedger.admit")(
     function* (request: AdmissionRequest) {
       const operation = "ledger admit";
+
       const validated = yield* Schema.decodeUnknownEffect(Schema.toType(AdmissionRequest))(
         request,
       ).pipe(Effect.mapError(internalFailure(operation)));
+
       const inputJson = yield* encodePersistedJsonText(validated.inputPayload).pipe(
         Effect.mapError(internalFailure(operation)),
       );
+
       const agentDigestsJson = yield* encodeDefinitionDigestsText(validated.agentDigests).pipe(
         Effect.mapError(internalFailure(operation)),
       );
+
       const mintedSubmissionId = yield* mintIdentifier("submission", operation);
       const mintedReceiptId = yield* mintIdentifier("receipt", operation);
+
       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* sql<Record<string, unknown>>`
             SELECT ${sql.literal(SUBMISSION_COLUMNS)}
             FROM effect_agent_submissions
@@ -924,7 +974,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               AND principal = ${validated.principal}
               AND idempotency_key = ${validated.idempotencyKey}
           `.pipe(Effect.mapError(sqlFailure(operation)));
+
           const existing = yield* decodeSubmissionRows(operation, keyRowKey, existingRows);
+
           if (existing.length > 1) {
             return yield* corruptionFailure(
               operation,
@@ -942,6 +994,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
                   existing[0].parent_tool_call_id === null
                 : existing[0].parent_submission_id === validated.parentLinkage.parentSubmissionId &&
                   existing[0].parent_tool_call_id === validated.parentLinkage.parentToolCallId;
+
             if (existing[0].input_digest !== validated.inputDigest || !sameLinkage) {
               return yield* AdmissionConflict.make({
                 threadId: validated.threadId,
@@ -951,6 +1004,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
                 attemptedInputDigest: validated.inputDigest,
               });
             }
+
             return yield* decodeAdmissionResult({
               submissionId: existing[0].submission_id,
               receiptId: existing[0].receipt_id,
@@ -965,15 +1019,18 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             FROM effect_agent_submissions
             WHERE thread_id = ${validated.threadId}
           `.pipe(Effect.mapError(sqlFailure(operation)));
+
           const decodedMax = yield* decodeRows(
             Schema.Array(MaxQueueSequenceRow),
             "effect_agent_submissions",
             validated.threadId,
             maxRows,
           ).pipe(Effect.mapError(internalFailure(operation)));
+
           const queueSequence = yield* decodeQueueSequence(
             (decodedMax[0]?.max_queue_sequence ?? 0) + 1,
           ).pipe(Effect.mapError(internalFailure(operation)));
+
           const now = yield* currentInstant;
 
           yield* sql`
@@ -1021,7 +1078,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           }).pipe(Effect.mapError(internalFailure(operation)));
         }),
       );
+
       yield* hitFailpoint("ledger:admit:after", operation);
+
       return result;
     },
   );
@@ -1030,16 +1089,20 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.markReady",
   )(function* (request: MarkReadyRequest) {
     const operation = "ledger mark ready";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(MarkReadyRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     yield* hitFailpoint("ledger:mark-ready:before", operation);
     yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const submission = yield* requireSubmission(operation, validated.submissionId);
+
         if (submission.state !== "admitted") return;
         const now = yield* currentInstant;
+
         yield* sql`
           UPDATE effect_agent_submissions
           SET state = 'ready', ready_at = ${now.iso}
@@ -1053,14 +1116,19 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   const lookup: SubmissionLedger["Service"]["lookup"] = Effect.fn("SqliteSubmissionLedger.lookup")(
     function* (request: SubmissionLookup) {
       const operation = "ledger lookup";
+
       const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SubmissionLookup))(
         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 rows = yield* sql<Record<string, unknown>>`
       SELECT ${sql.literal(SUBMISSION_COLUMNS)}
       FROM effect_agent_submissions
@@ -1068,11 +1136,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         AND principal = ${validated.principal}
         AND idempotency_key = ${validated.idempotencyKey}
     `.pipe(Effect.mapError(sqlFailure(operation)));
+
       const decoded = yield* decodeSubmissionRows(
         operation,
         `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`,
         rows,
       );
+
       if (decoded.length > 1) {
         return yield* corruptionFailure(
           operation,
@@ -1082,6 +1152,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         );
       }
       if (decoded.length === 0) return Option.none();
+
       return Option.some(yield* decodeSubmissionSnapshot(operation, decoded[0]));
     },
   );
@@ -1093,9 +1164,11 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.resolveAdmission",
   )(function* (request: SubmissionLookupByKey) {
     const operation = "ledger resolve admission";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SubmissionLookupByKey))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     const rows = yield* sql<Record<string, unknown>>`
       SELECT ${sql.literal(SUBMISSION_COLUMNS)}
       FROM effect_agent_submissions
@@ -1103,11 +1176,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         AND principal = ${validated.principal}
         AND idempotency_key = ${validated.idempotencyKey}
     `.pipe(Effect.mapError(sqlFailure(operation)));
+
     const decoded = yield* decodeSubmissionRows(
       operation,
       `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`,
       rows,
     );
+
     if (decoded.length > 1) {
       return yield* corruptionFailure(
         operation,
@@ -1117,6 +1192,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       );
     }
     if (decoded.length === 0) return AdmissionNotAdmitted.make();
+
     return AdmissionAdmitted.make({
       submission: yield* decodeSubmissionSnapshot(operation, decoded[0]),
     });
@@ -1125,12 +1201,16 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   const claim: SubmissionLedger["Service"]["claim"] = Effect.fn("SqliteSubmissionLedger.claim")(
     function* (request: ClaimRequest) {
       const operation = "ledger claim";
+
       const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ClaimRequest))(
         request,
       ).pipe(Effect.mapError(internalFailure(operation)));
+
       const attemptId = yield* mintIdentifier("attempt", operation);
       const ownershipToken = yield* mintIdentifier("owner", operation);
+
       yield* hitFailpoint("ledger:claim:before", operation);
+
       const claimed = yield* inWriteTransaction(
         operation,
         Effect.gen(function* () {
@@ -1142,7 +1222,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             ORDER BY queue_sequence ASC
             LIMIT 1
           `.pipe(Effect.mapError(sqlFailure(operation)));
+
           const heads = yield* decodeSubmissionRows(operation, validated.threadId, headRows);
+
           if (heads.length === 0) return Option.none<Claim>();
           const head = heads[0];
 
@@ -1161,11 +1243,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 
           const now = yield* currentInstant;
           const ownership = yield* readOwnership(operation, head.submission_id);
+
           if (Option.isSome(ownership)) {
             const expiresAt = yield* timestampMillis(
               operation,
               head.submission_id,
             )(ownership.value.lease_expires_at);
+
             // A live lease blocks every new claim; expiry alone only revokes the liveness
             // assumption — correctness stays with producer-epoch fencing (D5).
             if (expiresAt > now.millis) return Option.none<Claim>();
@@ -1178,7 +1262,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           const threads = yield* journal
             .getThread(head.thread_id)
             .pipe(Effect.mapError(internalFailure(operation)));
+
           let producerEpoch: number;
+
           if (threads.length === 0) {
             producerEpoch = 1;
             yield* sql`
@@ -1206,6 +1292,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           }
 
           const leaseExpiresAt = new Date(now.millis + config.ownershipLeaseDuration).toISOString();
+
           yield* sql`
             INSERT INTO effect_agent_submission_ownership (
               submission_id,
@@ -1266,6 +1353,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               ),
             ),
           );
+
           return Option.some(
             yield* decodeClaim({
               submissionId: head.submission_id,
@@ -1278,7 +1366,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           );
         }),
       );
+
       yield* hitFailpoint("ledger:claim:after", operation);
+
       return claimed;
     },
   );
@@ -1287,29 +1377,37 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.renewOwnership",
   )(function* (request: RenewOwnershipRequest) {
     const operation = "ledger renew ownership";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(RenewOwnershipRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     yield* hitFailpoint("ledger:renew:before", operation);
+
     const renewal = yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const submission = yield* requireSubmission(operation, validated.submissionId);
+
         yield* requireOwnership(operation, submission, validated.ownershipToken);
         const now = yield* currentInstant;
         const leaseExpiresAt = new Date(now.millis + config.ownershipLeaseDuration).toISOString();
+
         yield* sql`
           UPDATE effect_agent_submission_ownership
           SET lease_expires_at = ${leaseExpiresAt}
           WHERE submission_id = ${validated.submissionId}
         `.pipe(Effect.mapError(sqlFailure(operation)));
+
         return yield* decodeOwnershipRenewal({
           ownershipToken: validated.ownershipToken,
           leaseExpiresAt,
         }).pipe(Effect.mapError(internalFailure(operation)));
       }),
     );
+
     yield* hitFailpoint("ledger:renew:after", operation);
+
     return renewal;
   });
 
@@ -1317,14 +1415,17 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.releaseOwnership",
   )(function* (request: ReleaseOwnershipRequest) {
     const operation = "ledger release ownership";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ReleaseOwnershipRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     yield* hitFailpoint("ledger:release:before", operation);
     yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const submission = yield* requireSubmission(operation, validated.submissionId);
+
         yield* requireOwnership(operation, submission, validated.ownershipToken);
         yield* sql`
           DELETE FROM effect_agent_submission_ownership
@@ -1346,14 +1447,17 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.markInputApplied",
   )(function* (request: MarkInputAppliedRequest) {
     const operation = "ledger mark input applied";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(MarkInputAppliedRequest))(
       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* requireOwnership(operation, submission, validated.ownershipToken);
         if (submission.input_applied_record_id !== null) {
           if (
@@ -1362,6 +1466,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           ) {
             return;
           }
+
           return yield* corruptionFailure(
             operation,
             "effect_agent_submissions",
@@ -1389,29 +1494,36 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.reserveSettlement",
   )(function* (request: SettlementReservation) {
     const operation = "ledger reserve settlement";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SettlementReservation))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     const recordJson = yield* encodeRecordEnvelopeText(validated.record).pipe(
       Effect.mapError(internalFailure(operation)),
     );
+
     yield* hitFailpoint("ledger:reserve-settlement:before", operation);
+
     const reserved = yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const existing = yield* readReservation(operation, validated.submissionId);
+
         if (Option.isSome(existing)) {
           const identical =
             existing.value.settlement_id === validated.settlementId &&
             existing.value.outcome === validated.outcome &&
             existing.value.record_digest === validated.recordDigest &&
             existing.value.record_json === recordJson;
+
           if (!identical) {
             return yield* SettlementConflict.make({
               submissionId: validated.submissionId,
               existingOutcome: existing.value.outcome,
             });
           }
+
           const record = yield* decodeRecordEnvelopeText(existing.value.record_json).pipe(
             Effect.mapError((error) =>
               corruptionFailure(
@@ -1422,6 +1534,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               ),
             ),
           );
+
           return ReservedSettlement.make({
             submissionId: validated.submissionId,
             settlementId: validated.settlementId,
@@ -1433,6 +1546,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         }
 
         const submission = yield* requireSubmission(operation, validated.submissionId);
+
         if (submission.state === "settled") {
           if (submission.settled_outcome === null) {
             return yield* corruptionFailure(
@@ -1442,6 +1556,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               "A settled Submission carries no terminal outcome.",
             );
           }
+
           return yield* SettlementConflict.make({
             submissionId: validated.submissionId,
             existingOutcome: submission.settled_outcome,
@@ -1456,13 +1571,16 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           // ABORTED settlement (`terminalizing` is the same pass's crash replay). Every other
           // reservation stays fenced by the target lane's live ownership.
           let queuedAbortSettlement = false;
+
           if (
             validated.outcome === "aborted" &&
             (submission.state === "ready" || submission.state === "terminalizing")
           ) {
             const abortIntent = yield* readAbortIntent(operation, validated.submissionId);
+
             if (Option.isSome(abortIntent)) {
               const ownership = yield* readOwnership(operation, validated.submissionId);
+
               queuedAbortSettlement = Option.isNone(ownership);
             }
           }
@@ -1471,6 +1589,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           }
         }
         const now = yield* currentInstant;
+
         yield* sql`
           INSERT INTO effect_agent_settlement_reservations (
             submission_id,
@@ -1495,6 +1614,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           SET state = 'terminalizing'
           WHERE submission_id = ${validated.submissionId}
         `.pipe(Effect.mapError(sqlFailure(operation)));
+
         return ReservedSettlement.make({
           submissionId: validated.submissionId,
           settlementId: validated.settlementId,
@@ -1505,7 +1625,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         });
       }),
     );
+
     yield* hitFailpoint("ledger:reserve-settlement:after", operation);
+
     return reserved;
   });
 
@@ -1513,14 +1635,18 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.finalizeSettlement",
   )(function* (request: SettlementFinalization) {
     const operation = "ledger finalize settlement";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SettlementFinalization))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     yield* hitFailpoint("ledger:finalize-settlement:before", operation);
+
     const settlement = yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const reservation = yield* readReservation(operation, validated.submissionId);
+
         if (Option.isNone(reservation)) {
           return yield* LedgerError.make({
             operation,
@@ -1533,6 +1659,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             existingOutcome: reservation.value.outcome,
           });
         }
+
         const reservationRecord = yield* decodeRecordEnvelopeText(
           reservation.value.record_json,
         ).pipe(
@@ -1545,7 +1672,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             ),
           ),
         );
+
         const settlementFailure = settlementFailureFromRecord(reservationRecord);
+
         if ((reservation.value.outcome === "failed") !== (settlementFailure !== undefined)) {
           return yield* corruptionFailure(
             operation,
@@ -1555,6 +1684,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           );
         }
         const submission = yield* requireSubmission(operation, validated.submissionId);
+
         if (submission.state === "settled") {
           if (reservation.value.finalized_at === null) {
             return yield* corruptionFailure(
@@ -1564,6 +1694,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               "A settled Submission's reservation carries no finalization timestamp.",
             );
           }
+
           return yield* decodeSettlement({
             submissionId: validated.submissionId,
             settlementId: validated.settlementId,
@@ -1574,6 +1705,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           }).pipe(Effect.mapError(internalFailure(operation)));
         }
         const now = yield* currentInstant;
+
         yield* sql`
           UPDATE effect_agent_submissions
           SET state = 'settled', settled_outcome = ${reservation.value.outcome}
@@ -1588,6 +1720,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           DELETE FROM effect_agent_submission_ownership
           WHERE submission_id = ${validated.submissionId}
         `.pipe(Effect.mapError(sqlFailure(operation)));
+
         return yield* decodeSettlement({
           submissionId: validated.submissionId,
           settlementId: validated.settlementId,
@@ -1598,7 +1731,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         }).pipe(Effect.mapError(internalFailure(operation)));
       }),
     );
+
     yield* hitFailpoint("ledger:finalize-settlement:after", operation);
+
     return settlement;
   });
 
@@ -1606,14 +1741,18 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.requestAbort",
   )(function* (request: AbortCommand) {
     const operation = "ledger request abort";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(AbortCommand))(request).pipe(
       Effect.mapError(internalFailure(operation)),
     );
+
     yield* hitFailpoint("ledger:request-abort:before", operation);
+
     const intent = yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const submission = yield* requireSubmission(operation, validated.submissionId);
+
         if (submission.state === "settled") {
           if (submission.settled_outcome === null) {
             return yield* corruptionFailure(
@@ -1623,6 +1762,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               "A settled Submission carries no terminal outcome.",
             );
           }
+
           return yield* SettlementConflict.make({
             submissionId: validated.submissionId,
             existingOutcome: submission.settled_outcome,
@@ -1640,15 +1780,18 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               "A joined Submission carries no host linkage.",
             );
           }
+
           const hostSubmissionId = yield* decodeSubmissionId(
             submission.joined_host_submission_id,
           ).pipe(Effect.mapError(internalFailure(operation)));
+
           return yield* JoinedToHost.make({
             submissionId: validated.submissionId,
             hostSubmissionId,
           });
         }
         const existing = yield* readAbortIntent(operation, validated.submissionId);
+
         if (Option.isSome(existing)) {
           return yield* abortIntentFromRow(
             operation,
@@ -1658,6 +1801,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           );
         }
         const now = yield* currentInstant;
+
         yield* sql`
           INSERT INTO effect_agent_abort_intents (
             submission_id,
@@ -1671,11 +1815,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             ${now.iso}
           )
         `.pipe(Effect.mapError(sqlFailure(operation)));
+
         const canonicalRecordId = yield* canonicalAbortRecordId(
           operation,
           submission.thread_id,
           validated.submissionId,
         );
+
         return yield* decodeAbortIntent({
           submissionId: validated.submissionId,
           author: validated.author,
@@ -1685,7 +1831,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         }).pipe(Effect.mapError(internalFailure(operation)));
       }),
     );
+
     yield* hitFailpoint("ledger:request-abort:after", operation);
+
     return intent;
   });
 
@@ -1693,14 +1841,18 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.claimJoining",
   )(function* (request: ClaimJoiningRequest) {
     const operation = "ledger claim joining";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ClaimJoiningRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     yield* hitFailpoint("ledger:claim-joining:before", operation);
+
     const claims = yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const host = yield* requireSubmission(operation, validated.hostSubmissionId);
+
         if (host.thread_id !== validated.threadId) {
           return yield* LedgerError.make({
             operation,
@@ -1709,6 +1861,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         }
         // The host Attempt already owns the lane; no epoch bump happens here (plan §2.5).
         yield* requireOwnership(operation, host, validated.ownershipToken);
+
         const laterRows = yield* sql<Record<string, unknown>>`
           SELECT ${sql.literal(SUBMISSION_COLUMNS)}
           FROM effect_agent_submissions
@@ -1716,8 +1869,10 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             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: Array<JoiningClaim> = [];
+
         for (const row of later) {
           if (claimed.length >= validated.maxCount) break;
           // Rows already claimed by THIS host extend its contiguous prefix and are skipped;
@@ -1740,6 +1895,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             SET state = 'joining', joined_host_submission_id = ${validated.hostSubmissionId}
             WHERE submission_id = ${row.submission_id}
           `.pipe(Effect.mapError(sqlFailure(operation)));
+
           const inputPayload = yield* parseStoredJsonText(row.input_json).pipe(
             Effect.mapError((error) =>
               corruptionFailure(
@@ -1750,6 +1906,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               ),
             ),
           );
+
           claimed.push(
             yield* decodeJoiningClaim({
               submissionId: row.submission_id,
@@ -1758,10 +1915,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             }).pipe(Effect.mapError(internalFailure(operation))),
           );
         }
+
         return claimed;
       }),
     );
+
     yield* hitFailpoint("ledger:claim-joining:after", operation);
+
     return claims;
   });
 
@@ -1769,14 +1929,17 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.markJoined",
   )(function* (request: MarkJoinedRequest) {
     const operation = "ledger mark joined";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(MarkJoinedRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     yield* hitFailpoint("ledger:mark-joined:before", operation);
     yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const submission = yield* requireSubmission(operation, validated.submissionId);
+
         if (submission.joined_host_submission_id === null) {
           return yield* LedgerError.make({
             operation,
@@ -1784,6 +1947,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           });
         }
         const host = yield* requireSubmission(operation, submission.joined_host_submission_id);
+
         // The lane is host-owned: the presented token must own the HOST's ownership period,
         // which also lets a later host Attempt repair a lost marker from history (DUR-016).
         yield* requireOwnership(operation, host, validated.ownershipToken);
@@ -1794,6 +1958,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           ) {
             return;
           }
+
           return yield* corruptionFailure(
             operation,
             "effect_agent_submissions",
@@ -1824,14 +1989,17 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.revertJoining",
   )(function* (request: RevertJoiningRequest) {
     const operation = "ledger revert joining";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(RevertJoiningRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     yield* hitFailpoint("ledger:revert-joining:before", operation);
     yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const submission = yield* requireSubmission(operation, validated.submissionId);
+
         // Idempotent and recovery-only: only a still-`joining` Submission reverts; an
         // already-joined (or already-reverted) Submission is a no-op (DUR-016).
         if (submission.state !== "joining") return;
@@ -1849,17 +2017,22 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.suspend",
   )(function* (request: SuspendRequest) {
     const operation = "ledger suspend";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SuspendRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     const reasonJson = yield* encodeSuspensionReasonText(validated.reason).pipe(
       Effect.mapError(internalFailure(operation)),
     );
+
     yield* hitFailpoint("ledger:suspend:before", operation);
+
     const outcome = yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const submission = yield* requireSubmission(operation, validated.submissionId);
+
         if (submission.state === "settled") {
           if (submission.settled_outcome === null) {
             return yield* corruptionFailure(
@@ -1869,6 +2042,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               "A settled Submission carries no terminal outcome.",
             );
           }
+
           return yield* SettlementConflict.make({
             submissionId: validated.submissionId,
             existingOutcome: submission.settled_outcome,
@@ -1877,6 +2051,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         // An exact terminal outcome is already reserved (DUR-011); suspension would
         // contradict it, so the reservation wins.
         const reservation = yield* readReservation(operation, validated.submissionId);
+
         if (Option.isSome(reservation)) {
           return yield* SettlementConflict.make({
             submissionId: validated.submissionId,
@@ -1890,13 +2065,16 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         if (validated.reason._tag === "ApprovalPending") {
           const decisions = yield* readApprovalDecisions(operation, validated.submissionId);
           const decided = new Set(decisions.map((row) => row.tool_call_id));
+
           if (validated.reason.toolCallIds.every((toolCallId) => decided.has(toolCallId))) {
             return RESUME_IMMEDIATELY;
           }
         } else {
           let allSettled = true;
+
           for (const child of validated.reason.children) {
             const childRow = yield* readSubmission(operation, child.childSubmissionId);
+
             if (Option.isNone(childRow) || childRow.value.state !== "settled") {
               allSettled = false;
               break;
@@ -1907,6 +2085,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           }
         }
         const now = yield* currentInstant;
+
         yield* sql`
           UPDATE effect_agent_submissions
           SET
@@ -1921,10 +2100,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           DELETE FROM effect_agent_submission_ownership
           WHERE submission_id = ${validated.submissionId}
         `.pipe(Effect.mapError(sqlFailure(operation)));
+
         return SUSPENDED;
       }),
     );
+
     yield* hitFailpoint("ledger:suspend:after", operation);
+
     return outcome;
   });
 
@@ -1937,6 +2119,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
   const wakeSuspendedIfCovered = Effect.fn("SqliteSubmissionLedger.wakeSuspendedIfCovered")(
     function* (operation: string, submission: SubmissionRow): Effect.fn.Return<void, LedgerError> {
       if (submission.state !== "suspended" || submission.suspended_reason_json === null) return;
+
       const reason = yield* Schema.decodeEffect(Schema.fromJsonString(SuspensionReason))(
         submission.suspended_reason_json,
       ).pipe(
@@ -1949,9 +2132,11 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           ),
         ),
       );
+
       if (reason._tag !== "ApprovalPending") return;
       const decisions = yield* readApprovalDecisions(operation, submission.submission_id);
       const decided = new Set(decisions.map((row) => row.tool_call_id));
+
       if (!reason.toolCallIds.every((toolCallId) => decided.has(toolCallId))) return;
       yield* sql`
         UPDATE effect_agent_submissions
@@ -1968,14 +2153,18 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.recordApprovalDecision",
   )(function* (command: ApprovalDecisionCommand) {
     const operation = "ledger record approval decision";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ApprovalDecisionCommand))(
       command,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     yield* hitFailpoint("ledger:approval-decision:before", operation);
+
     const intent = yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const submission = yield* requireSubmission(operation, validated.submissionId);
+
         if (submission.state === "settled") {
           if (submission.settled_outcome === null) {
             return yield* corruptionFailure(
@@ -1985,6 +2174,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               "A settled Submission carries no terminal outcome.",
             );
           }
+
           return yield* SettlementConflict.make({
             submissionId: validated.submissionId,
             existingOutcome: submission.settled_outcome,
@@ -1992,6 +2182,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         }
         const decisions = yield* readApprovalDecisions(operation, validated.submissionId);
         const existing = decisions.find((row) => row.tool_call_id === validated.toolCallId);
+
         if (existing !== undefined) {
           // Idempotent per (submissionId, toolCallId): repeating the SAME decision replays
           // the recorded intent unchanged; a divergent re-decision conflicts.
@@ -2002,9 +2193,11 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               existingDecision: existing.decision,
             });
           }
+
           return yield* approvalIntentFromRow(operation, existing);
         }
         const now = yield* currentInstant;
+
         yield* sql`
           INSERT INTO effect_agent_approval_decisions (
             submission_id,
@@ -2023,6 +2216,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           )
         `.pipe(Effect.mapError(sqlFailure(operation)));
         yield* wakeSuspendedIfCovered(operation, submission);
+
         return yield* decodeApprovalDecisionIntent({
           submissionId: validated.submissionId,
           toolCallId: validated.toolCallId,
@@ -2033,7 +2227,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         }).pipe(Effect.mapError(internalFailure(operation)));
       }),
     );
+
     yield* hitFailpoint("ledger:approval-decision:after", operation);
+
     return intent;
   });
 
@@ -2041,14 +2237,17 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.markUnknown",
   )(function* (request: MarkUnknownRequest) {
     const operation = "ledger mark unknown";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(MarkUnknownRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     yield* hitFailpoint("ledger:mark-unknown:before", operation);
     yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const submission = yield* requireSubmission(operation, validated.submissionId);
+
         if (submission.state === "settled") {
           if (submission.settled_outcome === null) {
             return yield* corruptionFailure(
@@ -2058,6 +2257,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               "A settled Submission carries no terminal outcome.",
             );
           }
+
           return yield* SettlementConflict.make({
             submissionId: validated.submissionId,
             existingOutcome: submission.settled_outcome,
@@ -2066,6 +2266,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         // A reserved exact outcome wins over a late Unknown marking (DUR-011); the recovery
         // classifier orders reservation ahead of MarkUnknown for the same reason.
         const reservation = yield* readReservation(operation, validated.submissionId);
+
         if (Option.isSome(reservation)) {
           return yield* SettlementConflict.make({
             submissionId: validated.submissionId,
@@ -2076,13 +2277,16 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         // set while the first recorded reason is kept.
         const existingIds = yield* storedUnknownToolCallIds(operation, submission);
         const known = new Set(existingIds);
+
         const merged = [
           ...existingIds,
           ...validated.toolCallIds.filter((toolCallId) => !known.has(toolCallId)),
         ];
+
         const idsJson = yield* encodeToolCallIdsText(merged).pipe(
           Effect.mapError(internalFailure(operation)),
         );
+
         yield* sql`
           UPDATE effect_agent_submissions
           SET
@@ -2100,17 +2304,22 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.recordUnknownResolution",
   )(function* (command: UnknownResolutionCommand) {
     const operation = "ledger record unknown resolution";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(UnknownResolutionCommand))(
       command,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     const resolutionJson = yield* encodeUnknownResolutionText(validated.resolution).pipe(
       Effect.mapError(internalFailure(operation)),
     );
+
     yield* hitFailpoint("ledger:unknown-resolution:before", operation);
+
     const intent = yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const submission = yield* requireSubmission(operation, validated.submissionId);
+
         if (submission.state === "settled") {
           if (submission.settled_outcome === null) {
             return yield* corruptionFailure(
@@ -2120,6 +2329,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               "A settled Submission carries no terminal outcome.",
             );
           }
+
           return yield* SettlementConflict.make({
             submissionId: validated.submissionId,
             existingOutcome: submission.settled_outcome,
@@ -2127,10 +2337,12 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         }
         const resolutions = yield* readUnknownResolutions(operation, validated.submissionId);
         const existing = resolutions.find((row) => row.tool_call_id === validated.toolCallId);
+
         const existingIntent =
           existing === undefined
             ? undefined
             : yield* unknownResolutionIntentFromRow(operation, existing);
+
         if (
           existingIntent !== undefined &&
           !equivalentUnknownResolution(existingIntent.resolution, validated.resolution)
@@ -2141,12 +2353,14 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           });
         }
         let resolved: UnknownResolutionIntent;
+
         if (existingIntent !== undefined) {
           // Idempotent replay of the recorded intent (author/reason may differ; the stored
           // audit fields win, exactly like requestAbort).
           resolved = existingIntent;
         } else {
           const now = yield* currentInstant;
+
           yield* sql`
             INSERT INTO effect_agent_unknown_resolutions (
               submission_id,
@@ -2164,9 +2378,11 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               ${now.iso}
             )
           `.pipe(Effect.mapError(sqlFailure(operation)));
+
           const resolution = yield* parseStoredJsonText(resolutionJson).pipe(
             Effect.mapError(internalFailure(operation)),
           );
+
           resolved = yield* decodeUnknownResolutionIntent({
             submissionId: validated.submissionId,
             toolCallId: validated.toolCallId,
@@ -2183,6 +2399,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           const markedIds = yield* storedUnknownToolCallIds(operation, submission);
           const covering = yield* readUnknownResolutions(operation, validated.submissionId);
           const coveredIds = new Set(covering.map((row) => row.tool_call_id));
+
           if (markedIds.every((toolCallId) => coveredIds.has(toolCallId))) {
             yield* sql`
               UPDATE effect_agent_submissions
@@ -2194,10 +2411,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             `.pipe(Effect.mapError(sqlFailure(operation)));
           }
         }
+
         return resolved;
       }),
     );
+
     yield* hitFailpoint("ledger:unknown-resolution:after", operation);
+
     return intent;
   });
 
@@ -2205,10 +2425,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.recordChildSettled",
   )(function* (request: ChildSettledNotification) {
     const operation = "ledger record child settled";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ChildSettledNotification))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     yield* hitFailpoint("ledger:child-settled:before", operation);
+
     const outcome = yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
@@ -2218,10 +2441,12 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         // that makes that ordering admissible; earlier states remain a caller error.
         const child = yield* readSubmission(operation, validated.childSubmissionId);
         const childReservation = yield* readReservation(operation, validated.childSubmissionId);
+
         const announced =
           Option.isSome(child) &&
           (child.value.state === "settled" ||
             (child.value.state === "terminalizing" && Option.isSome(childReservation)));
+
         if (!announced) {
           return yield* LedgerError.make({
             operation,
@@ -2231,6 +2456,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         if (parent.state !== "suspended" || parent.suspended_reason_json === null) {
           return NOT_WAITING;
         }
+
         const reason = yield* Schema.decodeEffect(Schema.fromJsonString(SuspensionReason))(
           parent.suspended_reason_json,
         ).pipe(
@@ -2243,6 +2469,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             ),
           ),
         );
+
         if (reason._tag !== "WaitingForChild") {
           return NOT_WAITING;
         }
@@ -2256,10 +2483,12 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
         for (const entry of reason.children) {
           const listed = yield* readSubmission(operation, entry.childSubmissionId);
           const reservation = yield* readReservation(operation, entry.childSubmissionId);
+
           const covered =
             Option.isSome(listed) &&
             (listed.value.state === "settled" ||
               (listed.value.state === "terminalizing" && Option.isSome(reservation)));
+
           if (!covered) {
             return STILL_WAITING;
           }
@@ -2272,10 +2501,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             suspended_at = NULL
           WHERE submission_id = ${validated.parentSubmissionId}
         `.pipe(Effect.mapError(sqlFailure(operation)));
+
         return WOKEN;
       }),
     );
+
     yield* hitFailpoint("ledger:child-settled:after", operation);
+
     return outcome;
   });
 
@@ -2283,22 +2515,28 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.reserveChildBudget",
   )(function* (request: ChildBudgetReservationRequest) {
     const operation = "ledger reserve child budget";
+
     const validated = yield* Schema.decodeUnknownEffect(
       Schema.toType(ChildBudgetReservationRequest),
     )(request).pipe(Effect.mapError(internalFailure(operation)));
+
     const allocationJson = yield* encodePersistedJsonText(validated.allocation).pipe(
       Effect.mapError(internalFailure(operation)),
     );
+
     yield* hitFailpoint("ledger:child-reservation:before", operation);
+
     const reserved = yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const existing = yield* readChildReservation(operation, validated.reservationId);
+
         if (Option.isSome(existing)) {
           const existingSnapshot = yield* childReservationSnapshotFromRow(
             operation,
             existing.value,
           );
+
           // Identical replays short-circuit before the fence, mirroring reserveSettlement: a
           // replay creates nothing, so a recovering caller resumes rather than duplicates.
           const identical =
@@ -2306,6 +2544,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             existing.value.parent_tool_call_id === validated.parentToolCallId &&
             existing.value.allocation_digest === validated.allocationDigest &&
             equivalentPersistedJson(existingSnapshot.allocation, validated.allocation);
+
           if (!identical) {
             return yield* ChildReservationConflict.make({
               reservationId: validated.reservationId,
@@ -2314,16 +2553,19 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
                 "A reservation with this identity exists with a different parent Tool Call or allocation.",
             });
           }
+
           return ReservedChildBudget.make({
             reservation: existingSnapshot,
             replayed: true,
           });
         }
+
         const collision = yield* readChildReservationForCall(
           operation,
           validated.parentSubmissionId,
           validated.parentToolCallId,
         );
+
         if (Option.isSome(collision)) {
           return yield* ChildReservationConflict.make({
             reservationId: validated.reservationId,
@@ -2332,10 +2574,12 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           });
         }
         const parent = yield* requireSubmission(operation, validated.parentSubmissionId);
+
         // Creation is fenced by the parent lane's live ownership (spec §12 step 2): a stale
         // parent Attempt can never create new reservation state.
         yield* requireOwnership(operation, parent, validated.ownershipToken);
         const now = yield* currentInstant;
+
         yield* sql`
           INSERT INTO effect_agent_child_reservations (
             reservation_id,
@@ -2356,6 +2600,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           )
         `.pipe(Effect.mapError(sqlFailure(operation)));
         const inserted = yield* readChildReservation(operation, validated.reservationId);
+
         if (Option.isNone(inserted)) {
           return yield* corruptionFailure(
             operation,
@@ -2364,13 +2609,16 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             "An inserted child reservation row is missing inside its own transaction.",
           );
         }
+
         return ReservedChildBudget.make({
           reservation: yield* childReservationSnapshotFromRow(operation, inserted.value),
           replayed: false,
         });
       }),
     );
+
     yield* hitFailpoint("ledger:child-reservation:after", operation);
+
     return reserved;
   });
 
@@ -2379,14 +2627,18 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
       request: AttachChildToReservationRequest,
     ) {
       const operation = "ledger attach child to reservation";
+
       const validated = yield* Schema.decodeUnknownEffect(
         Schema.toType(AttachChildToReservationRequest),
       )(request).pipe(Effect.mapError(internalFailure(operation)));
+
       yield* hitFailpoint("ledger:child-attach:before", operation);
+
       const attached = yield* inWriteTransaction(
         operation,
         Effect.gen(function* () {
           const existing = yield* readChildReservation(operation, validated.reservationId);
+
           if (Option.isNone(existing)) {
             return yield* LedgerError.make({
               operation,
@@ -2398,6 +2650,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             if (existing.value.child_submission_id === validated.childSubmissionId) {
               return yield* childReservationSnapshotFromRow(operation, existing.value);
             }
+
             return yield* ChildReservationConflict.make({
               reservationId: validated.reservationId,
               status: existing.value.status,
@@ -2405,6 +2658,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             });
           }
           const parent = yield* requireSubmission(operation, existing.value.parent_submission_id);
+
           yield* requireOwnership(operation, parent, validated.ownershipToken);
           if (existing.value.status !== "reserved") {
             return yield* ChildReservationConflict.make({
@@ -2416,6 +2670,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           // Single-store latitude: the admitted child must exist here, so a dangling
           // attachment can never enter the recovery view.
           const child = yield* readSubmission(operation, validated.childSubmissionId);
+
           if (Option.isNone(child)) {
             return yield* LedgerError.make({
               operation,
@@ -2428,6 +2683,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             WHERE reservation_id = ${validated.reservationId}
           `.pipe(Effect.mapError(sqlFailure(operation)));
           const updated = yield* readChildReservation(operation, validated.reservationId);
+
           if (Option.isNone(updated)) {
             return yield* corruptionFailure(
               operation,
@@ -2436,10 +2692,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               "An updated child reservation row is missing inside its own transaction.",
             );
           }
+
           return yield* childReservationSnapshotFromRow(operation, updated.value);
         }),
       );
+
       yield* hitFailpoint("ledger:child-attach:after", operation);
+
       return attached;
     });
 
@@ -2447,17 +2706,22 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.beginChildBudgetRelease",
   )(function* (request: BeginChildBudgetReleaseRequest) {
     const operation = "ledger begin child budget release";
+
     const validated = yield* Schema.decodeUnknownEffect(
       Schema.toType(BeginChildBudgetReleaseRequest),
     )(request).pipe(Effect.mapError(internalFailure(operation)));
+
     const accountingJson = yield* encodePersistedJsonText(validated.accounting).pipe(
       Effect.mapError(internalFailure(operation)),
     );
+
     yield* hitFailpoint("ledger:child-release-pending:before", operation);
+
     const frozen = yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const existing = yield* readChildReservation(operation, validated.reservationId);
+
         if (Option.isNone(existing)) {
           return yield* LedgerError.make({
             operation,
@@ -2469,6 +2733,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             operation,
             existing.value,
           );
+
           // The accounting decision was already frozen exactly once; an identical replay is a
           // no-op and a divergent decision conflicts (spec §12 join step 6).
           if (
@@ -2477,6 +2742,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           ) {
             return existingSnapshot;
           }
+
           return yield* ChildReservationConflict.make({
             reservationId: validated.reservationId,
             status: existing.value.status,
@@ -2484,6 +2750,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           });
         }
         const now = yield* currentInstant;
+
         yield* sql`
           UPDATE effect_agent_child_reservations
           SET
@@ -2493,6 +2760,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           WHERE reservation_id = ${validated.reservationId}
         `.pipe(Effect.mapError(sqlFailure(operation)));
         const updated = yield* readChildReservation(operation, validated.reservationId);
+
         if (Option.isNone(updated)) {
           return yield* corruptionFailure(
             operation,
@@ -2501,10 +2769,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             "An updated child reservation row is missing inside its own transaction.",
           );
         }
+
         return yield* childReservationSnapshotFromRow(operation, updated.value);
       }),
     );
+
     yield* hitFailpoint("ledger:child-release-pending:after", operation);
+
     return frozen;
   });
 
@@ -2512,14 +2783,18 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.releaseChildBudget",
   )(function* (request: ReleaseChildBudgetRequest) {
     const operation = "ledger release child budget";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ReleaseChildBudgetRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     yield* hitFailpoint("ledger:child-release:before", operation);
+
     const released = yield* inWriteTransaction(
       operation,
       Effect.gen(function* () {
         const existing = yield* readChildReservation(operation, validated.reservationId);
+
         if (Option.isNone(existing)) {
           return yield* LedgerError.make({
             operation,
@@ -2539,12 +2814,14 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           });
         }
         const now = yield* currentInstant;
+
         yield* sql`
           UPDATE effect_agent_child_reservations
           SET status = 'released', released_at = ${now.iso}
           WHERE reservation_id = ${validated.reservationId}
         `.pipe(Effect.mapError(sqlFailure(operation)));
         const updated = yield* readChildReservation(operation, validated.reservationId);
+
         if (Option.isNone(updated)) {
           return yield* corruptionFailure(
             operation,
@@ -2553,10 +2830,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             "An updated child reservation row is missing inside its own transaction.",
           );
         }
+
         return yield* childReservationSnapshotFromRow(operation, updated.value);
       }),
     );
+
     yield* hitFailpoint("ledger:child-release:after", operation);
+
     return released;
   });
 
@@ -2572,6 +2852,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     LedgerError
   > {
     const operation = "ledger scan nonterminal";
+
     const rows = yield* (
       cursor === undefined
         ? sql<Record<string, unknown>>`
@@ -2596,11 +2877,15 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           LIMIT ${SCAN_PAGE_SIZE}
         `
     ).pipe(Effect.mapError(sqlFailure(operation)));
+
     const decoded = yield* decodeSubmissionRows(operation, "nonterminal_scan", rows);
+
     const snapshots = yield* Effect.forEach(decoded, (row) =>
       decodeSubmissionSnapshot(operation, row),
     );
+
     const last = decoded[decoded.length - 1];
+
     const next: Option.Option<ScanCursor | undefined> =
       last === undefined || decoded.length < SCAN_PAGE_SIZE
         ? Option.none()
@@ -2608,6 +2893,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             threadId: last.thread_id,
             queueSequence: last.queue_sequence,
           });
+
     return [snapshots, next] as const;
   });
 
@@ -2621,9 +2907,11 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
     "SqliteSubmissionLedger.loadRecoverySnapshot",
   )(function* (request: RecoverySnapshotRequest) {
     const operation = "ledger load recovery snapshot";
+
     const validated = yield* Schema.decodeUnknownEffect(Schema.toType(RecoverySnapshotRequest))(
       request,
     ).pipe(Effect.mapError(internalFailure(operation)));
+
     return yield* sql
       .withTransaction(
         Effect.gen(function* () {
@@ -2632,6 +2920,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 
           let ownership: OwnershipSnapshot | undefined;
           const ownershipRow = yield* readOwnership(operation, validated.submissionId);
+
           if (Option.isSome(ownershipRow)) {
             ownership = yield* decodeOwnershipSnapshot({
               attemptId: ownershipRow.value.attempt_id,
@@ -2642,6 +2931,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           }
 
           let inputApplied: InputAppliedMarker | undefined;
+
           if (
             submissionRow.input_applied_record_id !== null &&
             submissionRow.input_applied_sequence !== null
@@ -2654,6 +2944,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 
           let reservation: SettlementReservationSnapshot | undefined;
           const reservationRow = yield* readReservation(operation, validated.submissionId);
+
           if (Option.isSome(reservationRow)) {
             const record = yield* decodeRecordEnvelopeText(reservationRow.value.record_json).pipe(
               Effect.mapError((error) =>
@@ -2665,9 +2956,11 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
                 ),
               ),
             );
+
             const settlementId = yield* Schema.decodeUnknownEffect(
               SettlementReservationSnapshot.fields.settlementId,
             )(reservationRow.value.settlement_id).pipe(Effect.mapError(internalFailure(operation)));
+
             reservation = SettlementReservationSnapshot.make({
               settlementId,
               outcome: reservationRow.value.outcome,
@@ -2679,6 +2972,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 
           let abortIntent: AbortIntent | undefined;
           const abortRow = yield* readAbortIntent(operation, validated.submissionId);
+
           if (Option.isSome(abortRow)) {
             abortIntent = yield* abortIntentFromRow(
               operation,
@@ -2696,11 +2990,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             WHERE joined_host_submission_id = ${validated.submissionId}
             ORDER BY queue_sequence ASC
           `.pipe(Effect.mapError(sqlFailure(operation)));
+
           const joinSubmissions = yield* decodeSubmissionRows(
             operation,
             validated.submissionId,
             joinRows,
           );
+
           const joins = yield* Effect.forEach(joinSubmissions, (row) =>
             decodeJoinSnapshot({
               submissionId: row.submission_id,
@@ -2710,6 +3006,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           );
 
           let hostSubmissionId: RecoverySnapshot["hostSubmissionId"];
+
           if (submissionRow.joined_host_submission_id !== null) {
             hostSubmissionId = yield* decodeSubmissionId(
               submissionRow.joined_host_submission_id,
@@ -2717,6 +3014,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           }
 
           let suspension: SuspensionSnapshot | undefined;
+
           if (submissionRow.suspended_reason_json !== null && submissionRow.suspended_at !== null) {
             const reason = yield* parseStoredJsonText(submissionRow.suspended_reason_json).pipe(
               Effect.mapError((error) =>
@@ -2728,6 +3026,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
                 ),
               ),
             );
+
             suspension = yield* decodeSuspensionSnapshot({
               reason,
               suspendedAt: submissionRow.suspended_at,
@@ -2744,11 +3043,13 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           }
 
           const decisionRows = yield* readApprovalDecisions(operation, validated.submissionId);
+
           const approvalDecisions = yield* Effect.forEach(decisionRows, (row) =>
             approvalIntentFromRow(operation, row),
           );
 
           const resolutionRows = yield* readUnknownResolutions(operation, validated.submissionId);
+
           const unknownResolutions = yield* Effect.forEach(resolutionRows, (row) =>
             unknownResolutionIntentFromRow(operation, row),
           );
@@ -2762,18 +3063,23 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
             WHERE parent_submission_id = ${validated.submissionId}
             ORDER BY parent_tool_call_id ASC
           `.pipe(Effect.mapError(sqlFailure(operation)));
+
           const decodedChildReservations = yield* decodeChildReservationRows(
             operation,
             validated.submissionId,
             childReservationRows,
           );
+
           const childReservations = yield* Effect.forEach(decodedChildReservations, (row) =>
             childReservationSnapshotFromRow(operation, row),
           );
+
           const childAttachments: Array<ChildAttachmentSnapshot> = [];
+
           for (const row of decodedChildReservations) {
             if (row.child_submission_id === null) continue;
             const child = yield* readSubmission(operation, row.child_submission_id);
+
             if (Option.isNone(child)) continue;
             childAttachments.push(
               yield* decodeChildAttachmentSnapshot({
@@ -2788,6 +3094,7 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
           }
 
           let parentLinkage: ParentLinkage | undefined;
+
           if (
             submissionRow.parent_submission_id !== null &&
             submissionRow.parent_tool_call_id !== null