@noetaris/harness 0.10.0 → 0.12.0

package/dist/index.js

@@ -634,16 +634,14 @@ function extractRunListeners(resources) {
 // src/agent/ctx-within.ts
 function createWithinFn(observer, currentStep, onObserverError) {
   return (type, payload, fn) => {
-    const wrap = observer?.wrap;
     const stepCtx = currentStep();
-    if (wrap === void 0 || stepCtx === null) return fn();
-    return runWrapped((inner) => wrap(stepCtx, { kind: "event", type, payload }, inner), fn, onObserverError);
+    if (observer?.wrap === void 0 || stepCtx === null) return fn();
+    return runWrapped((inner) => observer.wrap?.(stepCtx, { kind: "event", type, payload }, inner), fn, onObserverError);
   };
 }
 function runStepScope(observer, stepCtx, fn, onObserverError) {
-  const wrap = observer?.wrap;
-  if (wrap === void 0) return fn();
-  return runWrapped((inner) => wrap(stepCtx, { kind: "step" }, inner), fn, onObserverError);
+  if (observer?.wrap === void 0) return fn();
+  return runWrapped((inner) => observer.wrap?.(stepCtx, { kind: "step" }, inner), fn, onObserverError);
 }
 
 // src/loop/loop-executor.ts
@@ -707,10 +705,9 @@ function applyUpdate(state, update, schema, touchedKeys) {
   }
 }
 function fireSettled(obs, stepCtx, stepStart, fields, onObserverError) {
-  const hook = obs?.onStepSettled;
-  if (hook === void 0) return;
+  if (obs?.onStepSettled === void 0) return;
   const event = { ...fields, durationMs: Date.now() - stepStart };
-  safeInvoke("onStepSettled", () => hook(stepCtx, event), onObserverError);
+  safeInvoke("onStepSettled", () => obs.onStepSettled?.(stepCtx, event), onObserverError);
 }
 function stepContextOf(runCtx, stepName) {
   return {
@@ -745,11 +742,13 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
     sessionId: ctx.sessionId,
     runId: typeof callbacks?.runId === "string" ? callbacks.runId : "",
     ...typeof callbacks?.parentRunId === "string" ? { parentRunId: callbacks.parentRunId } : {},
+    ...typeof callbacks?.requestId === "string" ? { requestId: callbacks.requestId } : {},
     ...typeof ctx.instanceId === "string" ? { instanceId: ctx.instanceId } : {},
     ...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 } : {}
+    ...!isBranch && callbacks?.branchedFrom !== void 0 ? { branchedFrom: callbacks.branchedFrom } : {},
+    ...!isBranch && callbacks?.continuedFrom !== void 0 ? { continuedFrom: callbacks.continuedFrom } : {}
   };
   safeInvoke("onRunStart", () => obs?.onRunStart?.(runCtx), onObserverError);
   const carrier = isBranch ? void 0 : normalizeCarrier(safeCall("carry", () => obs?.carry?.(runCtx), onObserverError));
@@ -773,6 +772,24 @@ async function runLoop(graph, state, ctx, schema, shouldStop, startCursor, callb
         endRun("$stopped");
         return withCarrier({ state, signal: null, cursor, paused: true });
       }
+      if (callbacks?.debugGate !== void 0) {
+        const next = isForkCursor(cursor) ? cursor.fork : cursor;
+        const fork = isForkCursor(cursor) || graph.steps.some((s) => s.name === next && isForkDef(s));
+        const { patches, halt } = await callbacks.debugGate(next, state, {
+          branchPath: branchPath ?? [],
+          fork,
+          ...callbacks.touchedKeys !== void 0 ? { touchedKeys: callbacks.touchedKeys } : {},
+          ...ctx.signal !== void 0 ? { signal: ctx.signal } : {}
+        });
+        const nextCtx = stepContextOf(runCtx, next);
+        for (const patch of patches) {
+          safeInvoke("onEvent", () => obs?.onEvent?.(nextCtx, "debug.setState", { patch }), onObserverError);
+        }
+        if (halt || shouldStop?.()) {
+          endRun("$stopped");
+          return withCarrier({ state, signal: null, cursor, paused: true });
+        }
+      }
       if (isForkCursor(cursor)) {
         const forkCursor = cursor;
         const forkNode = graph.steps.find((s) => s.name === forkCursor.fork);
@@ -1026,6 +1043,7 @@ async function dispatchFork(forkNode, priorBranches, outerState, outerCtx, schem
       } else {
         outerState[key] = outcome.result.state[key];
       }
+      callbacks?.touchedKeys?.add(key);
     }
   }
   return {
@@ -1181,6 +1199,15 @@ var SessionInFlightError = class extends Error {
     this.sessionId = sessionId;
   }
 };
+var SessionInDebugError = class extends Error {
+  /** The session being debugged. */
+  sessionId;
+  constructor(sessionId) {
+    super(`session "${sessionId}" is being debugged`);
+    this.name = "SessionInDebugError";
+    this.sessionId = sessionId;
+  }
+};
 var SessionPendingInterruptError = class extends Error {
   /** The session that is awaiting an interrupt response. */
   sessionId;
@@ -1287,12 +1314,32 @@ async function querySessionPhase(store, 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 } : {} } };
-  }
+  if (loaded === null) return {};
+  const ref = { runId: loaded.runId, ...loaded.carrier !== void 0 ? { carrier: loaded.carrier } : {} };
+  if (loaded.phase === "completed") return { continuedFrom: ref };
+  if (loaded.step !== void 0) return { resumedFrom: ref };
   return loaded.branchedFrom !== void 0 ? { branchedFrom: loaded.branchedFrom } : {};
 }
+function decideRun(args) {
+  const { loaded, older, mode, requestId, sessionId } = args;
+  if (loaded === null) return { action: "start" };
+  const pending = loaded.phase === "paused" && collectPendingInterrupts(loaded.step, loaded.finalState).length > 0;
+  if (mode === "resume") {
+    return loaded.phase === "completed" ? { action: "replay", row: loaded } : { action: "continue", mergeInput: false };
+  }
+  if (requestId !== void 0 && loaded.requestId === requestId) {
+    if (loaded.phase === "completed" || pending) return { action: "replay", row: loaded };
+    return { action: "continue", mergeInput: false };
+  }
+  if (older !== null) return { action: "replay", row: older };
+  if (loaded.phase === "completed") return { action: "new-turn" };
+  if (pending) return { action: "reject", error: new SessionPendingInterruptError(sessionId) };
+  return { action: "continue", mergeInput: true };
+}
+function withoutSystemFields(loaded) {
+  const { $error: _error, $interrupt: _interrupt, $interruptResponses: _responses, ...finalState } = loaded.finalState;
+  return { ...loaded, finalState };
+}
 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 ?? defaultClaimTtlMs());
@@ -1306,10 +1353,11 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
     }
     return false;
   };
+  const { mode = "run", requestId: callerRequestId, ...loopOptions } = options ?? {};
   if (store === void 0) {
     const state2 = initializeState(null, initialStateArg, schema);
     const result2 = await runLoop(graph, state2, ctx, schema, composedShouldStop, void 0, {
-      ...options,
+      ...loopOptions,
       runId,
       ...options?.parentRunId !== void 0 ? { parentRunId: options.parentRunId } : {}
     });
@@ -1320,31 +1368,46 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
     }
     return result2;
   }
+  const requestId = mode === "run" ? callerRequestId : void 0;
+  const fail = (error) => {
+    const failState = initializeState(null, initialStateArg, schema);
+    failState["$error"] = error;
+    return { state: failState, signal: "$error", paused: false, cursor: null };
+  };
   let loaded;
+  let older = null;
   try {
     loaded = await store.load(agentId, sessionId);
+    if (requestId !== void 0 && loaded !== null && loaded.requestId !== requestId && typeof store.findRequest === "function") {
+      older = await store.findRequest(agentId, sessionId, requestId);
+    }
   } catch (error) {
     const storeError = new StoreLoadError(error);
     options?.onStoreError?.(storeError, "load");
-    const failState = initializeState(null, initialStateArg, schema);
-    failState["$error"] = storeError;
-    return { state: failState, signal: "$error", paused: false, cursor: null };
+    return fail(storeError);
   }
-  if (loaded !== null && loaded.phase === "completed") {
+  const decision = decideRun({ loaded, older, mode, requestId, sessionId });
+  if (decision.action === "reject") return fail(decision.error);
+  if (decision.action === "replay") {
+    const { row } = decision;
     return {
-      state: loaded.finalState,
-      signal: loaded.signal ?? null,
-      cursor: null,
-      paused: false
+      state: row.finalState,
+      signal: row.signal ?? null,
+      cursor: row.step ?? null,
+      paused: row.phase === "paused"
     };
   }
-  const state = initializeState(loaded, initialStateArg, schema);
+  const segmentRequestId = mode === "run" ? requestId : loaded?.requestId;
+  const base = decision.action === "new-turn" && loaded !== null ? withoutSystemFields(loaded) : loaded;
+  const input = decision.action === "continue" && !decision.mergeInput ? {} : initialStateArg;
+  const state = initializeState(base, input, schema);
   const initialStateSnapshot = { ...state };
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const result = await runLoop(graph, state, ctx, schema, composedShouldStop, loaded?.step, {
-    ...options,
+    ...loopOptions,
     runId,
     ...options?.parentRunId !== void 0 ? { parentRunId: options.parentRunId } : {},
+    ...segmentRequestId !== void 0 ? { requestId: segmentRequestId } : {},
     ...runRefsOf(loaded)
   });
   if (leaseExpired) {
@@ -1370,7 +1433,8 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
         step: result.cursor,
         ...result.signal !== null ? { signal: result.signal } : {},
         ...metadata !== void 0 ? { metadata } : {},
-        ...result.carrier !== void 0 ? { carrier: result.carrier } : {}
+        ...result.carrier !== void 0 ? { carrier: result.carrier } : {},
+        ...segmentRequestId !== void 0 ? { requestId: segmentRequestId } : {}
       };
       await store.save(agentId, sessionId, saved);
     } else {
@@ -1386,7 +1450,8 @@ async function runWithSession(store, agentId, sessionId, runId, graph, initialSt
         finalState: result.state,
         ...result.signal !== null ? { signal: result.signal } : {},
         ...metadata !== void 0 ? { metadata } : {},
-        ...result.carrier !== void 0 ? { carrier: result.carrier } : {}
+        ...result.carrier !== void 0 ? { carrier: result.carrier } : {},
+        ...segmentRequestId !== void 0 ? { requestId: segmentRequestId } : {}
       };
       await store.save(agentId, sessionId, saved);
     }
@@ -1510,7 +1575,8 @@ async function injectInterruptResponse(store, agentId, sessionId, interruptId, r
     ...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 } : {}
+    ...loaded.branchedFrom !== void 0 ? { branchedFrom: loaded.branchedFrom } : {},
+    ...loaded.requestId !== void 0 ? { requestId: loaded.requestId } : {}
   };
   await store.save(agentId, sessionId, updated);
 }
@@ -1576,6 +1642,572 @@ function createRunHandle(sessionId, runId, execution, stopFlag, stepRef, resumeF
   return handle;
 }
 
+// src/agent/debug-session.ts
+var DebugCommandError = class extends Error {
+  /**
+   * - `busy`: another command is still running
+   * - `not-held`: the focused frame is not held at a step stop (or, for `answer`, the session is not at
+   *   an interrupt stop; for `focus`, the frame is not held)
+   * - `not-a-fork`: `stepInto` where the next step is not a fork node
+   * - `reserved-key`: `setState` was given a framework key (`$…`)
+   * - `ended`: the session is over
+   */
+  reason;
+  /** The command that was refused. */
+  command;
+  constructor(reason, command, detail) {
+    super(`${command}(): ${detail ?? describeReason(reason)}`);
+    this.name = "DebugCommandError";
+    this.reason = reason;
+    this.command = command;
+  }
+};
+function describeReason(reason) {
+  switch (reason) {
+    case "busy":
+      return "another debug command is still running";
+    case "not-held":
+      return "the debug session is not stopped where this command applies";
+    case "not-a-fork":
+      return "the next step is not a fork";
+    case "reserved-key":
+      return "framework keys ($\u2026) cannot be set";
+    case "ended":
+      return "the debug session has ended";
+  }
+}
+function cloneOrShare(value) {
+  try {
+    return { value: structuredClone(value), shared: false };
+  } catch {
+    return { value, shared: true };
+  }
+}
+function snapshotOf(source) {
+  const values = {};
+  const shared = [];
+  for (const [key, raw] of Object.entries(source)) {
+    const copy = cloneOrShare(raw);
+    values[key] = copy.value;
+    if (copy.shared) shared.push(key);
+  }
+  return { values, shared };
+}
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  promise.catch(() => {
+  });
+  return { promise, resolve, reject };
+}
+var keyOf = (path) => JSON.stringify(path);
+var samePath = (a, b) => a.length === b.length && a.every((s, i) => s === b[i]);
+var within = (path, root) => path.length >= root.length && root.every((s, i) => s === path[i]);
+function branchStart(parentForkMode) {
+  return {
+    mode: parentForkMode === "fork-entry" ? "fork-entry" : "continue",
+    lastRelease: parentForkMode === "continue" || parentForkMode === void 0 ? "continue" : "hold"
+  };
+}
+function createDebugSession(args) {
+  const { store, signal, onEnd } = args;
+  let status = "starting";
+  let handle;
+  let topMode = "start";
+  let frames = /* @__PURE__ */ new Map();
+  let seq = 0;
+  let focus = [];
+  let lastByFrame = /* @__PURE__ */ new Map();
+  let topInterrupt;
+  let interrupts = [];
+  let pausedForks = /* @__PURE__ */ new Map();
+  let paused;
+  let stopRequested = false;
+  let lease = {};
+  let renewal;
+  const breakpoints = /* @__PURE__ */ new Map();
+  let command;
+  let idle;
+  const first = deferred();
+  let current = first.promise;
+  let started = false;
+  const ended = deferred();
+  const done = deferred();
+  const anyHeld = () => [...frames.values()].some((f) => f.status === "held");
+  const updateRenewal = () => {
+    if (!anyHeld()) {
+      if (renewal !== void 0) clearInterval(renewal);
+      renewal = void 0;
+      return;
+    }
+    if (renewal !== void 0) return;
+    const { leaseRef, claimTtlMs } = lease;
+    const extendClaim = store?.extendClaim;
+    if (leaseRef === void 0 || claimTtlMs === void 0 || typeof extendClaim !== "function") return;
+    const renew = () => {
+      const held = leaseRef.current;
+      if (held === null) return;
+      extendClaim.call(store, held, { ttlMs: claimTtlMs }).then((renewed) => {
+        leaseRef.current = renewed;
+      }, () => {
+      });
+    };
+    renew();
+    renewal = setInterval(renew, claimTtlMs / 3);
+    renewal.unref?.();
+  };
+  const frameOf = (path) => frames.get(keyOf(path));
+  const addFrame = (path, init) => {
+    const frame = { path, seq: seq++, patches: [], ...init };
+    frames.set(keyOf(path), frame);
+    return frame;
+  };
+  const treeOrder = (a, b) => {
+    const n = Math.min(a.path.length, b.path.length);
+    for (let i = 0; i < n; i++) {
+      if (a.path[i] !== b.path[i]) {
+        const sa = frameOf(a.path.slice(0, i + 1))?.seq ?? 0;
+        const sb = frameOf(b.path.slice(0, i + 1))?.seq ?? 0;
+        return sa - sb;
+      }
+    }
+    return a.path.length - b.path.length;
+  };
+  const sortedFrames = () => [...frames.values()].sort(treeOrder);
+  const dropDescendants = (root) => {
+    for (const [key, frame] of frames) {
+      if (frame.path.length > root.length && within(frame.path, root)) frames.delete(key);
+    }
+  };
+  const seedPausedFork = (frame, forkName) => {
+    const settled = pausedForks.get(keyOf(frame.path));
+    if (settled?.fork === void 0 || settled.name !== forkName) return;
+    pausedForks.delete(keyOf(frame.path));
+    for (const branch of settled.fork.branches) {
+      addFrame([...frame.path, branch.name], { status: branch.status === "done" ? "ended" : "running", ...branchStart(frame.forkMode) });
+    }
+  };
+  const setCurrent = (stop) => {
+    current = Promise.resolve(stop);
+    if (!started) {
+      started = true;
+      first.resolve(stop);
+    }
+  };
+  const deliver = (stop, frame) => {
+    focus = frame;
+    setCurrent(stop);
+    const c = command;
+    command = void 0;
+    c?.result.resolve(stop);
+    const w = idle;
+    idle = void 0;
+    w?.resolve(stop);
+  };
+  const offerStop = (stop) => {
+    if (!started) return deliver(stop, stop.frame);
+    if (command !== void 0) {
+      const { target, orphan } = command;
+      if (target === "any" || orphan !== void 0 || within(stop.frame, target)) deliver(stop, stop.frame);
+      return;
+    }
+    if (idle !== void 0) deliver(stop, stop.frame);
+  };
+  const branchEndStop = (frame, endedFrame) => {
+    const held = frame.stop;
+    const stop = {
+      kind: "step",
+      frame: frame.path,
+      reason: "branch-end",
+      ended: endedFrame,
+      runId: held.runId,
+      next: held.next,
+      ...held.last !== void 0 ? { last: held.last } : {},
+      state: held.state
+    };
+    frame.stop = stop;
+    return stop;
+  };
+  const afterFrameEnd = (endedFrame) => {
+    setTimeout(() => {
+      if (status !== "active") return;
+      const heldFrame = sortedFrames().find((f) => f.status === "held");
+      if (command !== void 0) {
+        if (command.orphan !== endedFrame) return;
+        if (heldFrame !== void 0) deliver(branchEndStop(heldFrame, endedFrame), heldFrame.path);
+        return;
+      }
+      if (!samePath(focus, endedFrame.frame)) return;
+      if (heldFrame !== void 0) {
+        focus = heldFrame.path;
+        setCurrent(branchEndStop(heldFrame, endedFrame));
+      } else {
+        idle ??= deferred();
+        current = idle.promise;
+      }
+    }, 0);
+  };
+  const onFrameEnd = (path, signal2) => {
+    const frame = frameOf(path);
+    if (frame === void 0) return;
+    frame.status = "ended";
+    const parent = frameOf(path.slice(0, -1));
+    if (parent !== void 0) parent.joinHold = frame.lastRelease === "hold";
+    const outcome = signal2 === "$interrupt" ? "interrupt" : signal2 === "$error" ? "error" : signal2 === "$stopped" ? "stopped" : "done";
+    const last = lastByFrame.get(keyOf(path));
+    const endedFrame = { frame: path, outcome, ...last !== void 0 ? { last } : {} };
+    updateRenewal();
+    if (command !== void 0) {
+      if (command.target !== "any" && samePath(command.target, path)) {
+        command.orphan = endedFrame;
+        afterFrameEnd(endedFrame);
+      }
+      return;
+    }
+    if (samePath(focus, path)) afterFrameEnd(endedFrame);
+  };
+  const onAbort = () => {
+    void session.stop();
+  };
+  const cleanup = () => {
+    for (const frame of frames.values()) if (frame.status === "held") frame.status = "ended";
+    updateRenewal();
+    signal?.removeEventListener("abort", onAbort);
+    onEnd();
+  };
+  const topLast = () => lastByFrame.get(keyOf([]));
+  const finish = (outcome) => {
+    const last = topLast();
+    const stop = { kind: "end", runId: handle.runId, ...last !== void 0 ? { last } : {}, outcome };
+    status = "ended";
+    cleanup();
+    done.resolve(outcome);
+    deliver(stop, []);
+    ended.resolve(stop);
+  };
+  const fail = (error) => {
+    status = "ended";
+    cleanup();
+    done.reject(error);
+    const c = command;
+    command = void 0;
+    c?.result.reject(error);
+    const w = idle;
+    idle = void 0;
+    w?.reject(error);
+    if (!started) first.reject(error);
+    else current = done.promise.then(() => {
+      throw error;
+    });
+    current.catch(() => {
+    });
+    ended.reject(error);
+  };
+  const pendingInterrupts = () => {
+    const pending = [];
+    const walk = (path) => {
+      const settled = lastByFrame.get(keyOf(path));
+      if (settled?.fork === void 0) return;
+      for (const branch of settled.fork.branches) {
+        if (branch.status !== "paused") continue;
+        const branchPath = [...path, branch.name];
+        const raised = interrupts.find((i) => samePath(i.branchPath, branchPath));
+        if (raised !== void 0) pending.push({ interruptId: raised.interruptId, prompt: raised.prompt, frame: branchPath });
+        else walk(branchPath);
+      }
+    };
+    if (topInterrupt !== void 0 && topLast()?.fork === void 0) {
+      pending.push({ interruptId: topInterrupt.interruptId, prompt: topInterrupt.prompt, frame: [] });
+    } else {
+      walk([]);
+    }
+    return pending;
+  };
+  const attach = (h) => {
+    h.then((outcome) => {
+      const last = topLast();
+      if (outcome.signal === "$interrupt" && !stopRequested && last !== void 0) {
+        const pending = pendingInterrupts();
+        const head = pending[0];
+        if (head !== void 0) {
+          status = "interrupt";
+          paused = { outcome, pending };
+          for (const frame of frames.values()) if (frame.status === "held") frame.status = "ended";
+          updateRenewal();
+          deliver({
+            kind: "interrupt",
+            frame: head.frame,
+            runId: h.runId,
+            last,
+            interruptId: head.interruptId,
+            prompt: head.prompt,
+            pending,
+            state: snapshotOf(outcome.state)
+          }, head.frame);
+          return;
+        }
+      }
+      finish(outcome);
+    }, fail);
+  };
+  const gate = async (next, state, info) => {
+    const path = info.branchPath;
+    let frame = frameOf(path);
+    if (frame === void 0) {
+      if (path.length === 0) {
+        frame = addFrame(path, { status: "running", mode: topMode, lastRelease: "hold" });
+      } else {
+        frame = addFrame(path, { status: "running", ...branchStart(frameOf(path.slice(0, -1))?.forkMode) });
+      }
+    } else if (frame.status === "in-fork") {
+      dropDescendants(path);
+      frame.mode = frame.joinHold === false ? "continue" : "step";
+      frame.joinHold = void 0;
+      frame.forkMode = void 0;
+    }
+    if (info.signal?.aborted === true) return { patches: [], halt: true };
+    let reason;
+    let condition;
+    if (frame.mode !== "continue") {
+      reason = frame.mode;
+    } else {
+      const breakpoint = breakpoints.get(next);
+      if (breakpoint !== void 0) {
+        try {
+          if (breakpoint.when === void 0 || breakpoint.when(state)) reason = "breakpoint";
+        } catch (error) {
+          reason = "breakpoint";
+          condition = { error };
+        }
+      }
+    }
+    const enter = () => {
+      frame.before = snapshotOf(state);
+      if (info.fork) {
+        frame.status = "in-fork";
+        frame.forkMode ??= frame.mode === "continue" ? "continue" : "over";
+        seedPausedFork(frame, next);
+      } else {
+        frame.status = "running";
+      }
+    };
+    if (reason === void 0) {
+      enter();
+      return { patches: [], halt: false };
+    }
+    frame.status = "held";
+    frame.next = next;
+    frame.isFork = info.fork;
+    frame.live = state;
+    frame.forkMode = void 0;
+    if (info.touchedKeys !== void 0) frame.touched = info.touchedKeys;
+    const last = lastByFrame.get(keyOf(path));
+    const stop = {
+      kind: "step",
+      frame: path,
+      reason,
+      runId: handle.runId,
+      next,
+      ...last !== void 0 ? { last } : {},
+      state: snapshotOf(state),
+      ...condition !== void 0 ? { conditionError: condition.error } : {}
+    };
+    frame.stop = stop;
+    const released = new Promise((resolve) => {
+      frame.release = resolve;
+    });
+    const onHalt = () => {
+      frame.release?.({ patches: [], halt: true });
+    };
+    info.signal?.addEventListener("abort", onHalt);
+    updateRenewal();
+    offerStop(stop);
+    const result = await released;
+    info.signal?.removeEventListener("abort", onHalt);
+    frame.release = void 0;
+    frame.live = void 0;
+    if (!result.halt) enter();
+    updateRenewal();
+    return result;
+  };
+  const release = (frame, how, halt = false) => {
+    if (!halt) {
+      frame.mode = how === "next" ? "step" : "continue";
+      frame.lastRelease = how === "next" || how === "stepInto" ? "hold" : "continue";
+      if (frame.isFork === true) frame.forkMode = how === "stepInto" ? "fork-entry" : how === "next" ? "over" : "continue";
+      frame.status = frame.isFork === true ? "in-fork" : "running";
+    }
+    const patches = frame.patches;
+    frame.patches = [];
+    const r = frame.release;
+    frame.release = void 0;
+    r?.({ patches, halt });
+  };
+  const observer = {
+    onStepSettled: (ctx, e) => {
+      const path = ctx.branchPath ?? [];
+      if (path.length === 0) {
+        topInterrupt = e.interrupt !== void 0 ? { interruptId: e.interrupt.interruptId, prompt: e.interrupt.prompt, branchPath: [] } : void 0;
+      }
+      lastByFrame.set(keyOf(path), {
+        name: ctx.stepName,
+        outcome: e.outcome,
+        ...e.update !== void 0 ? { update: snapshotOf(e.update) } : {},
+        ...e.signal !== void 0 ? { signal: e.signal } : {},
+        next: e.next,
+        ...e.error !== void 0 ? { error: e.error } : {},
+        before: frameOf(path)?.before ?? { values: {}, shared: [] },
+        durationMs: e.durationMs,
+        ...e.fork !== void 0 ? { fork: e.fork } : {}
+      });
+    },
+    onInterrupt: (ctx, e) => {
+      interrupts.push({ interruptId: e.interruptId, prompt: e.prompt, branchPath: ctx.branchPath ?? [] });
+    },
+    onRunEnd: (ctx, e) => {
+      if (ctx.branchPath !== void 0) onFrameEnd(ctx.branchPath, e.signal);
+    }
+  };
+  const refuse = (name) => {
+    if (status === "ended") return new DebugCommandError("ended", name);
+    if (status === "starting" || !started || command !== void 0) return new DebugCommandError("busy", name);
+    if (status === "interrupt" && name !== "answer") return new DebugCommandError("not-held", name);
+    if (status === "active" && name === "answer") return new DebugCommandError("not-held", name);
+    return void 0;
+  };
+  const issue = (target) => {
+    const result = deferred();
+    command = { target, result };
+    return result.promise;
+  };
+  const drive = (how) => {
+    const refused = refuse(how);
+    if (refused !== void 0) return Promise.reject(refused);
+    const frame = frameOf(focus);
+    if (frame === void 0 || frame.status !== "held") return Promise.reject(new DebugCommandError("not-held", how));
+    if (how === "stepInto" && frame.isFork !== true) return Promise.reject(new DebugCommandError("not-a-fork", how));
+    const p = issue(frame.path);
+    release(frame, how);
+    updateRenewal();
+    return p;
+  };
+  const session = {
+    get sessionId() {
+      return handle.sessionId;
+    },
+    get runId() {
+      return handle.runId;
+    },
+    get current() {
+      return current;
+    },
+    get done() {
+      return done.promise;
+    },
+    get breakpoints() {
+      return [...breakpoints.values()];
+    },
+    get frames() {
+      return sortedFrames().map((f) => ({ frame: f.path, status: f.status, ...f.status === "held" && f.next !== void 0 ? { next: f.next } : {} }));
+    },
+    focus: (path) => {
+      const frame = frameOf(path);
+      if (status !== "active" || frame === void 0 || frame.status !== "held" || frame.stop === void 0) {
+        throw new DebugCommandError("not-held", "focus");
+      }
+      focus = frame.path;
+      setCurrent(frame.stop);
+      return frame.stop;
+    },
+    next: () => drive("next"),
+    continue: () => drive("continue"),
+    stepInto: () => drive("stepInto"),
+    continueAll: () => {
+      const refused = refuse("continueAll");
+      if (refused !== void 0) return Promise.reject(refused);
+      const p = issue("any");
+      for (const frame of sortedFrames()) if (frame.status === "held") release(frame, "continueAll");
+      updateRenewal();
+      return p;
+    },
+    answer: (response, id) => {
+      const at = paused;
+      const refused = refuse("answer") ?? (at === void 0 ? new DebugCommandError("not-held", "answer") : void 0);
+      if (refused !== void 0 || at === void 0) return Promise.reject(refused);
+      const target = id ?? at.pending[0].interruptId;
+      if (!at.pending.some((p2) => p2.interruptId === target)) return Promise.reject(new NoInterruptError());
+      let resumed;
+      try {
+        resumed = handle.resume(response, target);
+      } catch (error) {
+        return Promise.reject(error);
+      }
+      pausedForks = new Map([...lastByFrame].filter(([, s]) => s.fork !== void 0 && (s.outcome === "interrupt" || s.outcome === "stopped")));
+      handle = resumed;
+      paused = void 0;
+      status = "active";
+      topMode = "resume";
+      frames = /* @__PURE__ */ new Map();
+      focus = [];
+      lastByFrame = /* @__PURE__ */ new Map();
+      topInterrupt = void 0;
+      interrupts = [];
+      lease = {};
+      const p = issue([]);
+      attach(handle);
+      return p;
+    },
+    setState: (patch) => {
+      if (status === "ended") throw new DebugCommandError("ended", "setState");
+      const frame = frameOf(focus);
+      if (status !== "active" || frame === void 0 || frame.status !== "held" || frame.live === void 0) {
+        throw new DebugCommandError("not-held", "setState");
+      }
+      const reserved = Object.keys(patch).find((k) => k.startsWith("$"));
+      if (reserved !== void 0) throw new DebugCommandError("reserved-key", "setState", `framework key "${reserved}" cannot be set`);
+      const reported = {};
+      for (const [key, value] of Object.entries(patch)) {
+        frame.live[key] = cloneOrShare(value).value;
+        reported[key] = cloneOrShare(value).value;
+        frame.touched?.add(key);
+      }
+      frame.patches.push(reported);
+      return snapshotOf(frame.live);
+    },
+    setBreakpoint: (step, when) => {
+      breakpoints.set(step, { step, ...when !== void 0 ? { when } : {} });
+    },
+    clearBreakpoint: (step) => {
+      breakpoints.delete(step);
+    },
+    stop: () => {
+      if (status === "ended") return ended.promise;
+      stopRequested = true;
+      if (status === "interrupt" && paused !== void 0) {
+        finish(paused.outcome);
+        return ended.promise;
+      }
+      handle.stop();
+      for (const frame of frames.values()) if (frame.status === "held") release(frame, "continueAll", true);
+      return ended.promise;
+    }
+  };
+  handle = args.start({ gate, observer, onLease: (l) => {
+    lease = l;
+  } });
+  status = "active";
+  attach(handle);
+  if (signal !== void 0) {
+    signal.addEventListener("abort", onAbort);
+    if (signal.aborted) onAbort();
+  }
+  return session;
+}
+
 // src/agent/create-agent.ts
 import { randomUUID } from "crypto";
 
@@ -1697,6 +2329,36 @@ var InvalidClaimOptionsError = class extends Error {
     this.ttlMs = ttlMs;
   }
 };
+var InvalidAgentOptionError = class extends Error {
+  /** The option that was rejected. */
+  key;
+  /** The rejected value, as given. */
+  value;
+  constructor(key, value) {
+    super(`${key} must be ${key === "observer" ? "an object" : "a function"} \u2014 got ${describeValue(value)} in createAgent options`);
+    this.name = "InvalidAgentOptionError";
+    this.key = key;
+    this.value = value;
+  }
+};
+var InvalidRunResourceError = class extends Error {
+  /** The resource key that was rejected. */
+  key;
+  /** The rejected value, as given. */
+  value;
+  constructor(key, value) {
+    super(`${key} must be a non-empty string \u2014 got ${describeValue(value)} in agent.run() resources`);
+    this.name = "InvalidRunResourceError";
+    this.key = key;
+    this.value = value;
+  }
+};
+function readIdResource(resources, key) {
+  const value = resources[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.length === 0) throw new InvalidRunResourceError(key, value);
+  return value;
+}
 var _agentInternals = /* @__PURE__ */ Symbol("_agentInternals");
 function createAgent(id, h, slots, agentOptions) {
   const internals = getInternals(h);
@@ -1734,6 +2396,23 @@ function createAgent(id, h, slots, agentOptions) {
     agentClaimOptions = { ttlMs };
   }
   const fallbackClaimOptions = () => agentClaimOptions ?? { ttlMs: defaultClaimTtlMs() };
+  const agentObserver = agentOptions?.observer;
+  if (agentObserver !== void 0 && (agentObserver === null || typeof agentObserver !== "object" || Array.isArray(agentObserver))) {
+    throw new InvalidAgentOptionError("observer", agentObserver);
+  }
+  const agentErrorSink = agentOptions?.onObserverError;
+  if (agentErrorSink !== void 0 && typeof agentErrorSink !== "function") {
+    throw new InvalidAgentOptionError("onObserverError", agentErrorSink);
+  }
+  const resolveObserver = (resources) => {
+    const runObserver = extractRunObserver(resources);
+    const onObserverError = extractRunErrorSink(resources) ?? agentErrorSink;
+    const observer = agentObserver === void 0 ? runObserver : runObserver === void 0 || runObserver === agentObserver ? agentObserver : composeObservers([agentObserver, runObserver], onObserverError);
+    return {
+      ...observer !== void 0 ? { observer } : {},
+      ...onObserverError !== void 0 ? { onObserverError } : {}
+    };
+  };
   const resolvedProviders = /* @__PURE__ */ new Map();
   const storeEntries = [];
   const runtimeKeys = /* @__PURE__ */ new Set();
@@ -1783,8 +2462,9 @@ function createAgent(id, h, slots, agentOptions) {
     runtimeKeys,
     requiredKeys
   };
-  const reservedRunKeys = /* @__PURE__ */ new Set(["sessionId", "signal", "events", "listeners", "observer", "onObserverError", "claimOptions", "parentRunId"]);
+  const reservedRunKeys = /* @__PURE__ */ new Set(["sessionId", "requestId", "signal", "events", "listeners", "observer", "onObserverError", "claimOptions", "parentRunId"]);
   const inFlightSessions = /* @__PURE__ */ new Set();
+  const debugSessions = /* @__PURE__ */ new Set();
   const interruptPendingSessions = /* @__PURE__ */ new Set();
   const resumeFailState = () => initializeState(null, {}, agentInternals.stateSchema);
   const makeAgentResumeHandle = (resp, sId, iId, resumeResources) => {
@@ -1842,6 +2522,7 @@ function createAgent(id, h, slots, agentOptions) {
                   agentInternals.stateSchema,
                   agentCtx,
                   {
+                    mode: "resume",
                     shouldStop: () => flag.stopped,
                     onBeforeStep: (n) => {
                       ref.current = n;
@@ -1855,7 +2536,6 @@ function createAgent(id, h, slots, agentOptions) {
                     ...parentRunId !== void 0 ? { parentRunId } : {}
                   }
                 );
-                if (r.signal === "$interrupt") interruptPendingSessions.add(sId);
                 return { state: r.state, signal: r.signal };
               }
             });
@@ -1874,258 +2554,269 @@ function createAgent(id, h, slots, agentOptions) {
     };
     return createRunHandle(sId, rId, exec, flag, ref, resumeFn);
   };
-  const agent = {
-    id,
-    run: (initialState, resources) => {
-      for (const key of Object.keys(resources)) {
-        if (reservedRunKeys.has(key)) continue;
-        if (!agentInternals.runtimeKeys.has(key) && !agentInternals.requiredKeys.has(key)) {
-          throw new UnknownRunSlotError(key);
-        }
+  const startRun = (initialState, resources, debug) => {
+    for (const key of Object.keys(resources)) {
+      if (reservedRunKeys.has(key)) continue;
+      if (!agentInternals.runtimeKeys.has(key) && !agentInternals.requiredKeys.has(key)) {
+        throw new UnknownRunSlotError(key);
       }
-      for (const key of Object.keys(resources)) {
-        if (reservedRunKeys.has(key)) continue;
-        if (agentInternals.requiredKeys.has(key)) {
-          throw new RequiredSlotInRunError(key);
-        }
+    }
+    for (const key of Object.keys(resources)) {
+      if (reservedRunKeys.has(key)) continue;
+      if (agentInternals.requiredKeys.has(key)) {
+        throw new RequiredSlotInRunError(key);
       }
-      for (const key of agentInternals.runtimeKeys) {
-        if (!(key in resources)) {
-          throw new MissingRuntimeSlotError(key);
-        }
+    }
+    for (const key of agentInternals.runtimeKeys) {
+      if (!(key in resources)) {
+        throw new MissingRuntimeSlotError(key);
       }
-      const sessionId = typeof resources["sessionId"] === "string" ? resources["sessionId"] : randomUUID();
-      const runId = randomUUID();
-      if (inFlightSessions.has(sessionId)) throw new SessionInFlightError(sessionId);
-      if (interruptPendingSessions.has(sessionId)) throw new SessionPendingInterruptError(sessionId);
-      inFlightSessions.add(sessionId);
-      let _stopped = false;
-      const abortController = new AbortController();
-      const stopFlag = {
-        get stopped() {
-          return _stopped;
-        },
-        set stopped(v) {
-          _stopped = v;
-          if (v) abortController.abort();
-        }
-      };
-      const rawSignal = resources["signal"];
-      let ctxSignal = abortController.signal;
-      if (rawSignal instanceof AbortSignal) {
-        ctxSignal = rawSignal;
-        rawSignal.addEventListener("abort", () => {
-          stopFlag.stopped = true;
-          abortController.abort();
-        }, { once: true });
-        if (rawSignal.aborted) stopFlag.stopped = true;
+    }
+    const sessionId = readIdResource(resources, "sessionId") ?? randomUUID();
+    const requestId = readIdResource(resources, "requestId");
+    const runId = randomUUID();
+    if (debugSessions.has(sessionId)) throw new SessionInDebugError(sessionId);
+    if (inFlightSessions.has(sessionId)) throw new SessionInFlightError(sessionId);
+    if (capturedStore === void 0 && interruptPendingSessions.has(sessionId)) throw new SessionPendingInterruptError(sessionId);
+    inFlightSessions.add(sessionId);
+    let _stopped = false;
+    const abortController = new AbortController();
+    const stopFlag = {
+      get stopped() {
+        return _stopped;
+      },
+      set stopped(v) {
+        _stopped = v;
+        if (v) abortController.abort();
       }
-      const stepRef = { current: null };
-      const runtimeSlots = {};
-      for (const key of agentInternals.runtimeKeys) {
-        if (reservedRunKeys.has(key)) continue;
-        runtimeSlots[key] = resources[key];
+    };
+    const rawSignal = debug === void 0 ? resources["signal"] : void 0;
+    let ctxSignal = abortController.signal;
+    if (rawSignal instanceof AbortSignal) {
+      ctxSignal = rawSignal;
+      rawSignal.addEventListener("abort", () => {
+        stopFlag.stopped = true;
+        abortController.abort();
+      }, { once: true });
+      if (rawSignal.aborted) stopFlag.stopped = true;
+    }
+    const stepRef = { current: null };
+    const runtimeSlots = {};
+    for (const key of agentInternals.runtimeKeys) {
+      if (reservedRunKeys.has(key)) continue;
+      runtimeSlots[key] = resources[key];
+    }
+    const ctx = {
+      ...Object.fromEntries(agentInternals.resolvedProviders),
+      ...runtimeSlots,
+      agentId: id,
+      sessionId,
+      runId,
+      signal: ctxSignal,
+      ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {}
+    };
+    const events = extractRunEvents(resources);
+    const listeners = extractRunListeners(resources);
+    const resolved = resolveObserver(resources);
+    const onObserverError = resolved.onObserverError;
+    const observer = debug === void 0 ? resolved.observer : resolved.observer === void 0 ? debug.observer : composeObservers([resolved.observer, debug.observer], onObserverError);
+    const telemetrySlots = buildTelemetrySlots([
+      ...agentInternals.resolvedProviders.entries(),
+      ...Object.entries(runtimeSlots)
+    ]);
+    const parentRunId = typeof resources["parentRunId"] === "string" ? resources["parentRunId"] : void 0;
+    const claimOptions = parseClaimOptions(resources["claimOptions"], fallbackClaimOptions());
+    const options = {
+      mode: "run",
+      ...requestId !== void 0 ? { requestId } : {},
+      shouldStop: () => stopFlag.stopped,
+      onBeforeStep: (name, state) => {
+        stepRef.current = name;
+        events.onBeforeStep?.(name, state);
+      },
+      // 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 } : {},
+      ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {},
+      ...parentRunId !== void 0 ? { parentRunId } : {},
+      ...telemetrySlots.length > 0 ? { telemetrySlots } : {},
+      ...debug !== void 0 ? { debugGate: debug.gate } : {}
+    };
+    let lastResult = null;
+    const execution = (async () => {
+      await Promise.resolve();
+      try {
+        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) => {
+            debug?.onLease(lease);
+            const r = await runWithSession(
+              capturedStore,
+              id,
+              sessionId,
+              runId,
+              agentInternals.loopDef,
+              initialState,
+              agentInternals.stateSchema,
+              ctx,
+              { ...options, ...lease }
+            );
+            if (capturedStore === void 0 && 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);
       }
-      const ctx = {
-        ...Object.fromEntries(agentInternals.resolvedProviders),
-        ...runtimeSlots,
-        agentId: id,
-        sessionId,
-        runId,
-        signal: ctxSignal,
-        ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {}
-      };
-      const events = extractRunEvents(resources);
-      const listeners = extractRunListeners(resources);
-      const observer = extractRunObserver(resources);
-      const onObserverError = extractRunErrorSink(resources);
-      const telemetrySlots = buildTelemetrySlots([
-        ...agentInternals.resolvedProviders.entries(),
-        ...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) => {
-          stepRef.current = name;
-          events.onBeforeStep?.(name, state);
-        },
-        // 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 } : {},
-        ...agentOptions?.instanceId !== void 0 ? { instanceId: agentOptions.instanceId } : {},
-        ...parentRunId !== void 0 ? { parentRunId } : {},
-        ...telemetrySlots.length > 0 ? { telemetrySlots } : {}
-      };
-      let lastResult = null;
-      const execution = (async () => {
-        await Promise.resolve();
-        try {
-          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,
+    })();
+    const buildResumeFn = () => {
+      return (response, interruptId) => {
+        if (inFlightSessions.has(sessionId)) throw new SessionInFlightError(sessionId);
+        interruptPendingSessions.delete(sessionId);
+        inFlightSessions.add(sessionId);
+        let _resumeStopped = false;
+        const resumeAbortController = new AbortController();
+        const resumeStopFlag = {
+          get stopped() {
+            return _resumeStopped;
+          },
+          set stopped(v) {
+            _resumeStopped = v;
+            if (v) resumeAbortController.abort();
+          }
+        };
+        const resumeStepRef = { current: null };
+        const resumeRunId = randomUUID();
+        const resumeExecution = (async () => {
+          await Promise.resolve();
+          try {
+            const resumeCtx = {
+              ...ctx,
+              runId: resumeRunId,
+              signal: resumeAbortController.signal
+            };
+            if (capturedStore !== void 0) {
+              const store = capturedStore;
+              const onStoreError = events.onStoreError;
+              return await runClaimed({
+                store,
+                agentId: 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);
-        }
-      })();
-      const buildResumeFn = () => {
-        return (response, interruptId) => {
-          if (inFlightSessions.has(sessionId)) throw new SessionInFlightError(sessionId);
-          interruptPendingSessions.delete(sessionId);
-          inFlightSessions.add(sessionId);
-          let _resumeStopped = false;
-          const resumeAbortController = new AbortController();
-          const resumeStopFlag = {
-            get stopped() {
-              return _resumeStopped;
-            },
-            set stopped(v) {
-              _resumeStopped = v;
-              if (v) resumeAbortController.abort();
-            }
-          };
-          const resumeStepRef = { current: null };
-          const resumeRunId = randomUUID();
-          const resumeExecution = (async () => {
-            await Promise.resolve();
-            try {
-              const resumeCtx = {
-                ...ctx,
-                runId: resumeRunId,
-                signal: resumeAbortController.signal
-              };
-              if (capturedStore !== void 0) {
-                const store = capturedStore;
-                const onStoreError = events.onStoreError;
-                return await runClaimed({
+                claimOptions,
+                ...onStoreError !== void 0 ? { onStoreError } : {},
+                failState: resumeFailState,
+                body: (lease) => injectThenRun({
                   store,
                   agentId: id,
                   sessionId,
-                  claimOptions,
+                  interruptId,
+                  response,
                   ...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();
-              const injected = injectInterruptResponseIntoState(prev.cursor ?? void 0, prev.state, interruptId, response);
-              if (!injected.found) throw new NoInterruptError();
-              const state = injected.state;
-              const cursor = injected.cursor;
-              const r = await runLoop(
-                agentInternals.loopDef,
-                state,
-                resumeCtx,
-                agentInternals.stateSchema,
-                () => resumeStopFlag.stopped,
-                cursor,
-                {
-                  runId: resumeRunId,
-                  resumedFrom: { runId: prev.runId, ...prev.carrier !== void 0 ? { carrier: prev.carrier } : {} },
-                  onBeforeStep: (n, s) => {
-                    resumeStepRef.current = n;
-                    events.onBeforeStep?.(n, s);
-                  },
-                  ...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 (r.signal === "$interrupt") interruptPendingSessions.add(sessionId);
-              lastResult = { state: r.state, cursor: r.cursor, runId: resumeRunId, ...r.carrier !== void 0 ? { carrier: r.carrier } : {} };
-              return { state: r.state, signal: r.signal };
-            } finally {
-              inFlightSessions.delete(sessionId);
+                  run: async () => {
+                    debug?.onLease(lease);
+                    const r2 = await runWithSession(
+                      store,
+                      id,
+                      sessionId,
+                      resumeRunId,
+                      agentInternals.loopDef,
+                      {},
+                      agentInternals.stateSchema,
+                      resumeCtx,
+                      {
+                        mode: "resume",
+                        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 } : {},
+                        ...debug !== void 0 ? { debugGate: debug.gate } : {},
+                        ...lease
+                      }
+                    );
+                    lastResult = { state: r2.state, cursor: r2.cursor, runId: resumeRunId, ...r2.carrier !== void 0 ? { carrier: r2.carrier } : {} };
+                    return { state: r2.state, signal: r2.signal };
+                  }
+                })
+              });
             }
-          })();
-          return createRunHandle(sessionId, resumeRunId, resumeExecution, resumeStopFlag, resumeStepRef, buildResumeFn());
-        };
+            const prev = lastResult;
+            if (prev === null) throw new NoInterruptError();
+            const injected = injectInterruptResponseIntoState(prev.cursor ?? void 0, prev.state, interruptId, response);
+            if (!injected.found) throw new NoInterruptError();
+            const state = injected.state;
+            const cursor = injected.cursor;
+            const r = await runLoop(
+              agentInternals.loopDef,
+              state,
+              resumeCtx,
+              agentInternals.stateSchema,
+              () => resumeStopFlag.stopped,
+              cursor,
+              {
+                runId: resumeRunId,
+                resumedFrom: { runId: prev.runId, ...prev.carrier !== void 0 ? { carrier: prev.carrier } : {} },
+                onBeforeStep: (n, s) => {
+                  resumeStepRef.current = n;
+                  events.onBeforeStep?.(n, s);
+                },
+                ...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 } : {},
+                ...debug !== void 0 ? { debugGate: debug.gate } : {}
+              }
+            );
+            if (r.signal === "$interrupt") interruptPendingSessions.add(sessionId);
+            lastResult = { state: r.state, cursor: r.cursor, runId: resumeRunId, ...r.carrier !== void 0 ? { carrier: r.carrier } : {} };
+            return { state: r.state, signal: r.signal };
+          } finally {
+            inFlightSessions.delete(sessionId);
+          }
+        })();
+        return createRunHandle(sessionId, resumeRunId, resumeExecution, resumeStopFlag, resumeStepRef, buildResumeFn());
       };
-      return createRunHandle(sessionId, runId, execution, stopFlag, stepRef, buildResumeFn());
-    },
+    };
+    return createRunHandle(sessionId, runId, execution, stopFlag, stepRef, buildResumeFn());
+  };
+  const agent = {
+    id,
+    run: (initialState, resources) => startRun(initialState, resources),
     resume: (response, sessionId, interruptId, resources) => {
+      if (debugSessions.has(sessionId)) throw new SessionInDebugError(sessionId);
       if (inFlightSessions.has(sessionId)) throw new SessionInFlightError(sessionId);
       interruptPendingSessions.delete(sessionId);
       inFlightSessions.add(sessionId);
       const events = extractRunEvents(resources ?? {});
-      const observer = extractRunObserver(resources ?? {});
-      const onObserverError = extractRunErrorSink(resources ?? {});
+      const { observer, onObserverError } = resolveObserver(resources ?? {});
       const telemetrySlots = buildTelemetrySlots(agentInternals.resolvedProviders.entries());
       const parentRunId = resources?.["parentRunId"];
       const claimOptions = parseClaimOptions(resources?.["claimOptions"], fallbackClaimOptions());
@@ -2138,18 +2829,41 @@ function createAgent(id, h, slots, agentOptions) {
         ...typeof parentRunId === "string" ? { parentRunId } : {}
       });
     },
+    debug: (initialState, resources) => {
+      const rawSignal = resources["signal"];
+      let sessionId;
+      const session = createDebugSession({
+        start: (hooks) => {
+          const handle = startRun(initialState, resources, hooks);
+          sessionId = handle.sessionId;
+          return handle;
+        },
+        store: capturedStore,
+        signal: rawSignal instanceof AbortSignal ? rawSignal : void 0,
+        onEnd: () => {
+          if (sessionId !== void 0) debugSessions.delete(sessionId);
+        }
+      });
+      debugSessions.add(session.sessionId);
+      return session;
+    },
     status: (sessionId) => querySessionPhase(capturedStore, id, sessionId),
     [_agentInternals]: agentInternals
   };
   return agent;
 }
 export {
+  DebugCommandError,
+  InvalidAgentOptionError,
+  InvalidClaimOptionsError,
+  InvalidRunResourceError,
   LeaseExpiredError,
   LoopNotDefinedError,
   NoInterruptError,
   REQUIRED_TAG,
   RUNTIME_TAG,
   SessionBusyError,
+  SessionInDebugError,
   SessionInFlightError,
   SessionPendingInterruptError,
   StoreLoadError,