zeitlich 0.2.37 → 0.2.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.37",
+  "version": "0.2.39",
   "description": "[EXPERIMENTAL] An opinionated AI agent implementation for Temporal",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -27,6 +27,16 @@
         "default": "./dist/workflow.js"
       }
     },
+    "./adapters/thread": {
+      "import": {
+        "types": "./dist/adapters/thread/index.d.ts",
+        "default": "./dist/adapters/thread/index.js"
+      },
+      "require": {
+        "types": "./dist/adapters/thread/index.d.ts",
+        "default": "./dist/adapters/thread/index.js"
+      }
+    },
     "./adapters/thread/langchain": {
       "import": {
         "types": "./dist/adapters/thread/langchain/index.d.ts",
@@ -210,7 +220,7 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.80.0",
+    "@anthropic-ai/sdk": "^0.81.0",
     "@aws-sdk/client-bedrock-agentcore": "^3.900.0",
     "@daytonaio/sdk": "^0.158.1",
     "@e2b/code-interpreter": "^2.3.3",

package/src/adapters/sandbox/bedrock/index.ts

@@ -239,15 +239,24 @@ export class BedrockSandboxProvider implements SandboxProvider<
     // Bedrock sandboxes don't support pause, so resume is a no-op
   }
 
-  async snapshot(_sandboxId: string): Promise<SandboxSnapshot> {
+  async snapshot(
+    _sandboxId: string,
+    _options?: BedrockSandboxCreateOptions
+  ): Promise<SandboxSnapshot> {
     throw new SandboxNotSupportedError("snapshot");
   }
 
-  async restore(_snapshot: SandboxSnapshot): Promise<never> {
+  async restore(
+    _snapshot: SandboxSnapshot,
+    _options?: BedrockSandboxCreateOptions
+  ): Promise<never> {
     throw new SandboxNotSupportedError("restore");
   }
 
-  async fork(_sandboxId: string): Promise<Sandbox> {
+  async fork(
+    _sandboxId: string,
+    _options?: BedrockSandboxCreateOptions
+  ): Promise<Sandbox> {
     throw new SandboxNotSupportedError("fork");
   }
 

package/src/adapters/sandbox/daytona/index.ts

@@ -149,17 +149,26 @@ export class DaytonaSandboxProvider implements SandboxProvider<
     // Daytona sandboxes don't support pause, so resume is a no-op
   }
 
-  async fork(_sandboxId: string): Promise<Sandbox> {
+  async fork(
+    _sandboxId: string,
+    _options?: DaytonaSandboxCreateOptions
+  ): Promise<Sandbox> {
     throw new Error("Not implemented");
   }
 
-  async snapshot(_sandboxId: string): Promise<SandboxSnapshot> {
+  async snapshot(
+    _sandboxId: string,
+    _options?: DaytonaSandboxCreateOptions
+  ): Promise<SandboxSnapshot> {
     throw new SandboxNotSupportedError(
       "snapshot (use Daytona's native snapshot API directly)"
     );
   }
 
-  async restore(_snapshot: SandboxSnapshot): Promise<never> {
+  async restore(
+    _snapshot: SandboxSnapshot,
+    _options?: DaytonaSandboxCreateOptions
+  ): Promise<never> {
     throw new SandboxNotSupportedError(
       "restore (use Daytona's native snapshot API directly)"
     );

package/src/adapters/sandbox/e2b/index.ts

@@ -76,11 +76,19 @@ export class E2bSandboxProvider implements SandboxProvider<
   private readonly defaultTemplate?: string;
   private readonly defaultWorkspaceBase: string;
   private readonly defaultTimeoutMs?: number;
+  private readonly defaultAllowInternetAccess?: boolean;
+  private readonly defaultNetwork?: E2bSandboxConfig["network"];
+  private readonly defaultMetadata?: E2bSandboxConfig["metadata"];
+  private readonly defaultLifecycle?: E2bSandboxConfig["lifecycle"];
 
   constructor(config?: E2bSandboxConfig) {
     this.defaultTemplate = config?.template;
     this.defaultWorkspaceBase = config?.workspaceBase ?? "/home/user";
     this.defaultTimeoutMs = config?.timeoutMs;
+    this.defaultAllowInternetAccess = config?.allowInternetAccess;
+    this.defaultNetwork = config?.network;
+    this.defaultMetadata = config?.metadata;
+    this.defaultLifecycle = config?.lifecycle;
   }
 
   async create(
@@ -142,7 +150,10 @@ export class E2bSandboxProvider implements SandboxProvider<
     await E2bSdkSandbox.connect(sandboxId);
   }
 
-  async snapshot(sandboxId: string): Promise<SandboxSnapshot> {
+  async snapshot(
+    sandboxId: string,
+    _options?: E2bSandboxCreateOptions
+  ): Promise<SandboxSnapshot> {
     const { snapshotId } = await E2bSdkSandbox.createSnapshot(sandboxId);
     return {
       sandboxId,
@@ -152,14 +163,18 @@ export class E2bSandboxProvider implements SandboxProvider<
     };
   }
 
-  async restore(snapshot: SandboxSnapshot): Promise<Sandbox> {
+  async restore(
+    snapshot: SandboxSnapshot,
+    options?: E2bSandboxCreateOptions
+  ): Promise<Sandbox> {
     const data = snapshot.data as { snapshotId?: string } | null;
     if (!data?.snapshotId) {
       throw new SandboxNotSupportedError(
         "restore: snapshot is missing snapshotId"
       );
     }
-    const sdkSandbox = await E2bSdkSandbox.create(data.snapshotId);
+    const sdkOpts = this.buildSdkCreateOpts(options);
+    const sdkSandbox = await E2bSdkSandbox.create(data.snapshotId, sdkOpts);
     return new E2bSandboxImpl(
       sdkSandbox.sandboxId,
       sdkSandbox,
@@ -177,9 +192,13 @@ export class E2bSandboxProvider implements SandboxProvider<
     }
   }
 
-  async fork(sandboxId: string): Promise<Sandbox> {
+  async fork(
+    sandboxId: string,
+    options?: E2bSandboxCreateOptions
+  ): Promise<Sandbox> {
     const { snapshotId } = await E2bSdkSandbox.createSnapshot(sandboxId);
-    const sdkSandbox = await E2bSdkSandbox.create(snapshotId);
+    const sdkOpts = this.buildSdkCreateOpts(options);
+    const sdkSandbox = await E2bSdkSandbox.create(snapshotId, sdkOpts);
     return new E2bSandboxImpl(
       sdkSandbox.sandboxId,
       sdkSandbox,
@@ -188,22 +207,25 @@ export class E2bSandboxProvider implements SandboxProvider<
   }
 
   private buildSdkCreateOpts(options?: E2bSandboxCreateOptions) {
+    const network = options?.network ?? this.defaultNetwork;
+    const lifecycle = options?.lifecycle ?? this.defaultLifecycle;
     return {
       envs: options?.env,
       timeoutMs: options?.timeoutMs ?? this.defaultTimeoutMs,
-      metadata: options?.metadata,
-      allowInternetAccess: options?.allowInternetAccess,
-      network: options?.network
+      metadata: options?.metadata ?? this.defaultMetadata,
+      allowInternetAccess:
+        options?.allowInternetAccess ?? this.defaultAllowInternetAccess,
+      network: network
         ? {
-            allowOut: options.network.allowOut,
-            denyOut: options.network.denyOut,
-            allowPublicTraffic: options.network.allowPublicTraffic,
+            allowOut: network.allowOut,
+            denyOut: network.denyOut,
+            allowPublicTraffic: network.allowPublicTraffic,
           }
         : undefined,
-      lifecycle: options?.lifecycle
+      lifecycle: lifecycle
         ? {
-            onTimeout: options.lifecycle.onTimeout,
-            autoResume: options.lifecycle.autoResume,
+            onTimeout: lifecycle.onTimeout,
+            autoResume: lifecycle.autoResume,
           }
         : undefined,
     };

package/src/adapters/sandbox/e2b/types.ts

@@ -6,6 +6,14 @@ import type { E2bSandboxFileSystem } from "./filesystem";
  */
 export type E2bSandbox = Sandbox & { fs: E2bSandboxFileSystem };
 
+/**
+ * Provider-level defaults for E2B sandboxes. Every lifecycle op
+ * (`create` / `restore` / `fork`) merges per-call options on top of these —
+ * per-call options win per-field. This is how E2B preserves sandbox-level
+ * config (network policy, metadata, lifecycle, timeout) across
+ * snapshot/restore and fork, since the E2B API treats those as pure
+ * create-time inputs that aren't carried in the snapshot blob.
+ */
 export interface E2bSandboxConfig {
   /** Sandbox template name or ID */
   template?: string;
@@ -13,6 +21,14 @@ export interface E2bSandboxConfig {
   workspaceBase?: string;
   /** Sandbox idle timeout in milliseconds */
   timeoutMs?: number;
+  /** Default outbound internet access policy */
+  allowInternetAccess?: boolean;
+  /** Default outbound network allow/deny rules */
+  network?: SandboxCreateOptions["network"];
+  /** Default metadata surfaced via provider list/query APIs */
+  metadata?: SandboxCreateOptions["metadata"];
+  /** Default sandbox timeout behaviour */
+  lifecycle?: SandboxCreateOptions["lifecycle"];
 }
 
 export interface E2bSandboxCreateOptions extends SandboxCreateOptions {

package/src/adapters/sandbox/inmemory/index.ts

@@ -183,7 +183,10 @@ export class InMemorySandboxProvider implements SandboxProvider {
     return { sandbox };
   }
 
-  async snapshot(sandboxId: string): Promise<SandboxSnapshot> {
+  async snapshot(
+    sandboxId: string,
+    _options?: SandboxCreateOptions
+  ): Promise<SandboxSnapshot> {
     const sandbox = this.sandboxes.get(sandboxId);
     if (!sandbox) throw new SandboxNotFoundError(sandboxId);
 
@@ -210,7 +213,10 @@ export class InMemorySandboxProvider implements SandboxProvider {
     };
   }
 
-  async fork(sandboxId: string): Promise<Sandbox> {
+  async fork(
+    sandboxId: string,
+    _options?: SandboxCreateOptions
+  ): Promise<Sandbox> {
     const sandbox = await this.get(sandboxId);
 
     const entries = await sandbox.fs.readdirWithFileTypes("/");
@@ -228,7 +234,10 @@ export class InMemorySandboxProvider implements SandboxProvider {
     return newSandbox.sandbox;
   }
 
-  async restore(snapshot: SandboxSnapshot): Promise<Sandbox> {
+  async restore(
+    snapshot: SandboxSnapshot,
+    _options?: SandboxCreateOptions
+  ): Promise<Sandbox> {
     const { files } = snapshot.data as { files: Record<string, string> };
     const initialFiles: InitialFiles = {};
     for (const [path, content] of Object.entries(files)) {

package/src/adapters/thread/adapter-id.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect, expectTypeOf } from "vitest";
+import { ADAPTER_ID as LANGCHAIN } from "./langchain/adapter-id";
+import { ADAPTER_ID as GOOGLE_GENAI } from "./google-genai/adapter-id";
+import { ADAPTER_ID as ANTHROPIC } from "./anthropic/adapter-id";
+import {
+  LANGCHAIN_ADAPTER_ID,
+  GOOGLE_GENAI_ADAPTER_ID,
+  ANTHROPIC_ADAPTER_ID,
+  type ThreadAdapterId,
+} from "./index";
+
+describe("thread adapter identity", () => {
+  it("langchain ADAPTER_ID is the wire-format string", () => {
+    expect(LANGCHAIN).toBe("langChain");
+    expect(LANGCHAIN_ADAPTER_ID).toBe("langChain");
+  });
+
+  it("google-genai ADAPTER_ID is the wire-format string", () => {
+    expect(GOOGLE_GENAI).toBe("googleGenAI");
+    expect(GOOGLE_GENAI_ADAPTER_ID).toBe("googleGenAI");
+  });
+
+  it("anthropic ADAPTER_ID is the wire-format string", () => {
+    expect(ANTHROPIC).toBe("anthropic");
+    expect(ANTHROPIC_ADAPTER_ID).toBe("anthropic");
+  });
+
+  it("ADAPTER_ID values narrow to string literals, not `string`", () => {
+    expectTypeOf(LANGCHAIN).toEqualTypeOf<"langChain">();
+    expectTypeOf(GOOGLE_GENAI).toEqualTypeOf<"googleGenAI">();
+    expectTypeOf(ANTHROPIC).toEqualTypeOf<"anthropic">();
+  });
+
+  it("ThreadAdapterId is the discriminated union of every built-in id", () => {
+    const allow = (_id: ThreadAdapterId): void => undefined;
+    allow(LANGCHAIN);
+    allow(GOOGLE_GENAI);
+    allow(ANTHROPIC);
+    // @ts-expect-error — arbitrary strings aren't members of the union
+    allow("someOtherAdapter");
+  });
+});

package/src/adapters/thread/anthropic/activities.ts

@@ -1,6 +1,7 @@
 import type Redis from "ioredis";
 import type Anthropic from "@anthropic-ai/sdk";
 import type { ToolResultConfig } from "../../../lib/types";
+import type { PersistedThreadState } from "../../../lib/state/types";
 import type {
   ActivityToolHandler,
   RouterContext,
@@ -22,11 +23,10 @@ import {
   createAnthropicModelInvoker,
   type AnthropicModelInvokerConfig,
 } from "./model-invoker";
-
-const ADAPTER_PREFIX = "anthropic" as const;
+import { ADAPTER_ID } from "./adapter-id";
 
 export type AnthropicThreadOps<TScope extends string = ""> = PrefixedThreadOps<
-  ScopedPrefix<TScope, typeof ADAPTER_PREFIX>,
+  ScopedPrefix<TScope, typeof ADAPTER_ID>,
   AnthropicContent
 >;
 
@@ -209,17 +209,52 @@ export function createAnthropicAdapter(
         redis,
         threadId: sourceThreadId,
         key: threadKey,
+        hooks: config.hooks,
       });
       await thread.fork(targetThreadId);
     },
+
+    async truncateThread(
+      threadId: string,
+      messageId: string,
+      threadKey?: string,
+    ): Promise<void> {
+      const thread = createAnthropicThreadManager({ redis, threadId, key: threadKey });
+      await thread.truncateFromId(messageId);
+    },
+
+    async loadThreadState(
+      threadId: string,
+      threadKey?: string
+    ): Promise<PersistedThreadState | null> {
+      const thread = createAnthropicThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
+      return thread.loadState();
+    },
+
+    async saveThreadState(
+      threadId: string,
+      state: PersistedThreadState,
+      threadKey?: string
+    ): Promise<void> {
+      const thread = createAnthropicThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
+      await thread.saveState(state);
+    },
   };
 
   function createActivities<S extends string = "">(
     scope?: S
   ): AnthropicThreadOps<S> {
     const prefix = scope
-      ? `${ADAPTER_PREFIX}${scope.charAt(0).toUpperCase()}${scope.slice(1)}`
-      : ADAPTER_PREFIX;
+      ? `${ADAPTER_ID}${scope.charAt(0).toUpperCase()}${scope.slice(1)}`
+      : ADAPTER_ID;
     const cap = (s: string): string => s.charAt(0).toUpperCase() + s.slice(1);
     return Object.fromEntries(
       Object.entries(threadOps).map(([k, v]) => [`${prefix}${cap(k)}`, v])

package/src/adapters/thread/anthropic/adapter-id.ts

@@ -0,0 +1,16 @@
+/**
+ * Public adapter identity for the Anthropic thread adapter.
+ *
+ * This value is wire format — it appears as the prefix for Temporal
+ * activity names (e.g. `anthropicCodingAgentInitializeThread`) and must
+ * never change, since renaming it would orphan existing persisted
+ * threads and break in-flight workflows.
+ *
+ * Re-exported from `zeitlich/adapters/thread/anthropic` so downstream
+ * consumers can use the exact same literal the adapter uses internally,
+ * typed as the narrow string literal `"anthropic"`.
+ */
+export const ADAPTER_ID = "anthropic" as const;
+
+/** Narrow string-literal type for {@link ADAPTER_ID}. */
+export type AdapterId = typeof ADAPTER_ID;

package/src/adapters/thread/anthropic/fork-transform.test.ts

@@ -0,0 +1,291 @@
+import { describe, expect, it, vi } from "vitest";
+import type { StoredMessage } from "./thread-manager";
+import { createAnthropicThreadManager } from "./thread-manager";
+
+// ---------------------------------------------------------------------------
+// Stateful in-memory Redis mock sufficient for fork / replaceAll flows.
+// Only the commands used by createThreadManager are implemented.
+// ---------------------------------------------------------------------------
+
+function createStatefulRedis() {
+  const lists = new Map<string, string[]>();
+  const strings = new Map<string, string>();
+
+  return {
+    exists: vi.fn(async (...keys: string[]) =>
+      keys.reduce(
+        (acc, k) => acc + (lists.has(k) || strings.has(k) ? 1 : 0),
+        0
+      )
+    ),
+    lrange: vi.fn(async (key: string, start: number, stop: number) => {
+      const list = lists.get(key) ?? [];
+      const end = stop === -1 ? list.length : stop + 1;
+      return list.slice(start, end);
+    }),
+    rpush: vi.fn(async (key: string, ...values: string[]) => {
+      const list = lists.get(key) ?? [];
+      list.push(...values);
+      lists.set(key, list);
+      return list.length;
+    }),
+    ltrim: vi.fn(async (key: string, start: number, stop: number) => {
+      const list = lists.get(key) ?? [];
+      const end = stop === -1 ? list.length : stop + 1;
+      lists.set(key, list.slice(start, end));
+      return "OK";
+    }),
+    del: vi.fn(async (...keys: string[]) => {
+      let removed = 0;
+      for (const k of keys) {
+        if (lists.delete(k)) removed++;
+        if (strings.delete(k)) removed++;
+      }
+      return removed;
+    }),
+    set: vi.fn(async (key: string, value: string) => {
+      strings.set(key, value);
+      return "OK";
+    }),
+    get: vi.fn(async (key: string) => strings.get(key) ?? null),
+    expire: vi.fn(async (_key: string, _ttl: number) => 1),
+    llen: vi.fn(async (key: string) => (lists.get(key) ?? []).length),
+    eval: vi.fn(
+      async (_script: string, _numKeys: number, ...args: string[]) => {
+        const [dedupKey, listKey, , ...serialised] = args;
+        if (!dedupKey || !listKey) return 0;
+        if (strings.has(dedupKey)) return 0;
+        const list = lists.get(listKey) ?? [];
+        list.push(...serialised);
+        lists.set(listKey, list);
+        strings.set(dedupKey, "1");
+        return 1;
+      }
+    ),
+    __peek: {
+      list: (key: string): string[] => [...(lists.get(key) ?? [])],
+      strings,
+    },
+  };
+}
+
+const userMsg: StoredMessage = {
+  id: "msg-1",
+  message: { role: "user", content: [{ type: "text", text: "Hello" }] },
+};
+
+const assistantMsg: StoredMessage = {
+  id: "msg-2",
+  message: {
+    role: "assistant",
+    content: [{ type: "text", text: "Hi there!" }],
+  },
+};
+
+const userMsg2: StoredMessage = {
+  id: "msg-3",
+  message: { role: "user", content: [{ type: "text", text: "Again please" }] },
+};
+
+async function seedSource(
+  redis: ReturnType<typeof createStatefulRedis>,
+  threadId: string,
+  messages: StoredMessage[]
+): Promise<void> {
+  const tm = createAnthropicThreadManager({
+    redis: redis as never,
+    threadId,
+  });
+  await tm.initialize();
+  await tm.append(messages);
+}
+
+describe("Anthropic fork + transform hooks", () => {
+  it("behaves like fork when neither onFork hook is configured", async () => {
+    const redis = createStatefulRedis();
+    await seedSource(redis, "src", [userMsg, assistantMsg]);
+
+    const tm = createAnthropicThreadManager({
+      redis: redis as never,
+      threadId: "src",
+    });
+    const forked = await tm.fork("dst");
+    const loaded = await forked.load();
+
+    expect(loaded).toEqual([userMsg, assistantMsg]);
+
+    // Source is untouched
+    const srcLoaded = await tm.load();
+    expect(srcLoaded).toEqual([userMsg, assistantMsg]);
+  });
+
+  it("applies onForkTransform alone as a per-message map", async () => {
+    const redis = createStatefulRedis();
+    await seedSource(redis, "src", [userMsg, assistantMsg, userMsg2]);
+
+    const calls: Array<{
+      idx: number;
+      id: string;
+      total: number;
+    }> = [];
+    const onForkTransform = vi.fn(
+      (msg: StoredMessage, index: number, messages: readonly StoredMessage[]) => {
+        calls.push({ idx: index, id: msg.id, total: messages.length });
+        const firstBlock = (msg.message.content as Array<{ text?: string }>)[0];
+        return {
+          ...msg,
+          message: {
+            ...msg.message,
+            content: [
+              {
+                type: "text" as const,
+                text: `[T${index}] ${firstBlock?.text ?? ""}`,
+              },
+            ],
+          },
+        };
+      }
+    );
+
+    const tm = createAnthropicThreadManager({
+      redis: redis as never,
+      threadId: "src",
+      hooks: { onForkTransform },
+    });
+    const forked = await tm.fork("dst");
+    const loaded = await forked.load();
+
+    expect(onForkTransform).toHaveBeenCalledTimes(3);
+    expect(calls).toEqual([
+      { idx: 0, id: "msg-1", total: 3 },
+      { idx: 1, id: "msg-2", total: 3 },
+      { idx: 2, id: "msg-3", total: 3 },
+    ]);
+    expect(loaded).toHaveLength(3);
+    expect(loaded[0]?.message.content).toEqual([
+      { type: "text", text: "[T0] Hello" },
+    ]);
+    expect(loaded[1]?.message.content).toEqual([
+      { type: "text", text: "[T1] Hi there!" },
+    ]);
+    expect(loaded[2]?.message.content).toEqual([
+      { type: "text", text: "[T2] Again please" },
+    ]);
+
+    // Source is unchanged.
+    const srcLoaded = await tm.load();
+    expect(srcLoaded.map((m) => m.id)).toEqual(["msg-1", "msg-2", "msg-3"]);
+  });
+
+  it("applies onForkPrepareThread alone and may change list length", async () => {
+    const redis = createStatefulRedis();
+    await seedSource(redis, "src", [userMsg, assistantMsg, userMsg2]);
+
+    const onForkPrepareThread = vi.fn(
+      async (messages: readonly StoredMessage[]) =>
+        // Drop first message and prepend a summary.
+        [
+          {
+            id: "summary-1",
+            message: {
+              role: "user" as const,
+              content: [{ type: "text" as const, text: "[summary]" }],
+            },
+          },
+          ...messages.slice(1),
+        ]
+    );
+
+    const tm = createAnthropicThreadManager({
+      redis: redis as never,
+      threadId: "src",
+      hooks: { onForkPrepareThread },
+    });
+    const forked = await tm.fork("dst");
+    const loaded = await forked.load();
+
+    expect(onForkPrepareThread).toHaveBeenCalledTimes(1);
+    expect(loaded.map((m) => m.id)).toEqual(["summary-1", "msg-2", "msg-3"]);
+  });
+
+  it("runs onForkPrepareThread before onForkTransform and passes prepared list as messages", async () => {
+    const redis = createStatefulRedis();
+    await seedSource(redis, "src", [userMsg, assistantMsg, userMsg2]);
+
+    const order: string[] = [];
+    const indicesSeen: Array<{ idx: number; total: number; id: string }> = [];
+
+    const onForkPrepareThread = vi.fn(
+      async (messages: readonly StoredMessage[]) => {
+        order.push("prepare");
+        // Drop the last message (length changes).
+        return messages.slice(0, -1);
+      }
+    );
+
+    const onForkTransform = vi.fn(
+      (
+        msg: StoredMessage,
+        index: number,
+        messages: readonly StoredMessage[]
+      ) => {
+        order.push("transform");
+        indicesSeen.push({ idx: index, total: messages.length, id: msg.id });
+        return {
+          ...msg,
+          message: {
+            ...msg.message,
+            content: [{ type: "text" as const, text: `[x${index}]` }],
+          },
+        };
+      }
+    );
+
+    const tm = createAnthropicThreadManager({
+      redis: redis as never,
+      threadId: "src",
+      hooks: { onForkPrepareThread, onForkTransform },
+    });
+    const forked = await tm.fork("dst");
+    const loaded = await forked.load();
+
+    // prepare runs once, transform once per survivor.
+    expect(order).toEqual(["prepare", "transform", "transform"]);
+    expect(indicesSeen).toEqual([
+      { idx: 0, total: 2, id: "msg-1" },
+      { idx: 1, total: 2, id: "msg-2" },
+    ]);
+    expect(loaded).toHaveLength(2);
+    expect(loaded[0]?.message.content).toEqual([{ type: "text", text: "[x0]" }]);
+    expect(loaded[1]?.message.content).toEqual([{ type: "text", text: "[x1]" }]);
+  });
+
+  it("leaves dedup markers cleared so the transformed thread can accept replays", async () => {
+    const redis = createStatefulRedis();
+    await seedSource(redis, "src", [userMsg, assistantMsg]);
+
+    const onForkTransform = vi.fn(
+      (msg: StoredMessage) => ({
+        ...msg,
+        message: {
+          ...msg.message,
+          content: [{ type: "text" as const, text: "[replaced]" }],
+        },
+      })
+    );
+
+    const tm = createAnthropicThreadManager({
+      redis: redis as never,
+      threadId: "src",
+      hooks: { onForkTransform },
+    });
+    await tm.fork("dst");
+
+    // After replaceAll, dedup markers from the pre-replacement writes must be
+    // gone — otherwise an append with the same id would be silently skipped.
+    const lingering = Array.from(redis.__peek.strings.keys()).filter((k) =>
+      k.startsWith("messages:thread:dst:dedup:")
+    );
+    expect(lingering).toEqual([]);
+  });
+});