zeitlich 0.2.43 → 0.2.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.43",
+  "version": "0.2.45",
   "description": "[EXPERIMENTAL] An opinionated AI agent implementation for Temporal",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/src/lib/session/session.ts

@@ -163,8 +163,7 @@ export async function createSession<
     unknown,
     SandboxCapability
   >;
-  const wideOps = (): WideSandboxOps =>
-    sandboxOps as unknown as WideSandboxOps;
+  const wideOps = (): WideSandboxOps => sandboxOps as unknown as WideSandboxOps;
   // ---------------------------------------------------------------------------
   // Thread resolution
   // ---------------------------------------------------------------------------
@@ -276,10 +275,7 @@ export async function createSession<
       // defaults are. Both surfaces consult `resolveSessionLifecycle`
       // (or its type-level equivalent) before checking individual
       // mode/shutdown values.
-      const lifecycle = resolveSessionLifecycle(
-        sandboxInit,
-        sandboxShutdown
-      );
+      const lifecycle = resolveSessionLifecycle(sandboxInit, sandboxShutdown);
       const sandboxMode: SandboxInit["mode"] | undefined = lifecycle.mode;
       const resolvedShutdown: SubagentSandboxShutdown = lifecycle.shutdown;
       let sandboxId: string | undefined;
@@ -383,7 +379,48 @@ export async function createSession<
         });
       }
 
+      const sessionStartMs = Date.now();
+      const systemPrompt = stateManager.getSystemPrompt();
+
+      // --- Thread lifecycle: new, continue, or fork ----------------------
+      const rehydrateFromSlice = (slice: PersistedThreadState): void => {
+        stateManager.mergeUpdate({
+          tasks: new Map(slice.tasks),
+          ...slice.custom,
+        } as Partial<AgentState<TState>>);
+      };
+
+      if (threadMode === "fork" && sourceThreadId) {
+        await forkThread(sourceThreadId, threadId, threadKey);
+        const forkedSlice = await loadThreadState(threadId, threadKey);
+        if (forkedSlice) rehydrateFromSlice(forkedSlice);
+      } else if (threadMode === "continue") {
+        // "continue" — thread already exists, just append the new message
+        const continuedSlice = await loadThreadState(threadId, threadKey);
+        if (continuedSlice) rehydrateFromSlice(continuedSlice);
+      } else {
+        if (appendSystemPrompt) {
+          if (
+            systemPrompt == null ||
+            (typeof systemPrompt === "string" && systemPrompt.trim() === "")
+          ) {
+            throw ApplicationFailure.create({
+              message: "No system prompt in state",
+              nonRetryable: true,
+            });
+          }
+          await appendSystemMessage(threadId, uuid4(), systemPrompt, threadKey);
+        } else {
+          await initializeThread(threadId, threadKey);
+        }
+      }
+
       // --- Virtual filesystem init (independent of sandbox) ----------------
+      // Runs AFTER thread rehydration so the freshly resolved tree is
+      // authoritative. Otherwise a stale `fileTree` carried in a persisted
+      // slice (from a run on older code that didn't strip it) could
+      // overwrite entries that no longer exist in the backing store and
+      // cause subsequent FileWrite calls to fail with "not_found".
       if (virtualFsConfig) {
         if (!virtualFsOps) {
           throw ApplicationFailure.create({
@@ -423,6 +460,16 @@ export async function createSession<
         } as Partial<AgentState<TState>>);
       }
 
+      await appendHumanMessage(
+        threadId,
+        uuid4(),
+        await buildContextMessage(),
+        threadKey
+      );
+
+      let exitReason: SessionExitReason = "completed";
+      let finalMessage: M | null = null;
+
       if (hooks.onSessionStart) {
         await hooks.onSessionStart({
           threadId,
@@ -439,51 +486,6 @@ export async function createSession<
         ...(sandboxId && { sandboxId }),
       });
 
-      const sessionStartMs = Date.now();
-      const systemPrompt = stateManager.getSystemPrompt();
-
-      // --- Thread lifecycle: new, continue, or fork ----------------------
-      const rehydrateFromSlice = (slice: PersistedThreadState): void => {
-        stateManager.mergeUpdate({
-          tasks: new Map(slice.tasks),
-          ...slice.custom,
-        } as Partial<AgentState<TState>>);
-      };
-
-      if (threadMode === "fork" && sourceThreadId) {
-        await forkThread(sourceThreadId, threadId, threadKey);
-        const forkedSlice = await loadThreadState(threadId, threadKey);
-        if (forkedSlice) rehydrateFromSlice(forkedSlice);
-      } else if (threadMode === "continue") {
-        // "continue" — thread already exists, just append the new message
-        const continuedSlice = await loadThreadState(threadId, threadKey);
-        if (continuedSlice) rehydrateFromSlice(continuedSlice);
-      } else {
-        if (appendSystemPrompt) {
-          if (
-            systemPrompt == null ||
-            (typeof systemPrompt === "string" && systemPrompt.trim() === "")
-          ) {
-            throw ApplicationFailure.create({
-              message: "No system prompt in state",
-              nonRetryable: true,
-            });
-          }
-          await appendSystemMessage(threadId, uuid4(), systemPrompt, threadKey);
-        } else {
-          await initializeThread(threadId, threadKey);
-        }
-      }
-      await appendHumanMessage(
-        threadId,
-        uuid4(),
-        await buildContextMessage(),
-        threadKey
-      );
-
-      let exitReason: SessionExitReason = "completed";
-      let finalMessage: M | null = null;
-
       try {
         // Per-turn assistant message id. Pre-generated in the workflow
         // so the runAgent activity can truncate the thread from this id

package/src/lib/state/manager.integration.test.ts

@@ -385,6 +385,33 @@ describe("createAgentStateManager integration", () => {
     expect("tools" in slice.custom).toBe(false);
   });
 
+  it("getPersistedSlice strips runtime fields injected via mergeUpdate", () => {
+    const sm = createAgentStateManager<{ label: string }>({
+      initialState: { systemPrompt: "test", label: "original" },
+    });
+
+    sm.mergeUpdate({
+      label: "updated",
+      fileTree: [
+        {
+          id: "f1",
+          path: "/a.txt",
+          size: 1,
+          mtime: "2026-01-01T00:00:00Z",
+          metadata: {},
+        },
+      ],
+      virtualFsCtx: { workspaceBase: "/tmp" },
+      inlineFiles: { "/a.txt": "hi" },
+    } as Parameters<typeof sm.mergeUpdate>[0]);
+
+    const slice = sm.getPersistedSlice();
+    expect(slice.custom).toEqual({ label: "updated" });
+    expect("fileTree" in slice.custom).toBe(false);
+    expect("virtualFsCtx" in slice.custom).toBe(false);
+    expect("inlineFiles" in slice.custom).toBe(false);
+  });
+
   it("mergeUpdate replaces the task map when given a tasks field", () => {
     const sm = createAgentStateManager<{ label: string; extra?: string }>({
       initialState: {

package/src/lib/state/manager.ts

@@ -20,6 +20,32 @@ import type {
 } from "./types";
 import { z } from "zod";
 
+/**
+ * Fields that live on `AgentState` at runtime but must NOT be persisted into
+ * `PersistedThreadState`. They're either managed by the state manager itself
+ * (status/version/turns/tasks/tools/usage), kept in their own slot
+ * (systemPrompt), or rebuilt on each run (the virtual-fs trio).
+ *
+ * Centralizing the list keeps the constructor's destructure-omit and
+ * `getPersistedSlice` in lockstep.
+ */
+const RESERVED_STATE_KEYS = [
+  "status",
+  "version",
+  "turns",
+  "tasks",
+  "tools",
+  "systemPrompt",
+  "fileTree",
+  "inlineFiles",
+  "virtualFsCtx",
+  "totalInputTokens",
+  "totalOutputTokens",
+  "totalReasonTokens",
+  "cachedWriteTokens",
+  "cachedReadTokens",
+] as const;
+
 /**
  * Creates an agent state manager for tracking workflow state.
  * Automatically registers Temporal query and update handlers for the agent.
@@ -238,9 +264,21 @@ export function createAgentStateManager<
     },
 
     getPersistedSlice(): PersistedThreadState {
+      // `customState` can pick up reserved/runtime fields via `mergeUpdate`
+      // (e.g. `fileTree`, `virtualFsCtx`, `inlineFiles` written by the
+      // virtual-fs bootstrap on every run). Those are rebuilt per run and
+      // must never round-trip through the thread store, so strip them here
+      // rather than relying on callers to remember.
+      const source = customState as unknown as Record<string, JsonValue>;
+      const custom: Record<string, JsonValue> = {};
+      const reserved = new Set<string>(RESERVED_STATE_KEYS);
+      for (const [key, value] of Object.entries(source)) {
+        if (reserved.has(key)) continue;
+        custom[key] = value;
+      }
       return {
         tasks: Array.from(tasks.entries()),
-        custom: { ...(customState as unknown as Record<string, JsonValue>) },
+        custom,
       };
     },