zeitlich 0.2.42 → 0.2.44

package/package.json

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

package/src/lib/.env

@@ -0,0 +1 @@
+E2B_API_KEY=e2b_39af116424059782e2aee6942fd70237cc2126c9

package/src/lib/session/session-edge-cases.integration.test.ts

@@ -176,9 +176,18 @@ describe("createSession edge cases", () => {
     idCounter = 0;
   });
 
-  // --- WAITING_FOR_INPUT flow (condition returns false = timeout) ---
-
-  it("cancels session when WAITING_FOR_INPUT times out (condition returns false)", async () => {
+  // NOTE: a previous test here ("cancels session when WAITING_FOR_INPUT
+  // times out") covered the condition-based wait + cancel-on-timeout flow
+  // that was removed in 7ab652b ("fix: stop halting workflow when
+  // waiting"). The session loop now exits cleanly the moment a tool puts
+  // the agent into WAITING_FOR_INPUT — there is no internal timeout to
+  // assert against — so the test was deleted rather than rewritten. The
+  // assertion below covers the surviving contract: the exit reason
+  // reflects the WAITING_FOR_INPUT state instead of the default
+  // "completed", so callers can distinguish a finished session from a
+  // parked one.
+
+  it("exits with 'waiting_for_input' when a tool parks the session", async () => {
     const { ops } = createMockThreadOps();
     let endReason: string | undefined;
     const capturedRef: {
@@ -191,10 +200,7 @@ describe("createSession edge cases", () => {
       schema: z.object({}),
       handler: async (_args: Record<string, never>, _ctx: RouterContext) => {
         capturedRef.stateManager?.waitForInput();
-        return {
-          toolResponse: "Please provide input.",
-          data: null,
-        };
+        return { toolResponse: "Please provide input.", data: null };
       },
     });
 
@@ -224,9 +230,9 @@ describe("createSession edge cases", () => {
 
     const result = await session.runSession({ stateManager });
 
-    expect(result.exitReason).toBe("cancelled");
-    expect(result.finalMessage).toBeNull();
-    expect(endReason).toBe("cancelled");
+    expect(result.exitReason).toBe("waiting_for_input");
+    expect(endReason).toBe("waiting_for_input");
+    expect(stateManager.getStatus()).toBe("WAITING_FOR_INPUT");
   });
 
   // --- All tool calls are invalid ---

package/src/lib/session/session.ts

@@ -383,46 +383,6 @@ export async function createSession<
         });
       }
 
-      // --- Virtual filesystem init (independent of sandbox) ----------------
-      if (virtualFsConfig) {
-        if (!virtualFsOps) {
-          throw ApplicationFailure.create({
-            message: "No virtualFsOps provided — cannot resolve file tree",
-            nonRetryable: true,
-          });
-        }
-        const result = await virtualFsOps.resolveFileTree(virtualFsConfig.ctx);
-        const skillFiles = skills ? collectSkillFiles(skills) : undefined;
-        const fileTree = skillFiles
-          ? [
-              ...result.fileTree,
-              ...Object.entries(skillFiles).map(([path, content]) => ({
-                id: `skill:${path}`,
-                path,
-                size: content.length,
-                mtime: new Date().toISOString(),
-                metadata: {},
-                // Carry the content directly on the entry so any handler that
-                // constructs a VirtualFileSystem from `fileTree` can read it
-                // without needing to also wire up `inlineFiles` from state.
-                inlineContent: content,
-              })),
-            ]
-          : result.fileTree;
-        stateManager.mergeUpdate({
-          fileTree,
-          virtualFsCtx: virtualFsConfig.ctx,
-          // `inlineFiles` is still the source of truth at read time:
-          // VirtualFileSystem checks the inlineFiles map first and only
-          // falls through to entry.inlineContent. Embedding the content on
-          // the entry is the migration target so that handlers building a
-          // VirtualFileSystem from `fileTree` alone (without forwarding
-          // `inlineFiles` from state) can read skill resources. Until a
-          // follow-up drops `inlineFiles`, both fields are populated.
-          ...(skillFiles && { inlineFiles: skillFiles }),
-        } as Partial<AgentState<TState>>);
-      }
-
       if (hooks.onSessionStart) {
         await hooks.onSessionStart({
           threadId,
@@ -474,6 +434,52 @@ export async function createSession<
           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({
+            message: "No virtualFsOps provided — cannot resolve file tree",
+            nonRetryable: true,
+          });
+        }
+        const result = await virtualFsOps.resolveFileTree(virtualFsConfig.ctx);
+        const skillFiles = skills ? collectSkillFiles(skills) : undefined;
+        const fileTree = skillFiles
+          ? [
+              ...result.fileTree,
+              ...Object.entries(skillFiles).map(([path, content]) => ({
+                id: `skill:${path}`,
+                path,
+                size: content.length,
+                mtime: new Date().toISOString(),
+                metadata: {},
+                // Carry the content directly on the entry so any handler that
+                // constructs a VirtualFileSystem from `fileTree` can read it
+                // without needing to also wire up `inlineFiles` from state.
+                inlineContent: content,
+              })),
+            ]
+          : result.fileTree;
+        stateManager.mergeUpdate({
+          fileTree,
+          virtualFsCtx: virtualFsConfig.ctx,
+          // `inlineFiles` is still the source of truth at read time:
+          // VirtualFileSystem checks the inlineFiles map first and only
+          // falls through to entry.inlineContent. Embedding the content on
+          // the entry is the migration target so that handlers building a
+          // VirtualFileSystem from `fileTree` alone (without forwarding
+          // `inlineFiles` from state) can read skill resources. Until a
+          // follow-up drops `inlineFiles`, both fields are populated.
+          ...(skillFiles && { inlineFiles: skillFiles }),
+        } as Partial<AgentState<TState>>);
+      }
+
       await appendHumanMessage(
         threadId,
         uuid4(),
@@ -596,6 +602,14 @@ export async function createSession<
             threadId,
             maxTurns,
           });
+        } else if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
+          // A tool put the agent into WAITING_FOR_INPUT (e.g. an AskUser
+          // tool). The loop's `isRunning()` guard then exited cleanly; we
+          // report a dedicated exit reason rather than the misleading
+          // default `"completed"`, so callers can distinguish a finished
+          // session from one parked waiting on external input.
+          exitReason = "waiting_for_input";
+          log.info("session waiting for input", { agentName, threadId });
         }
       } catch (error) {
         exitReason = "failed";

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,
       };
     },
 

package/src/lib/subagent/workflow.ts

@@ -168,9 +168,8 @@ export function defineSubagentWorkflow(
 
     // Auto-forward sandbox outputs captured from the session so user code
     // never has to thread them through manually. Explicit values on the fn
-    // result take precedence.
+    // result take precedence, so spread `result` LAST.
     return {
-      ...result,
       ...(capturedThreadId !== undefined && { threadId: capturedThreadId }),
       ...(capturedSandboxId !== undefined && { sandboxId: capturedSandboxId }),
       ...(capturedSnapshot !== undefined && { snapshot: capturedSnapshot }),
@@ -178,6 +177,7 @@ export function defineSubagentWorkflow(
         baseSnapshot: capturedBaseSnapshot,
       }),
       ...(capturedUsage !== undefined && { usage: capturedUsage }),
+      ...result,
     };
   };
 

package/src/tools/bash/.env

@@ -0,0 +1 @@
+E2B_API_KEY=e2b_39af116424059782e2aee6942fd70237cc2126c9