effect-agent 0.1.0-beta.131 → 0.1.0-beta.133

package/src/durable/ThreadStore.ts

@@ -13,7 +13,12 @@ import {
   ProducerEpoch,
   RecordId,
 } from "./Records.ts";
-import { runIdForSubmission, toolCallPreparedRecordId } from "./RunJournal.ts";
+import {
+  runIdForSubmission,
+  subagentLineageRecordId,
+  toolCallPreparedRecordId,
+  workerOriginRecordId,
+} from "./RunJournal.ts";
 import { SubmissionLedger, SubmissionLookupById } from "./SubmissionLedger.ts";
 
 export const MAX_THREAD_EXPORT_RECORDS = 131_072;
@@ -383,6 +388,60 @@ export class ThreadTail extends Schema.Class<ThreadTail>("@effect-agent/thread/T
   producerEpoch: ProducerEpoch,
 }) {}
 
+export class ThreadIdentityRequest extends Schema.Class<ThreadIdentityRequest>(
+  "@effect-agent/thread/ThreadIdentityRequest",
+)({ threadId: ThreadId }) {}
+
+/**
+ * One consistent canonical snapshot: tail/epoch, first record, exact worker origin,
+ * then exact subagent lineage. A row selected twice appears only once. Missing
+ * identity records remain absent; the snapshot itself grants no execution authority.
+ */
+export class ThreadIdentity extends Schema.Class<ThreadIdentity>(
+  "@effect-agent/thread/ThreadIdentity",
+)(
+  Schema.Struct({
+    ...ThreadTail.fields,
+    records: Schema.Array(CanonicalRecordEnvelope).check(Schema.isMaxLength(3)),
+  }).check(
+    Schema.makeFilter((snapshot) => {
+      if (snapshot.tailSequence === 0) return snapshot.records.length === 0;
+      if (snapshot.records[0]?.sequence !== 1) return false;
+      const origin = workerOriginRecordId(snapshot.threadId);
+      const lineage = subagentLineageRecordId(snapshot.threadId);
+      const ids = new Set<RecordId>();
+      const sequences = new Set<CanonicalSequence>();
+      let previous = -1;
+
+      for (const entry of snapshot.records) {
+        const rank =
+          entry.sequence === 1
+            ? 0
+            : entry.record.recordId === origin
+              ? 1
+              : entry.record.recordId === lineage
+                ? 2
+                : -1;
+
+        if (
+          entry.threadId !== snapshot.threadId ||
+          entry.sequence < 1 ||
+          entry.sequence > snapshot.tailSequence ||
+          rank <= previous ||
+          ids.has(entry.record.recordId) ||
+          sequences.has(entry.sequence)
+        )
+          return false;
+        ids.add(entry.record.recordId);
+        sequences.add(entry.sequence);
+        previous = rank;
+      }
+
+      return true;
+    }),
+  ),
+) {}
+
 /** Maximum canonical records represented by one Thread export. */
 
 export class ThreadExport extends Schema.Class<ThreadExport>("@effect-agent/thread/ThreadExport")({
@@ -560,6 +619,9 @@ export class ThreadStore extends Context.Service<
     readonly inspectTail: (
       request: ThreadTailRequest,
     ) => Effect.Effect<ThreadTail, ThreadStoreError | ThreadNotMaterialized>;
+    readonly readIdentity: (
+      request: ThreadIdentityRequest,
+    ) => Effect.Effect<ThreadIdentity, ThreadStoreError | ThreadNotMaterialized>;
     /** Absent when this adapter does not support disposable checkpoints. */
     readonly checkpoints?: ThreadCheckpoints | undefined;
     readonly recoveryCheckpoints?: ThreadRecoveryCheckpoints | undefined;

package/src/durable/ThreadStoreConformance.ts

@@ -40,6 +40,7 @@ import {
   SubtreeBudgetReserved,
   PeerMessagePrepared,
 } from "./Records.ts";
+import { subagentLineageRecordId, workerOriginRecordId } from "./RunJournal.ts";
 import {
   type AppendResult,
   AppendConflict,
@@ -47,6 +48,7 @@ import {
   ThreadCheckpoint,
   ThreadExportRequest,
   ThreadMaterialization,
+  ThreadIdentityRequest,
   ThreadNotMaterialized,
   ThreadObservation,
   ThreadRead,
@@ -641,10 +643,19 @@ const tailInspection = conformanceCase(
           empty.producerEpoch === EPOCH_ONE,
         "An empty Thread must report the zero tail and its registered epoch",
       );
+      const emptyIdentity = yield* store.readIdentity(ThreadIdentityRequest.make({ threadId }));
+
+      yield* ensure(
+        emptyIdentity.tailSequence === ZERO_SEQUENCE &&
+          emptyIdentity.tailDigest === EMPTY_TAIL_DIGEST &&
+          emptyIdentity.producerEpoch === EPOCH_ONE &&
+          emptyIdentity.records.length === 0,
+        "A materialized empty identity remains distinct from a missing Thread",
+      );
 
       const first = yield* append(
         threadId,
-        batch("inspect-batch-1", [record("inspect-record-1", "first")]),
+        batch("inspect-batch-1", [record(workerOriginRecordId(threadId), "first")]),
       );
 
       const afterAppend = yield* store.inspectTail(ThreadTailRequest.make({ threadId }));
@@ -654,6 +665,18 @@ const tailInspection = conformanceCase(
           afterAppend.tailDigest === first.tailDigest,
         "Tail inspection must match the latest AppendResult",
       );
+      // Regression: https://github.com/danieljvdm/effect-agent/commit/6a4f4f870
+      const identity = yield* store.readIdentity(ThreadIdentityRequest.make({ threadId }));
+
+      yield* ensure(
+        identity.threadId === threadId &&
+          identity.tailSequence === first.lastSequence &&
+          identity.tailDigest === first.tailDigest &&
+          identity.producerEpoch === EPOCH_ONE &&
+          identity.records.length === 1 &&
+          identity.records[0]?.record.recordId === workerOriginRecordId(threadId),
+        "Identity captures the canonical tail and deduplicates a first record at the origin locator",
+      );
 
       const resumed = yield* append(
         threadId,
@@ -667,6 +690,22 @@ const tailInspection = conformanceCase(
         "An append composed from the inspected tail must commit without exporting the log",
       );
 
+      const staleIdentity = yield* expectFailure(
+        "appending from an identity snapshot after a tail advance",
+        append(
+          threadId,
+          batch("inspect-stale-identity", [record("inspect-record-3", "third")]),
+          { lastSequence: identity.tailSequence, tailDigest: identity.tailDigest },
+          identity.producerEpoch,
+        ),
+      );
+
+      yield* ensure(
+        isAppendConflict(staleIdentity) && staleIdentity.reason === "tail",
+        "Identity reads do not bypass the canonical append tail fence",
+      );
+      const beforeTakeover = yield* store.readIdentity(ThreadIdentityRequest.make({ threadId }));
+
       yield* materialize(threadId, EPOCH_TWO);
       const afterTakeover = yield* store.inspectTail(ThreadTailRequest.make({ threadId }));
 
@@ -675,6 +714,43 @@ const tailInspection = conformanceCase(
           afterTakeover.tailSequence === resumed.lastSequence,
         "Tail inspection must reflect epoch takeover without disturbing the tail",
       );
+
+      const fencedIdentity = yield* expectFailure(
+        "appending from an identity snapshot after an epoch-only takeover",
+        append(
+          threadId,
+          batch("inspect-stale-epoch", [record("inspect-record-3", "third")]),
+          { lastSequence: beforeTakeover.tailSequence, tailDigest: beforeTakeover.tailDigest },
+          beforeTakeover.producerEpoch,
+        ),
+      );
+
+      yield* ensure(
+        isFenceRejected(fencedIdentity),
+        "An epoch-only takeover rejects the identity snapshot's captured producer fence",
+      );
+
+      const afterTakeoverIdentity = yield* store.readIdentity(
+        ThreadIdentityRequest.make({ threadId }),
+      );
+
+      const retried = yield* append(
+        threadId,
+        batch("inspect-retry-identity", [record("inspect-record-3", "third")]),
+        {
+          lastSequence: afterTakeoverIdentity.tailSequence,
+          tailDigest: afterTakeoverIdentity.tailDigest,
+        },
+        afterTakeoverIdentity.producerEpoch,
+      );
+
+      yield* ensure(
+        afterTakeoverIdentity.producerEpoch === EPOCH_TWO &&
+          afterTakeoverIdentity.tailSequence === resumed.lastSequence &&
+          afterTakeoverIdentity.records.length === 1 &&
+          retried.lastSequence === resumed.lastSequence + 1,
+        "Rereading identity after takeover retains the bounded facts and permits the current producer",
+      );
     }),
 );
 
@@ -705,6 +781,10 @@ const notMaterializedOperations = conformanceCase(
           "inspecting the tail of an unmaterialized Thread",
           store.inspectTail(ThreadTailRequest.make({ threadId })),
         ),
+        yield* expectFailure(
+          "reading the identity of an unmaterialized Thread",
+          store.readIdentity(ThreadIdentityRequest.make({ threadId })),
+        ),
       ];
 
       yield* Effect.forEach(
@@ -1040,6 +1120,14 @@ const nativeWorkerAccounting = conformanceCase(
           Option.isSome(yield* getRecord({ threadId, recordId: decodeRecordId("requested") })),
         "Proven completion retires the input while retaining its canonical reservation",
       );
+      // Regression: https://github.com/danieljvdm/effect-agent/commit/6a4f4f870
+      // Payloads do not select identity: the exact lineage locator precedes the
+      // exact origin locator in the log, while replies retain first/origin/lineage order.
+      tail = yield* append(
+        threadId,
+        batch("identity-lineage", [record(subagentLineageRecordId(threadId), "lineage")]),
+        tail,
+      );
       // Cross the recovery horizon with irrelevant conversation records. Native worker
       // accounting must return the same families and scope, while capturing the full CAS tail.
       for (let base = 0; base < 4097; base += 256) {
@@ -1060,6 +1148,30 @@ const nativeWorkerAccounting = conformanceCase(
           tail,
         );
       }
+      tail = yield* append(
+        threadId,
+        batch("identity-origin", [record(workerOriginRecordId(threadId), "origin")]),
+        tail,
+      );
+      const identity = yield* store.readIdentity(ThreadIdentityRequest.make({ threadId }));
+
+      yield* ensure(
+        identity.threadId === threadId &&
+          identity.tailSequence === tail.lastSequence &&
+          identity.tailDigest === tail.tailDigest &&
+          identity.producerEpoch === EPOCH_ONE &&
+          identity.records.length === 3 &&
+          identity.records.map(({ record }) => record.recordId).join() ===
+            [
+              "requested",
+              workerOriginRecordId(threadId),
+              subagentLineageRecordId(threadId),
+            ].join() &&
+          identity.records.every(
+            (entry) => entry.threadId === threadId && entry.sequence <= identity.tailSequence,
+          ),
+        "Identity selects the exact canonical locators in semantic order beyond the recovery horizon",
+      );
 
       const budgetRow = (id: string, sourceSubmissionId: SubmissionId) =>
         envelope(

package/src/durable/internal/agent-updates.ts

@@ -34,6 +34,7 @@ import {
   ThreadStore,
   ThreadTailRequest,
 } from "../ThreadStore.ts";
+import { WakeScheduler } from "../WakeScheduler.ts";
 import { WorkerRuntime } from "./worker-runtime.ts";
 
 export const lastWorkerReportMessageId = (records: ReadonlyArray<CanonicalRecordEnvelope>) => {
@@ -62,6 +63,7 @@ export const makeAgentUpdateRuntime = Effect.fn("AgentUpdates.makeDurable")(func
 }) {
   const store = yield* ThreadStore;
   const workers = yield* WorkerRuntime;
+  const wake = yield* WakeScheduler;
   const deliveries = yield* Effect.serviceOption(MessageDeliveryStore);
   const crypto = yield* Crypto.Crypto;
   const failpoint = yield* DurableRuntimeFailpoint;
@@ -290,6 +292,8 @@ export const makeAgentUpdateRuntime = Effect.fn("AgentUpdates.makeDurable")(func
 
       if (!appended) continue;
       yield* failpoint.hit("update:after-canonical-append");
+      // Canonical progress is observable even when no parent report is selected.
+      yield* wake.notify(request.submission.threadId);
       yield* insert(payload);
 
       return update;

package/src/durable/internal/worker-host.ts

@@ -84,7 +84,6 @@ import {
   workerInputRecordId,
   agentUpdateRecordId,
   firstWorkerInputRecordId,
-  subagentLineageRecordId,
   workerOriginRecordId,
   workerReportRecordId,
 } from "../RunJournal.ts";
@@ -108,6 +107,7 @@ import {
 import type { SubmissionStatus } from "../SubmissionStatus.ts";
 import { PreparedInput } from "../Subscription.ts";
 import {
+  ThreadIdentityRequest,
   ThreadStore,
   getRecord,
   getRunInput,
@@ -117,6 +117,7 @@ import {
   type ThreadExport,
   MAX_THREAD_EXPORT_RECORDS,
   ThreadRead,
+  type ThreadTail,
   ThreadTailRequest,
 } from "../ThreadStore.ts";
 import {
@@ -492,18 +493,9 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
     threadId: ThreadId,
     operation: WorkerError["operation"],
   ) {
-    const tail = yield* deps.store
-      .inspectTail(ThreadTailRequest.make({ threadId }))
+    return yield* deps.store
+      .readIdentity(ThreadIdentityRequest.make({ threadId }))
       .pipe(Effect.mapError(storageFailure(operation)));
-
-    const first = yield* deps.store
-      .read(ThreadRead.make({ threadId, limit: 1 }))
-      .pipe(Stream.runCollect, Effect.mapError(storageFailure(operation)));
-
-    const worker = yield* exactRecord(threadId, workerOriginRecordId(threadId), operation);
-    const attached = yield* exactRecord(threadId, subagentLineageRecordId(threadId), operation);
-
-    return { ...tail, records: [...first, ...Option.toArray(worker), ...Option.toArray(attached)] };
   });
 
   const readWorkerState = Effect.fn("WorkerHost.readWorkerState")(function* (
@@ -536,23 +528,30 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         | WorkerReportPrepared
         | WorkerReportRefused
         | SubtreeBudgetReserved,
-      current: Pick<ThreadExport, "tailSequence" | "tailDigest" | "records">,
+      current: Pick<ThreadExport, "tailSequence" | "tailDigest" | "records"> &
+        Partial<Pick<ThreadTail, "producerEpoch">>,
       phase: "source" | "origin" | "completion" | "subtree" | "report" | "stop",
       acknowledgements: ReadonlyArray<WorkerInputCompleted> = [],
     ) {
       const operation = "start";
-      const tail = yield* deps.store.inspectTail(ThreadTailRequest.make({ threadId }));
+      let producerEpoch = current.producerEpoch;
+
+      if (producerEpoch === undefined) {
+        const tail = yield* deps.store.inspectTail(ThreadTailRequest.make({ threadId }));
+
+        if (tail.tailSequence !== current.tailSequence || tail.tailDigest !== current.tailDigest)
+          return false;
+        producerEpoch = tail.producerEpoch;
+      }
 
-      // Never append against a tail newer than the prefix whose capacity was checked.
-      if (tail.tailSequence !== current.tailSequence || tail.tailDigest !== current.tailDigest)
-        return false;
+      // The store atomically fences the validated prefix and its producer epoch.
       yield* hit(`worker:before-${phase}-append`, operation);
 
       const result = yield* deps.store
         .append(
           FencedAppendRequest.make({
             threadId,
-            producerEpoch: tail.producerEpoch,
+            producerEpoch,
             expectedTailSequence: current.tailSequence,
             expectedTailDigest: current.tailDigest,
             batch: CanonicalBatch.make({