@noetaris/harness 0.8.0 → 0.10.0

package/dist/index.js

@@ -510,6 +510,14 @@ function safeInvoke(hookName, call, sink) {
     reportObserverError(error, { hookName }, sink);
   }
 }
+function safeCall(hookName, call, sink) {
+  try {
+    return call();
+  } catch (error) {
+    reportObserverError(error, { hookName }, sink);
+    return void 0;
+  }
+}
 async function runWrapped(wrap, fn, onObserverError) {
   let p;
   const inner = () => {
@@ -556,6 +564,16 @@ function composeObservers(observers, onObserverError) {
     onStepSettled: (ctx, event) => {
       for (const o of observers) safeInvoke("onStepSettled", () => o.onStepSettled?.(ctx, event), onObserverError);
     },
+    // Each observer isolated on its own; later keys win.
+    carry: (ctx) => {
+      let merged;
+      for (const o of observers) {
+        const carried = safeCall("carry", () => o.carry?.(ctx), onObserverError);
+        if (typeof carried !== "object" || carried === null || Array.isArray(carried)) continue;
+        merged = Object.assign(merged ?? {}, carried);
+      }
+      return merged;
+    },
     // First observer outermost; each layer isolated on its own by runWrapped.
     wrap: (ctx, scope, fn) => {
       const layer = (i) => i === wrappers.length ? fn() : runWrapped((inner) => wrappers[i].wrap(ctx, scope, inner), () => layer(i + 1), onObserverError);
@@ -706,6 +724,11 @@ function stepContextOf(runCtx, stepName) {
 function asError(e) {
   return e instanceof Error ? e : new Error(String(e));
 }
+function normalizeCarrier(carried) {
+  if (typeof carried !== "object" || carried === null || Array.isArray(carried)) return void 0;
+  const entries = Object.entries(carried).filter(([, v]) => typeof v === "string");
+  return entries.length > 0 ? Object.freeze(Object.fromEntries(entries)) : void 0;
+}
 async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callbacks) {
   const { onBeforeStep, onAfterStep, onError, onComplete, onInterrupt } = callbacks ?? {};
   const obs = callbacks?.observer;
@@ -715,15 +738,22 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
   if (!("$interrupt" in state)) state.$interrupt = null;
   if (!("$interruptResponses" in state)) state.$interruptResponses = {};
   const runStart = Date.now();
+  const branchPath = callbacks?.branchPath;
+  const isBranch = branchPath !== void 0 && branchPath.length > 0;
   const runCtx = {
     agentId: ctx.agentId,
     sessionId: ctx.sessionId,
     runId: typeof callbacks?.runId === "string" ? callbacks.runId : "",
     ...typeof callbacks?.parentRunId === "string" ? { parentRunId: callbacks.parentRunId } : {},
     ...typeof ctx.instanceId === "string" ? { instanceId: ctx.instanceId } : {},
-    ...callbacks?.branchPath !== void 0 && callbacks.branchPath.length > 0 ? { branchPath: callbacks.branchPath } : {}
+    ...isBranch ? { branchPath } : {},
+    // Branch runLoops receive the outer callbacks by spread, so the refs are dropped here.
+    ...!isBranch && callbacks?.resumedFrom !== void 0 ? { resumedFrom: callbacks.resumedFrom } : {},
+    ...!isBranch && callbacks?.branchedFrom !== void 0 ? { branchedFrom: callbacks.branchedFrom } : {}
   };
   safeInvoke("onRunStart", () => obs?.onRunStart?.(runCtx), onObserverError);
+  const carrier = isBranch ? void 0 : normalizeCarrier(safeCall("carry", () => obs?.carry?.(runCtx), onObserverError));
+  const withCarrier = (result) => carrier !== void 0 ? { ...result, carrier } : result;
   let runEnded = false;
   const endRun = (signal, failure) => {
     runEnded = true;
@@ -741,7 +771,7 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
     while (true) {
       if (shouldStop?.()) {
         endRun("$stopped");
-        return { state, signal: null, cursor, paused: true };
+        return withCarrier({ state, signal: null, cursor, paused: true });
       }
       if (isForkCursor(cursor)) {
         const forkCursor = cursor;
@@ -765,7 +795,7 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
           graph
         );
         if (outcome.done) {
-          return outcome.result;
+          return withCarrier(outcome.result);
         }
         cursor = outcome.nextCursor;
         continue;
@@ -788,7 +818,7 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
           graph
         );
         if (outcome.done) {
-          return outcome.result;
+          return withCarrier(outcome.result);
         }
         cursor = outcome.nextCursor;
         continue;
@@ -834,7 +864,7 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
             safeInvoke("onInterrupt", () => obs?.onInterrupt?.(stepCtx, { prompt: e.prompt, interruptId: e.interruptId }), onObserverError);
             settle({ outcome: "interrupt", interrupt: { interruptId: e.interruptId, prompt: e.prompt }, next: { kind: "pause" } });
             endRun("$interrupt");
-            return { state, signal: "$interrupt", cursor, paused: true };
+            return withCarrier({ state, signal: "$interrupt", cursor, paused: true });
           }
           state.$error = e instanceof Error ? e : new Error(String(e));
           onError?.(state.$error, cursor);
@@ -856,7 +886,7 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
           state.$error = e instanceof Error ? e : new Error(String(e));
           settle({ outcome: "error", error: state.$error, next: { kind: "pause" } });
           endRun("$error", { error: state.$error });
-          return { state, signal: "$error", cursor, paused: true };
+          return withCarrier({ state, signal: "$error", cursor, paused: true });
         }
         const routed = runSucceeded || step.run === void 0 ? { outcome: "ok", signal } : { outcome: "error", signal, error: state.$error };
         const transition = step.transitions.find((t) => t.signal === signal);
@@ -869,7 +899,7 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
           settle({ ...routed, next: { kind: "end" } });
           onComplete?.(state, signal);
           endRun(signal);
-          return { state, signal, cursor: null, paused: false };
+          return withCarrier({ state, signal, cursor: null, paused: false });
         }
         settle({ ...routed, next: { kind: "step", name: transition.target.name } });
         cursor = transition.target.name;
@@ -880,7 +910,7 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
         } else {
           settle({ outcome: "error", error: state.$error, next: { kind: "pause" } });
           endRun("$error", { error: state.$error });
-          return { state, signal: "$error", cursor, paused: true };
+          return withCarrier({ state, signal: "$error", cursor, paused: true });
         }
       } else {
         const next = step.next ?? implicitNextMap.get(cursor) ?? null;
@@ -1054,6 +1084,13 @@ async function handleFork(forkNode, priorBranches, state, ctx, schema, shouldSto
 }
 
 // src/agent/session-store.ts
+function isValidTtlMs(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function defaultClaimTtlMs() {
+  const ttlMs = Number(process.env["HARNESS_CLAIM_TTL_MS"]);
+  return isValidTtlMs(ttlMs) ? ttlMs : 3e4;
+}
 function collectPendingInterrupts(cursor, state) {
   if (cursor !== void 0 && isForkCursor(cursor)) {
     const result = [];
@@ -1249,9 +1286,16 @@ async function querySessionPhase(store, agentId, sessionId) {
   const loaded = await store.load(agentId, sessionId);
   return storedSessionToPhase(loaded);
 }
+function runRefsOf(loaded) {
+  if (loaded === null || loaded.phase !== "paused") return {};
+  if (loaded.step !== void 0) {
+    return { resumedFrom: { runId: loaded.runId, ...loaded.carrier !== void 0 ? { carrier: loaded.carrier } : {} } };
+  }
+  return loaded.branchedFrom !== void 0 ? { branchedFrom: loaded.branchedFrom } : {};
+}
 async function runWithSession(store, agentId, sessionId, runId, graph, initialStateArg, schema, ctx, options) {
   const leaseRef = options?.leaseRef ?? { current: null };
-  const keepAlive = createKeepAliveFn(leaseRef, store, options?.claimTtlMs ?? 3e4);
+  const keepAlive = createKeepAliveFn(leaseRef, store, options?.claimTtlMs ?? defaultClaimTtlMs());
   ctx["keepAlive"] = keepAlive;
   let leaseExpired = false;
   const composedShouldStop = () => {
@@ -1300,7 +1344,8 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
   const result = await runLoop(graph, state, ctx, schema, composedShouldStop, loaded?.step, {
     ...options,
     runId,
-    ...options?.parentRunId !== void 0 ? { parentRunId: options.parentRunId } : {}
+    ...options?.parentRunId !== void 0 ? { parentRunId: options.parentRunId } : {},
+    ...runRefsOf(loaded)
   });
   if (leaseExpired) {
     const expiredError = new LeaseExpiredError(sessionId);
@@ -1324,7 +1369,8 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
         finalState: result.state,
         step: result.cursor,
         ...result.signal !== null ? { signal: result.signal } : {},
-        ...metadata !== void 0 ? { metadata } : {}
+        ...metadata !== void 0 ? { metadata } : {},
+        ...result.carrier !== void 0 ? { carrier: result.carrier } : {}
       };
       await store.save(agentId, sessionId, saved);
     } else {
@@ -1339,7 +1385,8 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
         initialState: initialStateSnapshot,
         finalState: result.state,
         ...result.signal !== null ? { signal: result.signal } : {},
-        ...metadata !== void 0 ? { metadata } : {}
+        ...metadata !== void 0 ? { metadata } : {},
+        ...result.carrier !== void 0 ? { carrier: result.carrier } : {}
       };
       await store.save(agentId, sessionId, saved);
     }
@@ -1349,6 +1396,50 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
   return result;
 }
 
+// src/agent/claim-scope.ts
+function failOutcome(failState, error) {
+  const state = failState();
+  state["$error"] = error;
+  return { state, signal: "$error" };
+}
+async function runClaimed(args) {
+  const { store, agentId, sessionId, claimOptions, onStoreError, failState, body } = args;
+  const fail = (error) => failOutcome(failState, error);
+  let leaseRef = void 0;
+  if (typeof store?.claim === "function") {
+    let lease;
+    try {
+      lease = await store.claim(agentId, sessionId, claimOptions);
+    } catch (claimError) {
+      const loadError = new StoreLoadError(claimError);
+      onStoreError?.(loadError, "claim");
+      return fail(loadError);
+    }
+    if (lease === null) {
+      const busyError = new SessionBusyError(sessionId);
+      onStoreError?.(busyError, "claim");
+      return fail(busyError);
+    }
+    leaseRef = { current: lease };
+  }
+  try {
+    return await body(leaseRef !== void 0 ? { leaseRef, claimTtlMs: claimOptions.ttlMs } : {});
+  } catch (error) {
+    if (error instanceof LeaseExpiredError) return fail(error);
+    throw error;
+  } finally {
+    if (leaseRef !== void 0 && typeof store?.release === "function") {
+      try {
+        await store.release(leaseRef.current);
+      } catch {
+      }
+    }
+  }
+}
+function parseClaimOptions(raw, fallback) {
+  return typeof raw === "object" && raw !== null && typeof raw["ttlMs"] === "number" ? raw : fallback;
+}
+
 // src/agent/interrupt-resume.ts
 var NoInterruptError = class extends Error {
   constructor() {
@@ -1416,10 +1507,25 @@ async function injectInterruptResponse(store, agentId, sessionId, interruptId, r
     initialState: loaded.initialState,
     finalState: result.state,
     ...result.cursor !== void 0 ? { step: result.cursor } : {},
-    ...loaded.signal !== void 0 ? { signal: loaded.signal } : {}
+    ...loaded.signal !== void 0 ? { signal: loaded.signal } : {},
+    ...loaded.metadata !== void 0 ? { metadata: loaded.metadata } : {},
+    ...loaded.carrier !== void 0 ? { carrier: loaded.carrier } : {},
+    ...loaded.branchedFrom !== void 0 ? { branchedFrom: loaded.branchedFrom } : {}
   };
   await store.save(agentId, sessionId, updated);
 }
+async function injectThenRun(args) {
+  const { store, agentId, sessionId, interruptId, response, onStoreError, failState, run } = args;
+  try {
+    await injectInterruptResponse(store, agentId, sessionId, interruptId, response);
+  } catch (injectError) {
+    if (injectError instanceof NoInterruptError) throw injectError;
+    const storeError = new StoreLoadError(injectError);
+    onStoreError?.(storeError, "claim");
+    return failOutcome(failState, storeError);
+  }
+  return run();
+}
 
 // src/agent/run-handle.ts
 function createRunHandle(sessionId, runId, execution, stopFlag, stepRef, resumeFn) {
@@ -1579,6 +1685,18 @@ var UnexpectedStoreSlotError = class extends Error {
     this.key = key;
   }
 };
+function describeValue(value) {
+  return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+var InvalidClaimOptionsError = class extends Error {
+  /** The rejected `ttlMs` value, as given. */
+  ttlMs;
+  constructor(ttlMs) {
+    super(`claimOptions.ttlMs must be a finite number of milliseconds greater than 0 \u2014 got ${describeValue(ttlMs)} in createAgent options`);
+    this.name = "InvalidClaimOptionsError";
+    this.ttlMs = ttlMs;
+  }
+};
 var _agentInternals = /* @__PURE__ */ Symbol("_agentInternals");
 function createAgent(id, h, slots, agentOptions) {
   const internals = getInternals(h);
@@ -1609,6 +1727,13 @@ function createAgent(id, h, slots, agentOptions) {
       }
     }
   }
+  let agentClaimOptions = void 0;
+  if (agentOptions?.claimOptions !== void 0) {
+    const ttlMs = agentOptions.claimOptions?.ttlMs;
+    if (!isValidTtlMs(ttlMs)) throw new InvalidClaimOptionsError(ttlMs);
+    agentClaimOptions = { ttlMs };
+  }
+  const fallbackClaimOptions = () => agentClaimOptions ?? { ttlMs: defaultClaimTtlMs() };
   const resolvedProviders = /* @__PURE__ */ new Map();
   const storeEntries = [];
   const runtimeKeys = /* @__PURE__ */ new Set();
@@ -1661,7 +1786,9 @@ function createAgent(id, h, slots, agentOptions) {
   const reservedRunKeys = /* @__PURE__ */ new Set(["sessionId", "signal", "events", "listeners", "observer", "onObserverError", "claimOptions", "parentRunId"]);
   const inFlightSessions = /* @__PURE__ */ new Set();
   const interruptPendingSessions = /* @__PURE__ */ new Set();
-  const makeAgentResumeHandle = (resp, sId, iId, resumeOpts, observer, onObserverError, telemetrySlots) => {
+  const resumeFailState = () => initializeState(null, {}, agentInternals.stateSchema);
+  const makeAgentResumeHandle = (resp, sId, iId, resumeResources) => {
+    const { onStoreError, observer, onObserverError, telemetrySlots, parentRunId, claimOptions } = resumeResources;
     let _stopped = false;
     const abortController = new AbortController();
     const flag = {
@@ -1677,86 +1804,63 @@ function createAgent(id, h, slots, agentOptions) {
     const rId = randomUUID();
     const exec = (async () => {
       await Promise.resolve();
-      const claimOptions = { ttlMs: 3e4 };
-      let leaseRef = void 0;
       try {
-        if (typeof capturedStore?.claim === "function") {
-          let lease;
-          try {
-            lease = await capturedStore.claim(id, sId, claimOptions);
-          } catch (claimError) {
-            const loadError = new StoreLoadError(claimError);
-            resumeOpts?.onStoreError?.(loadError, "claim");
-            const failState = initializeState(null, {}, agentInternals.stateSchema);
-            failState["$error"] = loadError;
-            return { state: failState, signal: "$error" };
-          }
-          if (lease === null) {
-            const busyError = new SessionBusyError(sId);
-            resumeOpts?.onStoreError?.(busyError, "claim");
-            const failState = initializeState(null, {}, agentInternals.stateSchema);
-            failState["$error"] = busyError;
-            return { state: failState, signal: "$error" };
-          }
-          leaseRef = { current: lease };
-        }
-        try {
-          if (capturedStore === void 0) throw new NoInterruptError();
-          try {
-            await injectInterruptResponse(capturedStore, id, sId, iId, resp);
-          } catch (injectError) {
-            if (injectError instanceof NoInterruptError) throw injectError;
-            const storeError = new StoreLoadError(injectError);
-            resumeOpts?.onStoreError?.(storeError, "claim");
-            const failState = initializeState(null, {}, agentInternals.stateSchema);
-            failState["$error"] = storeError;
-            return { state: failState, signal: "$error" };
-          }
-          const agentCtx = {
-            ...Object.fromEntries(agentInternals.resolvedProviders),
-            agentId: id,
-            sessionId: sId,
-            runId: rId,
-            signal: abortController.signal
-          };
-          const r = await runWithSession(
-            capturedStore,
-            id,
-            sId,
-            rId,
-            agentInternals.loopDef,
-            {},
-            agentInternals.stateSchema,
-            agentCtx,
-            {
-              shouldStop: () => flag.stopped,
-              onBeforeStep: (n) => {
-                ref.current = n;
-              },
-              ...resumeOpts?.onStoreError !== void 0 ? { onStoreError: resumeOpts.onStoreError } : {},
-              ...leaseRef !== void 0 ? { leaseRef, claimTtlMs: claimOptions.ttlMs } : {},
-              ...observer !== void 0 ? { observer } : {},
-              ...onObserverError !== void 0 ? { onObserverError } : {},
-              ...telemetrySlots !== void 0 && telemetrySlots.length > 0 ? { telemetrySlots } : {}
-            }
-          );
-          if (r.signal === "$interrupt") interruptPendingSessions.add(sId);
-          return { state: r.state, signal: r.signal };
-        } catch (error) {
-          if (error instanceof LeaseExpiredError) {
-            const failState = initializeState(null, {}, agentInternals.stateSchema);
-            failState["$error"] = error;
-            return { state: failState, signal: "$error" };
-          }
-          throw error;
-        } finally {
-          if (leaseRef !== void 0 && typeof capturedStore?.release === "function") {
-            try {
-              await capturedStore.release(leaseRef.current);
-            } catch {
-            }
+        return await runClaimed({
+          store: capturedStore,
+          agentId: id,
+          sessionId: sId,
+          claimOptions,
+          ...onStoreError !== void 0 ? { onStoreError } : {},
+          failState: resumeFailState,
+          body: async (lease) => {
+            if (capturedStore === void 0) throw new NoInterruptError();
+            const store = capturedStore;
+            return injectThenRun({
+              store,
+              agentId: id,
+              sessionId: sId,
+              interruptId: iId,
+              response: resp,
+              ...onStoreError !== void 0 ? { onStoreError } : {},
+              failState: resumeFailState,
+              run: async () => {
+                const agentCtx = {
+                  ...Object.fromEntries(agentInternals.resolvedProviders),
+                  agentId: id,
+                  sessionId: sId,
+                  runId: rId,
+                  signal: abortController.signal,
+                  ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {}
+                };
+                const r = await runWithSession(
+                  store,
+                  id,
+                  sId,
+                  rId,
+                  agentInternals.loopDef,
+                  {},
+                  agentInternals.stateSchema,
+                  agentCtx,
+                  {
+                    shouldStop: () => flag.stopped,
+                    onBeforeStep: (n) => {
+                      ref.current = n;
+                    },
+                    ...onStoreError !== void 0 ? { onStoreError } : {},
+                    ...lease,
+                    ...observer !== void 0 ? { observer } : {},
+                    ...onObserverError !== void 0 ? { onObserverError } : {},
+                    ...telemetrySlots !== void 0 && telemetrySlots.length > 0 ? { telemetrySlots } : {},
+                    ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {},
+                    ...parentRunId !== void 0 ? { parentRunId } : {}
+                  }
+                );
+                if (r.signal === "$interrupt") interruptPendingSessions.add(sId);
+                return { state: r.state, signal: r.signal };
+              }
+            });
           }
-        }
+        });
       } finally {
         inFlightSessions.delete(sId);
       }
@@ -1765,7 +1869,8 @@ function createAgent(id, h, slots, agentOptions) {
       if (inFlightSessions.has(sId)) throw new SessionInFlightError(sId);
       interruptPendingSessions.delete(sId);
       inFlightSessions.add(sId);
-      return makeAgentResumeHandle(r, sId, i);
+      const { parentRunId: _staleParentRunId, ...inherited } = resumeResources;
+      return makeAgentResumeHandle(r, sId, i, inherited);
     };
     return createRunHandle(sId, rId, exec, flag, ref, resumeFn);
   };
@@ -1839,6 +1944,7 @@ function createAgent(id, h, slots, agentOptions) {
         ...Object.entries(runtimeSlots)
       ]);
       const parentRunId = typeof resources["parentRunId"] === "string" ? resources["parentRunId"] : void 0;
+      const claimOptions = parseClaimOptions(resources["claimOptions"], fallbackClaimOptions());
       const options = {
         shouldStop: () => stopFlag.stopped,
         onBeforeStep: (name, state) => {
@@ -1861,63 +1967,31 @@ function createAgent(id, h, slots, agentOptions) {
       let lastResult = null;
       const execution = (async () => {
         await Promise.resolve();
-        const rawClaimOpts = resources["claimOptions"];
-        const claimOptions = typeof rawClaimOpts === "object" && rawClaimOpts !== null && typeof rawClaimOpts["ttlMs"] === "number" ? rawClaimOpts : { ttlMs: 3e4 };
-        let leaseRef = void 0;
         try {
-          if (typeof capturedStore?.claim === "function") {
-            let lease;
-            try {
-              lease = await capturedStore.claim(id, sessionId, claimOptions);
-            } catch (claimError) {
-              const loadError = new StoreLoadError(claimError);
-              events.onStoreError?.(loadError, "claim");
-              const failState = initializeState(null, initialState, agentInternals.stateSchema);
-              failState["$error"] = loadError;
-              return { state: failState, signal: "$error" };
-            }
-            if (lease === null) {
-              const busyError = new SessionBusyError(sessionId);
-              events.onStoreError?.(busyError, "claim");
-              const failState = initializeState(null, initialState, agentInternals.stateSchema);
-              failState["$error"] = busyError;
-              return { state: failState, signal: "$error" };
-            }
-            leaseRef = { current: lease };
-          }
-          try {
-            const r = await runWithSession(
-              capturedStore,
-              id,
-              sessionId,
-              runId,
-              agentInternals.loopDef,
-              initialState,
-              agentInternals.stateSchema,
-              ctx,
-              {
-                ...options,
-                ...leaseRef !== void 0 ? { leaseRef, claimTtlMs: claimOptions.ttlMs } : {}
-              }
-            );
-            if (r.signal === "$interrupt") interruptPendingSessions.add(sessionId);
-            lastResult = { state: r.state, cursor: r.cursor };
-            return { state: r.state, signal: r.signal };
-          } catch (error) {
-            if (error instanceof LeaseExpiredError) {
-              const failState = initializeState(null, initialState, agentInternals.stateSchema);
-              failState["$error"] = error;
-              return { state: failState, signal: "$error" };
-            }
-            throw error;
-          } finally {
-            if (leaseRef !== void 0 && typeof capturedStore?.release === "function") {
-              try {
-                await capturedStore.release(leaseRef.current);
-              } catch {
-              }
+          return await runClaimed({
+            store: capturedStore,
+            agentId: id,
+            sessionId,
+            claimOptions,
+            ...events.onStoreError !== void 0 ? { onStoreError: events.onStoreError } : {},
+            failState: () => initializeState(null, initialState, agentInternals.stateSchema),
+            body: async (lease) => {
+              const r = await runWithSession(
+                capturedStore,
+                id,
+                sessionId,
+                runId,
+                agentInternals.loopDef,
+                initialState,
+                agentInternals.stateSchema,
+                ctx,
+                { ...options, ...lease }
+              );
+              if (r.signal === "$interrupt") interruptPendingSessions.add(sessionId);
+              lastResult = { state: r.state, cursor: r.cursor, runId, ...r.carrier !== void 0 ? { carrier: r.carrier } : {} };
+              return { state: r.state, signal: r.signal };
             }
-          }
+          });
         } finally {
           inFlightSessions.delete(sessionId);
         }
@@ -1949,37 +2023,59 @@ function createAgent(id, h, slots, agentOptions) {
                 signal: resumeAbortController.signal
               };
               if (capturedStore !== void 0) {
-                await injectInterruptResponse(capturedStore, id, sessionId, interruptId, response);
-                const r2 = await runWithSession(
-                  capturedStore,
-                  id,
+                const store = capturedStore;
+                const onStoreError = events.onStoreError;
+                return await runClaimed({
+                  store,
+                  agentId: id,
                   sessionId,
-                  resumeRunId,
-                  agentInternals.loopDef,
-                  {},
-                  agentInternals.stateSchema,
-                  resumeCtx,
-                  {
-                    shouldStop: () => resumeStopFlag.stopped,
-                    onBeforeStep: (n, s) => {
-                      resumeStepRef.current = n;
-                      events.onBeforeStep?.(n, s);
-                    },
-                    // spread optional event callbacks only when defined (exactOptionalPropertyTypes requires omission, not undefined)
-                    ...events.onStoreError !== void 0 ? { onStoreError: events.onStoreError } : {},
-                    ...events.onAfterStep !== void 0 ? { onAfterStep: events.onAfterStep } : {},
-                    ...events.onError !== void 0 ? { onError: events.onError } : {},
-                    ...events.onComplete !== void 0 ? { onComplete: events.onComplete } : {},
-                    ...events.onInterrupt !== void 0 ? { onInterrupt: events.onInterrupt } : {},
-                    ...Object.keys(listeners).length > 0 ? { listeners } : {},
-                    ...observer !== void 0 ? { observer } : {},
-                    ...onObserverError !== void 0 ? { onObserverError } : {},
-                    ...telemetrySlots.length > 0 ? { telemetrySlots } : {}
-                  }
-                );
-                if (r2.signal === "$interrupt") interruptPendingSessions.add(sessionId);
-                lastResult = { state: r2.state, cursor: r2.cursor };
-                return { state: r2.state, signal: r2.signal };
+                  claimOptions,
+                  ...onStoreError !== void 0 ? { onStoreError } : {},
+                  failState: resumeFailState,
+                  body: (lease) => injectThenRun({
+                    store,
+                    agentId: id,
+                    sessionId,
+                    interruptId,
+                    response,
+                    ...onStoreError !== void 0 ? { onStoreError } : {},
+                    failState: resumeFailState,
+                    run: async () => {
+                      const r2 = await runWithSession(
+                        store,
+                        id,
+                        sessionId,
+                        resumeRunId,
+                        agentInternals.loopDef,
+                        {},
+                        agentInternals.stateSchema,
+                        resumeCtx,
+                        {
+                          shouldStop: () => resumeStopFlag.stopped,
+                          onBeforeStep: (n, s) => {
+                            resumeStepRef.current = n;
+                            events.onBeforeStep?.(n, s);
+                          },
+                          // spread optional event callbacks only when defined (exactOptionalPropertyTypes requires omission, not undefined)
+                          ...events.onStoreError !== void 0 ? { onStoreError: events.onStoreError } : {},
+                          ...events.onAfterStep !== void 0 ? { onAfterStep: events.onAfterStep } : {},
+                          ...events.onError !== void 0 ? { onError: events.onError } : {},
+                          ...events.onComplete !== void 0 ? { onComplete: events.onComplete } : {},
+                          ...events.onInterrupt !== void 0 ? { onInterrupt: events.onInterrupt } : {},
+                          ...Object.keys(listeners).length > 0 ? { listeners } : {},
+                          ...observer !== void 0 ? { observer } : {},
+                          ...onObserverError !== void 0 ? { onObserverError } : {},
+                          ...telemetrySlots.length > 0 ? { telemetrySlots } : {},
+                          ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {},
+                          ...lease
+                        }
+                      );
+                      if (r2.signal === "$interrupt") interruptPendingSessions.add(sessionId);
+                      lastResult = { state: r2.state, cursor: r2.cursor, runId: resumeRunId, ...r2.carrier !== void 0 ? { carrier: r2.carrier } : {} };
+                      return { state: r2.state, signal: r2.signal };
+                    }
+                  })
+                });
               }
               const prev = lastResult;
               if (prev === null) throw new NoInterruptError();
@@ -1996,6 +2092,7 @@ function createAgent(id, h, slots, agentOptions) {
                 cursor,
                 {
                   runId: resumeRunId,
+                  resumedFrom: { runId: prev.runId, ...prev.carrier !== void 0 ? { carrier: prev.carrier } : {} },
                   onBeforeStep: (n, s) => {
                     resumeStepRef.current = n;
                     events.onBeforeStep?.(n, s);
@@ -2011,15 +2108,8 @@ function createAgent(id, h, slots, agentOptions) {
                 }
               );
               if (r.signal === "$interrupt") interruptPendingSessions.add(sessionId);
-              lastResult = { state: r.state, cursor: r.cursor };
+              lastResult = { state: r.state, cursor: r.cursor, runId: resumeRunId, ...r.carrier !== void 0 ? { carrier: r.carrier } : {} };
               return { state: r.state, signal: r.signal };
-            } catch (error) {
-              if (error instanceof LeaseExpiredError) {
-                const failState = initializeState(null, initialState, agentInternals.stateSchema);
-                failState["$error"] = error;
-                return { state: failState, signal: "$error" };
-              }
-              throw error;
             } finally {
               inFlightSessions.delete(sessionId);
             }
@@ -2034,11 +2124,19 @@ function createAgent(id, h, slots, agentOptions) {
       interruptPendingSessions.delete(sessionId);
       inFlightSessions.add(sessionId);
       const events = extractRunEvents(resources ?? {});
-      const resumeOpts = events.onStoreError !== void 0 ? { onStoreError: events.onStoreError } : void 0;
       const observer = extractRunObserver(resources ?? {});
       const onObserverError = extractRunErrorSink(resources ?? {});
       const telemetrySlots = buildTelemetrySlots(agentInternals.resolvedProviders.entries());
-      return makeAgentResumeHandle(response, sessionId, interruptId, resumeOpts, observer ?? void 0, onObserverError ?? void 0, telemetrySlots.length > 0 ? telemetrySlots : void 0);
+      const parentRunId = resources?.["parentRunId"];
+      const claimOptions = parseClaimOptions(resources?.["claimOptions"], fallbackClaimOptions());
+      return makeAgentResumeHandle(response, sessionId, interruptId, {
+        claimOptions,
+        ...events.onStoreError !== void 0 ? { onStoreError: events.onStoreError } : {},
+        ...observer !== void 0 ? { observer } : {},
+        ...onObserverError !== void 0 ? { onObserverError } : {},
+        ...telemetrySlots.length > 0 ? { telemetrySlots } : {},
+        ...typeof parentRunId === "string" ? { parentRunId } : {}
+      });
     },
     status: (sessionId) => querySessionPhase(capturedStore, id, sessionId),
     [_agentInternals]: agentInternals