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

package/src/DoThreadStore.ts

@@ -18,7 +18,6 @@ import { ThreadImport } from "@yielded/agent/thread-import";
 import {
   type ThreadExportRequest,
   AppendConflict,
-  AppendResult,
   CheckpointRejected,
   ThreadCheckpoint,
   ThreadMaterialization,
@@ -104,6 +103,11 @@ const isDoCheckpointConflict = Schema.is(DoCheckpointConflict);
 const ThreadCheckpointJson = Schema.fromJsonString(ThreadCheckpoint);
 const decodeCanonicalRecord = decodeExportRecordJson;
 
+const decodeThreadMaterializationType = Schema.decodeEffect(Schema.toType(ThreadMaterialization));
+const decodeThreadReadRequestType = Schema.decodeEffect(Schema.toType(ThreadReadRequest));
+const decodeThreadTailRequestType = Schema.decodeEffect(Schema.toType(ThreadTailRequest));
+const decodeStorageConfig = Schema.decodeEffect(DoStorageConfigValue);
+
 const storeError = (
   operation: string,
   error: { readonly message: string; readonly diagnostic?: ThreadStoreDiagnostic },
@@ -126,19 +130,6 @@ const schemaStoreError = (operation: string, error: Schema.SchemaError) =>
     }),
   });
 
-const makeOffset = (
-  threadId: ThreadMaterialization["threadId"],
-  sequence: number,
-): Effect.Effect<ObservationOffset, ThreadStoreError> =>
-  Schema.decodeEffect(CanonicalSequence)(sequence).pipe(
-    Effect.flatMap((validatedSequence) =>
-      Schema.decodeEffect(ObservationOffset)(
-        `${DO_OFFSET_PREFIX}${encodeURIComponent(threadId)}:${validatedSequence}`,
-      ),
-    ),
-    Effect.mapError((error) => schemaStoreError("encode observation offset", error)),
-  );
-
 const parseOffset = Effect.fnUntraced(function* (
   threadId: ThreadMaterialization["threadId"],
   offset: ObservationOffset | undefined,
@@ -179,8 +170,8 @@ const encodeCheckpoint = (checkpoint: ThreadCheckpoint): Effect.Effect<string, T
 const envelopes = new WeakMap<object, CanonicalRecordEnvelope>();
 
 const decodeEnvelope = Effect.fnUntraced(function* (row: {
-  readonly batch_id: string;
-  readonly thread_id: string;
+  readonly batch_id: CanonicalRecordEnvelope["batchId"];
+  readonly thread_id: CanonicalRecordEnvelope["threadId"];
   readonly record_json: string;
   readonly sequence: CanonicalSequence;
 }) {
@@ -213,15 +204,11 @@ const decodeEnvelope = Effect.fnUntraced(function* (row: {
     ),
   );
 
-  const threadId = yield* Schema.decodeEffect(CanonicalRecordEnvelope.fields.threadId)(
-    row.thread_id,
-  ).pipe(Effect.mapError((error) => schemaStoreError("decode thread identity", error)));
+  const { thread_id: threadId, batch_id: batchId } = row;
 
-  const offset = yield* makeOffset(threadId, row.sequence);
-
-  const batchId = yield* Schema.decodeEffect(CanonicalRecordEnvelope.fields.batchId)(
-    row.batch_id,
-  ).pipe(Effect.mapError((error) => schemaStoreError("decode batch identity", error)));
+  const offset = ObservationOffset.make(
+    `${DO_OFFSET_PREFIX}${encodeURIComponent(threadId)}:${row.sequence}`,
+  );
 
   const envelope = CanonicalRecordEnvelope.make(
     { threadId, batchId, sequence: row.sequence, offset, record },
@@ -317,9 +304,9 @@ const makeServices = Effect.fnUntraced(function* () {
   const materialize: ThreadStore["Service"]["materialize"] = Effect.fnUntraced(function* (
     request: ThreadMaterialization,
   ) {
-    const validated = yield* Schema.decodeEffect(Schema.toType(ThreadMaterialization))(
-      request,
-    ).pipe(Effect.mapError((error) => schemaStoreError("validate materialization", error)));
+    const validated = yield* decodeThreadMaterializationType(request).pipe(
+      Effect.mapError((error) => schemaStoreError("validate materialization", error)),
+    );
 
     const now = yield* Clock.currentTimeMillis;
 
@@ -362,11 +349,6 @@ const makeServices = Effect.fnUntraced(function* () {
 
             return storeError("append canonical batch", error);
           }),
-          Effect.flatMap((result) =>
-            Schema.decodeEffect(AppendResult)(result).pipe(
-              Effect.mapError((error) => schemaStoreError("decode append result", error)),
-            ),
-          ),
         );
 
       yield* hitFailpoint("append:after");
@@ -391,7 +373,7 @@ const makeServices = Effect.fnUntraced(function* () {
   });
 
   const readEffect = Effect.fnUntraced(function* (request: ThreadReadRequest) {
-    const validated = yield* Schema.decodeEffect(Schema.toType(ThreadReadRequest))(request).pipe(
+    const validated = yield* decodeThreadReadRequestType(request).pipe(
       Effect.mapError((error) => schemaStoreError("validate thread read", error)),
     );
 
@@ -503,7 +485,7 @@ const makeServices = Effect.fnUntraced(function* () {
   const inspectTail: ThreadStore["Service"]["inspectTail"] = Effect.fnUntraced(function* (
     request: ThreadTailRequest,
   ) {
-    const validated = yield* Schema.decodeEffect(Schema.toType(ThreadTailRequest))(request).pipe(
+    const validated = yield* decodeThreadTailRequestType(request).pipe(
       Effect.mapError((error) => schemaStoreError("validate tail inspection", error)),
     );
 
@@ -602,15 +584,7 @@ const makeServices = Effect.fnUntraced(function* () {
       snapshot: journal.state.read,
       tail: (threadId) =>
         journal.getThread(threadId).pipe(
-          Effect.flatMap((rows) =>
-            Schema.decodeEffect(
-              Schema.UndefinedOr(
-                Schema.Struct({
-                  tail_sequence: CanonicalSequence,
-                }),
-              ),
-            )(rows[0]),
-          ),
+          Effect.map((rows) => rows[0]),
           Effect.mapError((error) => storeError("native thread tail", error)),
         ),
     }),
@@ -668,7 +642,7 @@ export const storageConfigLayer = (
   options: DoStorageOptions,
 ): Layer.Layer<DoStorageConfig, DoStorageError> =>
   Layer.effect(DoStorageConfig)(
-    Schema.decodeEffect(DoStorageConfigValue)({
+    decodeStorageConfig({
       observationPollInterval: options.observationPollInterval ?? 25,
       maxStoredValueBytes: options.maxStoredValueBytes ?? DEFAULT_MAX_STORED_VALUE_BYTES,
       verifyOnOpen: options.verifyOnOpen ?? false,

package/src/PortRouting.ts

@@ -570,9 +570,9 @@ const makeRoutedLedgerServices = Effect.fnUntraced(function* (options: RoutedPor
   const routed = SubmissionLedger.of({
     capabilities: local.capabilities,
 
-    admit: (request) =>
+    admit: (request, admissionOptions) =>
       options.ownsThread(request.threadId)
-        ? local.admit(request)
+        ? local.admit(request, admissionOptions)
         : foreignLedgerCall(
             "ledger admit",
             request.threadId,
@@ -824,6 +824,7 @@ const makeRoutedLedgerServices = Effect.fnUntraced(function* (options: RoutedPor
 
     // The local scan IS the whole worklist: one Thread per Object (durability §5).
     scanNonterminal: local.scanNonterminal,
+    ...(local.listNonterminal === undefined ? {} : { listNonterminal: local.listNonterminal }),
 
     readAbortIntent: (request) =>
       submissionTarget("ledger read abort intent", request.submissionId).pipe(
@@ -1046,6 +1047,13 @@ const makeRoutedStoreServices = Effect.fnUntraced(function* (options: RoutedPort
             ).pipe(Effect.map((reply) => reply.range)),
     },
     work: {
+      isOnlyFreshAdmission: (request) => {
+        const prove = local.work?.isOnlyFreshAdmission;
+
+        return prove !== undefined && options.ownsThread(request.threadId)
+          ? prove(request)
+          : Effect.succeed(false);
+      },
       threads: (request) =>
         Effect.flatMap(CurrentNativeSource, (nativeSource) =>
           nativeSource && local.work !== undefined

package/src/internal/do-journal.ts

@@ -1,3 +1,4 @@
+import { SqliteClient } from "@effect/sql-sqlite-do";
 import {
   makeCanonicalStorage,
   recordBatchId,
@@ -21,16 +22,29 @@ import {
   LifecyclePublicationFact,
   LifecyclePublicationError,
 } from "@yielded/agent/lifecycle-publication";
-import { CanonicalRecord, CanonicalSequence } from "@yielded/agent/records";
+import { BatchId, CanonicalRecord, CanonicalSequence } from "@yielded/agent/records";
 import { SqlStorageOwner } from "@yielded/agent/sql-memory-store";
 import {
   type AppendConflict,
+  AppendResult,
   ThreadStoreDiagnostic,
   ThreadStoreError,
 } from "@yielded/agent/thread-store";
-import { Cause, Clock, Effect, Option, Schema, Stream } from "effect";
+import {
+  Cause,
+  Clock,
+  Effect,
+  Option,
+  Predicate,
+  References,
+  Result,
+  Schema,
+  Stream,
+  Tracer,
+} from "effect";
 import * as SqlClient from "effect/sql/SqlClient";
-import { SqlError } from "effect/sql/SqlError";
+import { classifySqliteError, SqlError } from "effect/sql/SqlError";
+import { CurrentTransformer, type Statement } from "effect/sql/Statement";
 
 import {
   type DoStorageFailpointError,
@@ -41,6 +55,7 @@ import {
   DoValueBoundExceeded,
   type DoStorageFailpointLocation,
 } from "../DoStorageError.ts";
+import { isDefaultDoStorageFailpoint } from "../DoStorageFailpoint.ts";
 import { ensureDoStorageLayout } from "./migrations.ts";
 import { ownedState, ownedRows, type OwnedState } from "./owned-state.ts";
 import {
@@ -68,6 +83,12 @@ const MAX_RECORD_CACHE_ENTRIES = 4_096;
 const MAX_BOUND_PARAMETERS = 100;
 const isSqlError = Schema.is(SqlError);
 
+const isNativeClient = Schema.is(
+  Schema.declare<SqliteClient.SqliteClient>((value): value is SqliteClient.SqliteClient =>
+    Predicate.hasProperty(value, SqliteClient.TypeId),
+  ),
+);
+
 const storedTextBytes = (value: string): number => new TextEncoder().encode(value).byteLength;
 
 const chunked = <A>(values: ReadonlyArray<A>, size: number): Array<ReadonlyArray<A>> => {
@@ -94,8 +115,8 @@ const threadRows = ownedRows(
 );
 
 class RecordRow extends Schema.Class<RecordRow>("RecordRow")({
-  batch_id: Schema.fromJsonString(BoundedIdentifier),
-  thread_id: BoundedIdentifier,
+  batch_id: Schema.fromJsonString(BatchId.check(Schema.isMaxLength(MAX_IDENTIFIER_LENGTH))),
+  thread_id: ThreadId.check(Schema.isMaxLength(MAX_IDENTIFIER_LENGTH)),
   record_id: Schema.fromJsonString(BoundedIdentifier),
   record_json: BoundedStoredText,
   sequence: CanonicalSequence,
@@ -200,14 +221,6 @@ const initializedLifecycleSources = new WeakSet<OwnedState>();
 
 export type { RawAppendRequest } from "@yielded/agent-storage-sql/sql-journal";
 
-export class RawAppendResult extends Schema.Class<RawAppendResult>(
-  "@effect-agent/storage-cloudflare/RawAppendResult",
-)({
-  firstSequence: CanonicalSequence,
-  lastSequence: CanonicalSequence,
-  replayed: Schema.Boolean,
-}) {}
-
 export class RawReadRequest extends Schema.Class<RawReadRequest>(
   "@effect-agent/storage-cloudflare/RawReadRequest",
 )({
@@ -317,10 +330,14 @@ const ensureCurrentStorage = Effect.fnUntraced(function* (
   failpoint: DoJournalFailpoint = noFailpoint,
   maxStoredValueBytes: number,
 ) {
-  yield* ensureDoStorageLayout().pipe(Effect.provideService(SqlClient.SqlClient, sql));
-
   const state = yield* ownedState(sql);
   const owner = (yield* SqlStorageOwner) ?? state;
+
+  yield* ensureDoStorageLayout().pipe(
+    Effect.provideService(SqlStorageOwner, owner),
+    Effect.provideService(SqlClient.SqlClient, sql),
+  );
+
   let journal: DoJournal | undefined;
 
   const lifecycle = yield* makeSqlLifecyclePublication(undefined, maxStoredValueBytes).pipe(
@@ -366,6 +383,14 @@ const makeJournal = Effect.fnUntraced(function* (
   const owner = (yield* SqlStorageOwner) ?? state;
   const progress = yield* SqlStorageProgress;
 
+  const nativeDb =
+    isNativeClient(sql) &&
+    sql.config.transformQueryNames === undefined &&
+    sql.config.transformResultNames === undefined &&
+    isDefaultDoStorageFailpoint(failpoint)
+      ? sql.config.storage?.sql
+      : undefined;
+
   const work = yield* makeSqlThreadWork({
     read: (body) => state.read(body),
     write: (body) =>
@@ -478,13 +503,29 @@ const makeJournal = Effect.fnUntraced(function* (
     <A, E extends { readonly _tag: string }>(
       effect: Effect.Effect<A, E>,
     ): Effect.Effect<A, E | DoStorageError> =>
-      state.owner.withMutation(owner.transaction(storageResult(effect, expected))).pipe(
-        Effect.provideService(SqlClient.SqlClient, sql),
-        Effect.mapError((error) => (isSqlError(error) ? storageError(operation)(error) : error)),
-        Effect.tapError(annotateStorageError),
-        Effect.withSpan("DoJournal.withWriteTransaction", { attributes: { operation } }),
-        Effect.flatMap(Effect.fromResult),
-      );
+      Effect.withFiber((fiber) => {
+        const body = state.owner
+          .withMutation(owner.transaction(storageResult(effect, expected)))
+          .pipe(
+            Effect.provideService(SqlClient.SqlClient, sql),
+            Effect.mapError((error) =>
+              isSqlError(error) ? storageError(operation)(error) : error,
+            ),
+          );
+
+        const traced =
+          fiber.getRef(References.TracerEnabled) &&
+          fiber.getRef(Tracer.Tracer) !== Tracer.nativeTracer;
+
+        return (
+          traced
+            ? body.pipe(
+                Effect.tapError(annotateStorageError),
+                Effect.withSpan("DoJournal.withWriteTransaction", { attributes: { operation } }),
+              )
+            : body
+        ).pipe(Effect.flatMap(Effect.fromResult));
+      });
 
   const materialize = Effect.fnUntraced(function* (
     threadId: string,
@@ -620,9 +661,152 @@ const makeJournal = Effect.fnUntraced(function* (
     return request;
   });
 
+  // Replay and progress validation precede this body in the same owner transaction.
+  // A miss makes no native change; the ordinary path reuses any tentative batch.
+  // After advancing the frontier, failures must roll back rather than fall back.
+  const appendNativeBody = Effect.fnUntraced(function* (
+    request: RawAppendRequest,
+    first: CanonicalSequence,
+    last: CanonicalSequence,
+    batchInserted: boolean,
+  ) {
+    const db = nativeDb;
+
+    // Effectful statement transformers and exported SQL spans retain the ordinary path.
+    const ordinaryStatement = yield* Effect.withFiber((fiber) =>
+      Effect.succeed(
+        fiber.getRef(CurrentTransformer) !== undefined ||
+          (fiber.getRef(References.TracerEnabled) &&
+            fiber.getRef(Tracer.Tracer) !== Tracer.nativeTracer),
+      ),
+    );
+
+    if (ordinaryStatement) return false;
+    if (
+      db === undefined ||
+      request.executionWrites.length !== 1 ||
+      request.executionWrites[0]?.update.retire ||
+      request.executionWrites[0]?.update.facts.length !== 0
+    )
+      return false;
+
+    const workPlan = work.prepareClosedPair(
+      request.threadId,
+      first,
+      last,
+      request.records.map((record) => record.canonical),
+    );
+
+    if (workPlan === undefined) return false;
+
+    const native = yield* Effect.suspend(() => {
+      const query = (statement: Statement<object>, operation: string) =>
+        Result.try({
+          try: () => {
+            const [text, parameters] = statement.compile();
+
+            return db.exec(text, ...parameters).toArray();
+          },
+          catch: (cause) =>
+            storageError(operation)(
+              SqlError.make({
+                reason: classifySqliteError(cause, {
+                  operation,
+                  message: "Native canonical statement failed",
+                }),
+              }),
+            ),
+        });
+
+      return Effect.fromResult(
+        Result.gen(function* () {
+          const captured = physical.cachedRecords(request.threadId, first, request.records);
+
+          if (captured === undefined) return undefined;
+          const physicalRecords = yield* captured;
+          const rows = yield* query(workPlan.advance, "advance native work frontier");
+
+          // A zero-row predicate miss has made no change. A successful update
+          // must never fall back: every later refusal rolls back this transaction.
+          if (rows.length === 0) return undefined;
+          const closed = yield* workPlan.fold();
+          const executionPlans = executions.prepareCommit(request);
+
+          if (!batchInserted)
+            yield* query(
+              sql`INSERT INTO effect_agent_canonical_batches
+            (thread_id, batch_id, first_sequence, last_sequence, producer_id_json)
+            VALUES (${request.threadId}, ${JSON.stringify(request.batchId)}, ${first}, ${last}, ${request.producerIdJson})`,
+              "insert canonical batch",
+            );
+
+          const inserted = yield* query(
+            sql`INSERT INTO effect_agent_canonical_records ${sql.insert(physicalRecords.map((row) => row.columns))}
+            ON CONFLICT(thread_id, record_id) DO NOTHING RETURNING 1`,
+            "insert canonical records",
+          );
+
+          if (inserted.length !== request.records.length)
+            return yield* Result.fail(
+              DoAppendConflict.make({
+                message: "A canonical record ID already exists.",
+                reason: "record-identity",
+              }),
+            );
+          const memberships = physicalRecords.flatMap((row) => row.memberships);
+
+          for (const group of chunked(memberships, Math.floor(MAX_BOUND_PARAMETERS / 3)))
+            yield* query(
+              sql`INSERT INTO effect_agent_record_runs ${sql.insert(group)}`,
+              "index canonical Run membership",
+            );
+          for (const pointer of closed.pointers) yield* query(pointer, "index canonical pointers");
+
+          for (const plan of executionPlans) {
+            const changed = yield* query(plan.statement, "commit active execution");
+            const accepted = plan.accept(changed);
+
+            if (Result.isFailure(accepted))
+              return yield* Result.fail(
+                DoAppendConflict.make({
+                  reason: accepted.failure.reason,
+                  message: "Active execution conflicts with the captured commit",
+                  ...(accepted.failure.actualTailSequence === undefined
+                    ? {}
+                    : { actualTailSequence: accepted.failure.actualTailSequence }),
+                }),
+              );
+          }
+          for (let index = 0; index < request.records.length; index++) {
+            const record = request.records[index]!;
+
+            recordCache.put(
+              RecordRow.make({
+                ...physicalRecords[index]!.columns,
+                thread_id: request.threadId,
+                record_id: record.recordId,
+                batch_id: request.batchId,
+                record_json: record.recordJson,
+                sequence: CanonicalSequence.make(first + index),
+              }),
+              record.recordBytes,
+            );
+          }
+
+          return rows;
+        }),
+      );
+    });
+
+    if (native === undefined) return false;
+    yield* threads.write(Effect.succeed(native));
+
+    return true;
+  });
+
   const appendPrepared = Effect.fnUntraced(function* (
     request: RawAppendRequest,
-  ): Effect.fn.Return<RawAppendResult, AppendError> {
+  ): Effect.fn.Return<AppendResult, AppendError> {
     const threadRows = yield* getThread(request.threadId);
 
     const thread = threadRows.length === 1 ? threadRows[0] : undefined;
@@ -634,30 +818,62 @@ const makeJournal = Effect.fnUntraced(function* (
         message: `Expected exactly one row but found ${threadRows.length}.`,
       });
 
-    const prefix = recordCache.prefix(request.threadId, thread.tail_sequence);
+    // A fresh canonical batch key and absence of an active receipt prove the two
+    // negative replay lookups in the same statement that retains the batch header.
+    // Keep the read-first path for stale/overflowed coordinates so exact retries
+    // still precede sequence and tail refusals.
+    const canInsert =
+      request.records.length > 0 &&
+      request.expectedTailSequence === thread.tail_sequence &&
+      Number.isSafeInteger(thread.tail_sequence + request.records.length);
+
+    const inserted = canInsert
+      ? yield* sql`INSERT INTO effect_agent_canonical_batches
+            (thread_id, batch_id, first_sequence, last_sequence, producer_id_json)
+            SELECT ${request.threadId}, ${JSON.stringify(request.batchId)},
+              ${thread.tail_sequence + 1}, ${thread.tail_sequence + request.records.length},
+              ${request.producerIdJson}
+            WHERE NOT EXISTS (
+              SELECT 1 FROM effect_agent_executions
+              WHERE thread_id=${request.threadId} AND last_commit_id=${request.batchId}
+            )
+            ON CONFLICT(thread_id, batch_id) DO NOTHING RETURNING 1`.pipe(
+          Effect.mapError(storageError("insert canonical batch")),
+        )
+      : [];
 
-    const replay = yield* executionConflict(executions.replay(request));
+    if (inserted.length === 0) {
+      const replay = yield* executionConflict(executions.replay(request));
 
-    if (replay !== undefined) return RawAppendResult.make(replay);
+      if (replay !== undefined) return AppendResult.make(replay);
 
-    const existing =
-      prefix !== undefined && !prefix.some((row) => row.batch_id === request.batchId)
-        ? undefined
-        : yield* archives.replay(request.threadId, request.batchId);
+      const prefix = recordCache.prefix(request.threadId, thread.tail_sequence);
 
-    if (existing !== undefined) {
-      if (existing.batch_json !== request.batchJson) {
-        return yield* DoAppendConflict.make({
-          message: `Batch ${request.batchId} already exists with different canonical content.`,
-          reason: "batch-content",
+      const existing =
+        prefix !== undefined && !prefix.some((row) => row.batch_id === request.batchId)
+          ? undefined
+          : yield* archives.replay(request.threadId, request.batchId);
+
+      if (existing !== undefined) {
+        if (existing.batch_json !== request.batchJson) {
+          return yield* DoAppendConflict.make({
+            message: `Batch ${request.batchId} already exists with different canonical content.`,
+            reason: "batch-content",
+          });
+        }
+
+        return AppendResult.make({
+          firstSequence: existing.first_sequence,
+          lastSequence: existing.last_sequence,
+          replayed: true,
         });
       }
-
-      return RawAppendResult.make({
-        firstSequence: existing.first_sequence,
-        lastSequence: existing.last_sequence,
-        replayed: true,
-      });
+      if (canInsert)
+        return yield* DoStorageCorruptionError.make({
+          table: "effect_agent_canonical_batches",
+          rowKey: request.threadId,
+          message: "Batch insertion conflicted without a durable replay receipt.",
+        });
     }
 
     yield* executionConflict(executions.rejectSuperseded(request));
@@ -671,9 +887,11 @@ const makeJournal = Effect.fnUntraced(function* (
       });
     }
 
-    const firstSequence = yield* Schema.decodeEffect(CanonicalSequence)(
-      thread.tail_sequence + (request.records.length === 0 ? 0 : 1),
-    ).pipe(
+    const result = yield* Schema.decodeEffect(AppendResult)({
+      firstSequence: thread.tail_sequence + (request.records.length === 0 ? 0 : 1),
+      lastSequence: thread.tail_sequence + request.records.length,
+      replayed: false,
+    }).pipe(
       Effect.mapError((error) =>
         DoStorageError.make({
           cause: error,
@@ -683,27 +901,29 @@ const makeJournal = Effect.fnUntraced(function* (
       ),
     );
 
-    const lastSequence = yield* Schema.decodeEffect(CanonicalSequence)(
-      thread.tail_sequence + request.records.length,
-    ).pipe(
-      Effect.mapError((error) =>
-        DoStorageError.make({
-          cause: error,
-          operation: "append canonical batch",
-          message: error.message,
-        }),
-      ),
-    );
+    const { firstSequence, lastSequence } = result;
 
     yield* executionConflict(executions.validate(request));
 
-    const result = RawAppendResult.make({
-      firstSequence,
-      lastSequence,
-      replayed: false,
-    });
+    if (yield* appendNativeBody(request, firstSequence, lastSequence, inserted.length > 0)) {
+      yield* progress.committed("canonical").pipe(
+        Effect.catchCause((cause) =>
+          Effect.failCause(
+            Cause.map(cause, (error) =>
+              DoStorageError.make({
+                operation: "enroll canonical progress",
+                message: error.message,
+                cause: error,
+              }),
+            ),
+          ),
+        ),
+      );
 
-    if (request.records.length > 0) {
+      return result;
+    }
+
+    if (request.records.length > 0 && inserted.length === 0) {
       yield* sql`
           INSERT INTO effect_agent_canonical_batches (
             thread_id,
@@ -760,6 +980,7 @@ const makeJournal = Effect.fnUntraced(function* (
         recordCache.put(
           RecordRow.make({
             ...row,
+            thread_id: request.threadId,
             record_id: record.recordId,
             batch_id: request.batchId,
             record_json: record.recordJson,
@@ -874,7 +1095,7 @@ const makeJournal = Effect.fnUntraced(function* (
     function* (
       request: RawAppendRequest,
       observed: ThreadRow,
-    ): Effect.fn.Return<RawAppendResult, AppendError> {
+    ): Effect.fn.Return<AppendResult, AppendError> {
       yield* prepareAppend(request);
       // The facade already read this tail. Reject a known stale writer without opening a
       // transaction; a matching tail is still checked atomically below. Replays precede tail
@@ -898,10 +1119,9 @@ const makeJournal = Effect.fnUntraced(function* (
         }
       }
 
-      return yield* withWriteTransaction(
-        "append transaction",
-        isAppendContention,
-      )(appendPrepared(request));
+      // Receipt arbitration may have tentatively inserted a batch. Even typed
+      // contention must roll back before leaving the owner mutation gate.
+      return yield* withWriteTransaction("append transaction")(appendPrepared(request));
     },
     withStorageSpan("DoJournal.append", isAppendContention),
   );