effect-agent 0.1.0-beta.159 → 0.1.0-beta.160

package/src/durable/RunJournal.ts

@@ -15,7 +15,10 @@ import {
   contextWindowMessage,
 } from "../engine/Compaction.ts";
 import { digestJson, type DigestError } from "./Digest.ts";
-import { type JournalCheckpointSeed } from "./internal/journal-checkpoint.ts";
+import {
+  type JournalCheckpointSeed,
+  type ThreadContextCheckpoint,
+} from "./internal/journal-checkpoint.ts";
 import {
   makeJournalMetadata,
   toolExecutionKey,
@@ -610,13 +613,19 @@ export const projectRunJournalStream = Effect.fn("RunJournal.projectRunJournalSt
   onBoundary?: (boundary: JournalBoundary) => void,
   seed?: JournalCheckpointSeed,
   preparedMetadata?: JournalMetadata,
+  priorContext?: ThreadContextCheckpoint,
 ): Effect.fn.Return<RunJournalProjection, RunJournalError | E, R> {
   if (seed !== undefined && seed.runId !== ownerRunId)
     return yield* journalError("Recovery checkpoint belongs to another Run");
+  if (seed !== undefined && priorContext !== undefined)
+    return yield* journalError("Run recovery and prior Thread context cannot seed the same replay");
+
+  const historical =
+    priorContext === undefined ? [] : (yield* decodePromptMessages(priorContext.prompt)).content;
 
   let state: FoldState = {
-    all: [],
-    before: [],
+    all: [...historical],
+    before: [...historical],
     pendingTools: [],
     pendingToolsForRun: false,
     committedTurns: seed?.committedTurns ?? 0,
@@ -679,6 +688,9 @@ export const projectRunJournalStream = Effect.fn("RunJournal.projectRunJournalSt
     isInRunView(sequence, payload, ownerRunId),
   );
 
+  if (priorContext !== undefined && compactions.length > 0)
+    return yield* journalError("New compaction requires the complete canonical context mapping");
+
   const recordsForRun = records.pipe(
     Stream.filter(({ sequence, record: { payload } }) =>
       isInRunView(sequence, payload, ownerRunId),
@@ -827,7 +839,7 @@ export const projectRunJournalStream = Effect.fn("RunJournal.projectRunJournalSt
     ];
   };
 
-  let latestWindowId: string | undefined = seed?.contextWindowId;
+  let latestWindowId: string | undefined = seed?.contextWindowId ?? priorContext?.contextWindowId;
   let latestWindowSequence = seed?.throughSequence ?? -1;
   let rolloverCoveredThrough = 0;
 

package/src/durable/SqlMemoryStore.ts

@@ -63,6 +63,9 @@ export class SqlMemoryBatchWriter extends Context.Service<
  * releasing readers. Hosts with independent database writers must leave this unset.
  */
 export interface SqlStorageOwner {
+  /** Cache identity for transaction decorators; omission uses the owner itself.
+   * Shared identities must name the same database, reader gate and invalidator set. */
+  readonly identity?: object;
   readonly read: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
   readonly transaction: <A, E, R>(
     effect: Effect.Effect<A, E, R>,
@@ -172,17 +175,18 @@ class MemoryViews {
   }
 }
 
-const ownedViews = new WeakMap<SqlStorageOwner, MemoryViews>();
+const ownedViews = new WeakMap<object, MemoryViews>();
 
 const memoryViews = Effect.fn("SqliteMemoryStore.memoryViews")(function* () {
   const owner = yield* SqlStorageOwner;
 
   if (owner === undefined) return undefined;
-  let views = ownedViews.get(owner);
+  const identity = owner.identity ?? owner;
+  let views = ownedViews.get(identity);
 
   if (views === undefined) {
     views = new MemoryViews();
-    ownedViews.set(owner, views);
+    ownedViews.set(identity, views);
     owner.invalidators.add(views.clear);
   }
 

package/src/durable/internal/journal-checkpoint.ts

@@ -37,15 +37,25 @@ export class JournalCheckpointSeed extends Schema.Class<JournalCheckpointSeed>(
   compaction: CanonicalRecordEnvelope,
 }) {}
 
+/** Canonical historical context for a later Run, without the previous Run's authority or usage. */
+export class ThreadContextCheckpoint extends Schema.Class<ThreadContextCheckpoint>(
+  "@effect-agent/thread/internal/ThreadContextCheckpoint",
+)({
+  throughSequence: CanonicalSequence,
+  prompt: PersistedJson,
+  contextWindowId: Schema.optionalKey(Schema.String),
+}) {}
+
 /** A bounded sparse projection, never a canonical log or a submission-ownership record. */
 export class RecoveryCheckpointState extends Schema.Class<RecoveryCheckpointState>(
   "@effect-agent/thread/internal/RecoveryCheckpointState",
 )({
-  schemaVersion: Schema.Literal(1),
+  schemaVersion: Schema.Literal(2),
   policyAccountingVersion: Schema.Literal(1),
   submissionId: SubmissionId,
   submissionIds: Schema.Array(SubmissionId).check(Schema.isMaxLength(4_096)),
-  seed: JournalCheckpointSeed,
+  seed: Schema.optionalKey(JournalCheckpointSeed),
+  context: Schema.optionalKey(ThreadContextCheckpoint),
   records: Schema.Array(CanonicalRecordEnvelope).check(Schema.isMaxLength(4_096)),
 }) {}
 
@@ -56,7 +66,51 @@ export class RecoveryCheckpointContents extends Schema.Class<RecoveryCheckpointC
   digest: Digest,
 }) {}
 
-export const RECOVERY_ENGINE_VERSION = "effect-agent/recovery@2";
+export const RECOVERY_ENGINE_VERSION = "effect-agent/recovery@3";
+
+/**
+ * Prove that indexed original-input absence also means absent prefix Run/control evidence.
+ * Only cache consumers with colon-free Submission IDs use this certificate. For those IDs,
+ * every possible control marker is exactly :run:<submission-id>:. Parsing here can only decline
+ * caching; it never supplies an execution identity. Separator-bearing identities use full replay.
+ * The temporary anchor set is discarded after certification, not persisted with the context.
+ */
+export const makeThreadContextCertificate = () => {
+  const anchored = new Set<string>();
+  let valid = true;
+
+  return {
+    add: ({ record }: CanonicalRecordEnvelope): void => {
+      if (!valid) return;
+      const payload = record.payload;
+
+      if ("runId" in payload && payload.runId !== undefined) {
+        const originalInput = payload._tag === "UserInputRecorded" && payload.kind === "user";
+
+        if (originalInput ? anchored.has(payload.runId) : !anchored.has(payload.runId)) {
+          valid = false;
+
+          return;
+        }
+        if (originalInput) anchored.add(payload.runId);
+      }
+      for (
+        let start = record.recordId.indexOf(":run:");
+        start !== -1;
+        start = record.recordId.indexOf(":run:", start + 1)
+      ) {
+        const end = record.recordId.indexOf(":", start + 5);
+
+        if (end !== -1 && !anchored.has(record.recordId.slice(start + 1, end))) {
+          valid = false;
+
+          return;
+        }
+      }
+    },
+    isValid: (): boolean => valid,
+  };
+};
 
 /**
  * Late evidence can invalidate an old compaction. Such histories use full canonical replay;