@bastani/atomic 0.9.35-alpha.2 → 0.9.35-alpha.3

package/dist/builtin/workflows/src/extension/index.bundle.mjs

@@ -998,6 +998,7 @@ class InMemoryDurableBackend {
       inputs: handle.inputs,
       createdAt: handle.createdAt,
       status: handle.status,
+      transitionClaimId: handle.transitionClaimId ?? existing?.handle.transitionClaimId,
       ...handle.invocationCwd !== undefined ? { invocationCwd: handle.invocationCwd } : existing?.handle.invocationCwd !== undefined ? { invocationCwd: existing.handle.invocationCwd } : {},
       ...handle.origin !== undefined ? { origin: handle.origin } : existing?.handle.origin !== undefined ? { origin: existing.handle.origin } : {},
       modelOwner: authoritativeOwner ? handle.modelOwner : existing?.handle.modelOwner ?? handle.modelOwner,
@@ -1011,7 +1012,11 @@ class InMemoryDurableBackend {
       completedCheckpoints,
       pendingPrompts,
       updatedAt,
-      ...handle.label !== undefined ? { label: handle.label } : {},
+      ...(handle.label ?? existing?.handle.label) !== undefined ? { label: handle.label ?? existing?.handle.label } : {},
+      ...(handle.summary ?? existing?.handle.summary) !== undefined ? {
+        summary: handle.summary ?? existing?.handle.summary,
+        summarizedThrough: handle.summarizedThrough ?? existing?.handle.summarizedThrough
+      } : {},
       ...handle.rootWorkflowId !== undefined ? { rootWorkflowId: handle.rootWorkflowId } : {},
       ...handle.resumable !== undefined ? { resumable: handle.resumable } : {},
       ...workflowFailureFields(hasWorkflowFailureMetadata(handle) ? handle : handle.status === "running" ? undefined : existing?.handle),
@@ -1081,6 +1086,13 @@ class InMemoryDurableBackend {
       return this.stickyReceipts.get(workflowId)?.has(name) ?? false;
     });
   }
+  async persistSummary(workflowId, summary, summarizedThrough) {
+    const handle = this.getWorkflow(workflowId);
+    if (!handle || (handle.summarizedThrough ?? -Infinity) > summarizedThrough)
+      return false;
+    this.registerWorkflow({ ...handle, summary, summarizedThrough });
+    return true;
+  }
   async persistPendingStageMessages(workflowId, messages, logicalRunId = workflowId) {
     const handle = this.getWorkflow(workflowId);
     if (handle === undefined)
@@ -1207,6 +1219,7 @@ class InMemoryDurableBackend {
       failureDisposition: undefined,
       failedToolNodeId: undefined,
       status,
+      transitionClaimId: status === rec.handle.status ? rec.handle.transitionClaimId : crypto.randomUUID(),
       updatedAt: Math.max(Date.now(), rec.handle.updatedAt + 1),
       ...pendingPrompts !== undefined ? { pendingPrompts } : {},
       ...resumable !== undefined ? { resumable } : {},
@@ -1295,6 +1308,7 @@ class InMemoryDurableBackend {
       name: h.name,
       inputs: h.inputs,
       status: h.status,
+      ...h.transitionClaimId !== undefined ? { transitionClaimId: h.transitionClaimId } : {},
       createdAt: h.createdAt,
       completedCheckpoints: h.completedCheckpoints,
       pendingPrompts: h.pendingPrompts,
@@ -1304,6 +1318,7 @@ class InMemoryDurableBackend {
       ...h.legacyRecoveryPending === true ? { legacyRecoveryPending: true } : {},
       ...h.sessionFile !== undefined ? { sessionFile: h.sessionFile } : {},
       ...h.label !== undefined ? { label: h.label } : {},
+      ...h.summary !== undefined ? { summary: h.summary, summarizedThrough: h.summarizedThrough } : {},
       ...h.rootWorkflowId !== undefined ? { rootWorkflowId: h.rootWorkflowId } : {},
       ...h.resumable !== undefined ? { resumable: h.resumable } : {},
       ...workflowFailureFields(h),
@@ -1385,6 +1400,7 @@ function toResumableEntry(handle) {
     pendingPrompts: handle.pendingPrompts,
     ...handle.sessionFile !== undefined ? { sessionFile: handle.sessionFile } : {},
     ...handle.label !== undefined ? { label: handle.label } : {},
+    ...handle.summary !== undefined ? { summary: handle.summary, summarizedThrough: handle.summarizedThrough } : {},
     ...handle.rootWorkflowId !== undefined ? { rootWorkflowId: handle.rootWorkflowId } : {},
     ...handle.resumable !== undefined ? { resumable: handle.resumable } : {},
     ...workflowFailureFields(handle),
@@ -4340,6 +4356,8 @@ function encodeMetadata(metadata) {
       ...metadata.legacyRecoveryPending === true ? { legacyRecoveryPending: true } : {},
       ...metadata.sessionFile !== undefined ? { sessionFile: metadata.sessionFile } : {},
       ...metadata.label !== undefined ? { label: metadata.label } : {},
+      ...metadata.summary !== undefined ? { summary: metadata.summary } : {},
+      ...metadata.summarizedThrough !== undefined ? { summarizedThrough: metadata.summarizedThrough } : {},
       ...metadata.rootWorkflowId !== undefined ? { rootWorkflowId: metadata.rootWorkflowId } : {},
       ...metadata.resumable !== undefined ? { resumable: metadata.resumable } : {},
       ...metadata.exited !== undefined ? { exited: metadata.exited } : {},
@@ -4401,7 +4419,7 @@ function parseDurableWorkflowMetadata(value2, workflowId) {
     return;
   const possibleStages = coercePossibleStages(serialized.possibleStages);
   const metadata = value2;
-  if (metadata.workflowId !== workflowId || typeof metadata.workflowId !== "string" || typeof metadata.name !== "string" || typeof metadata.inputs !== "object" || metadata.inputs === null || Array.isArray(metadata.inputs) || typeof metadata.status !== "string" || !isDurableWorkflowStatus(metadata.status) || typeof metadata.completedCheckpoints !== "number" || typeof metadata.createdAt !== "number" || typeof metadata.pendingPrompts !== "number" || typeof metadata.promptReservationEpoch !== "string" || typeof metadata.updatedAt !== "number" || metadata.ownerExecutorId !== undefined && typeof metadata.ownerExecutorId !== "string" || metadata.transitionClaimId !== undefined && typeof metadata.transitionClaimId !== "string" || metadata.legacyRecoveryPending !== undefined && metadata.legacyRecoveryPending !== true || metadata.sessionFile !== undefined && typeof metadata.sessionFile !== "string" || metadata.label !== undefined && typeof metadata.label !== "string" || metadata.rootWorkflowId !== undefined && typeof metadata.rootWorkflowId !== "string" || metadata.resumable !== undefined && typeof metadata.resumable !== "boolean" || metadata.exited !== undefined && typeof metadata.exited !== "boolean" || metadata.exitReason !== undefined && typeof metadata.exitReason !== "string" || metadata.error !== undefined && typeof metadata.error !== "string" || metadata.failureKind !== undefined && !isWorkflowFailureKind(metadata.failureKind) || metadata.failureCode !== undefined && !isWorkflowFailureCode(metadata.failureCode) || metadata.failureRecoverability !== undefined && !isWorkflowFailureRecoverability(metadata.failureRecoverability) || metadata.failureDisposition !== undefined && !isWorkflowFailureDisposition(metadata.failureDisposition) || metadata.failedToolNodeId !== undefined && typeof metadata.failedToolNodeId !== "string" || metadata.releasedModelOwner !== undefined && typeof metadata.releasedModelOwner !== "string" || metadata.invocationCwd !== undefined && typeof metadata.invocationCwd !== "string" || metadata.workflowCwd !== undefined && typeof metadata.workflowCwd !== "string" || metadata.repositoryRoot !== undefined && typeof metadata.repositoryRoot !== "string" || metadata.gitWorktreeRoot !== undefined && typeof metadata.gitWorktreeRoot !== "string")
+  if (metadata.workflowId !== workflowId || typeof metadata.workflowId !== "string" || typeof metadata.name !== "string" || typeof metadata.inputs !== "object" || metadata.inputs === null || Array.isArray(metadata.inputs) || typeof metadata.status !== "string" || !isDurableWorkflowStatus(metadata.status) || typeof metadata.completedCheckpoints !== "number" || typeof metadata.createdAt !== "number" || typeof metadata.pendingPrompts !== "number" || typeof metadata.promptReservationEpoch !== "string" || typeof metadata.updatedAt !== "number" || metadata.ownerExecutorId !== undefined && typeof metadata.ownerExecutorId !== "string" || metadata.transitionClaimId !== undefined && typeof metadata.transitionClaimId !== "string" || metadata.legacyRecoveryPending !== undefined && metadata.legacyRecoveryPending !== true || metadata.sessionFile !== undefined && typeof metadata.sessionFile !== "string" || metadata.label !== undefined && typeof metadata.label !== "string" || metadata.summary !== undefined && typeof metadata.summary !== "string" || metadata.summarizedThrough !== undefined && (typeof metadata.summarizedThrough !== "number" || !Number.isFinite(metadata.summarizedThrough)) || metadata.rootWorkflowId !== undefined && typeof metadata.rootWorkflowId !== "string" || metadata.resumable !== undefined && typeof metadata.resumable !== "boolean" || metadata.exited !== undefined && typeof metadata.exited !== "boolean" || metadata.exitReason !== undefined && typeof metadata.exitReason !== "string" || metadata.error !== undefined && typeof metadata.error !== "string" || metadata.failureKind !== undefined && !isWorkflowFailureKind(metadata.failureKind) || metadata.failureCode !== undefined && !isWorkflowFailureCode(metadata.failureCode) || metadata.failureRecoverability !== undefined && !isWorkflowFailureRecoverability(metadata.failureRecoverability) || metadata.failureDisposition !== undefined && !isWorkflowFailureDisposition(metadata.failureDisposition) || metadata.failedToolNodeId !== undefined && typeof metadata.failedToolNodeId !== "string" || metadata.releasedModelOwner !== undefined && typeof metadata.releasedModelOwner !== "string" || metadata.invocationCwd !== undefined && typeof metadata.invocationCwd !== "string" || metadata.workflowCwd !== undefined && typeof metadata.workflowCwd !== "string" || metadata.repositoryRoot !== undefined && typeof metadata.repositoryRoot !== "string" || metadata.gitWorktreeRoot !== undefined && typeof metadata.gitWorktreeRoot !== "string")
     return;
   const { origin, possibleStages: rawPossibleStages, ...metadataWithoutOrigin } = metadata;
   return {
@@ -36484,9 +36502,9 @@ async function configureDbosDurableBackend(config) {
         backend = new DbosDurableBackend(createRealDbosHandle(sdk, mainWorkflow, checkpointWorkflow, backendFence), { checkReady });
       }
     },
-    shutdown: async () => {
+    shutdown: async (options) => {
       const results = await Promise.allSettled([
-        sdk.shutdown(),
+        sdk.shutdown(options),
         ...[...owner.executorFences ?? []].map((fence) => fence.close())
       ]);
       const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason instanceof Error ? result.reason : new Error(String(result.reason)));
@@ -36783,6 +36801,36 @@ class DbosDurableBackend {
     }
     return false;
   }
+  async persistSummary(workflowId, summary, summarizedThrough) {
+    let persisted = false;
+    await this.enqueueBestEffortWrite(workflowId, async () => {
+      const handle = this.mem.getWorkflow(workflowId);
+      const value2 = this.mem.toMetadata(workflowId);
+      if (!handle || !value2 || !this.isWorkflowLoadable(workflowId))
+        return;
+      if ((handle.summarizedThrough ?? -Infinity) > summarizedThrough)
+        return;
+      const updatedAt = Math.max(Date.now(), handle.updatedAt + 1);
+      const metadata = {
+        ...this.promptReservations.metadata(workflowId, value2),
+        summary,
+        summarizedThrough,
+        updatedAt
+      };
+      await this.sdk.recordStepOutput(workflowId, metadataStepName(updatedAt), encodeMetadata(metadata));
+      const current = this.mem.getWorkflow(workflowId);
+      if (current) {
+        this.mem.registerWorkflow({
+          ...current,
+          summary,
+          summarizedThrough,
+          updatedAt: Math.max(updatedAt, current.updatedAt)
+        });
+      }
+      persisted = true;
+    });
+    return persisted;
+  }
   async persistPendingStageMessages(workflowId, messages, logicalRunId = workflowId) {
     let persisted = false;
     await this.enqueueWrite(workflowId, async () => {
@@ -40578,7 +40626,7 @@ async function shutdownDbos() {
     const errors = [];
     const actions = [
       ...wasReady ? [() => durability.backend.flush()] : [],
-      ...slot.launchPromise !== undefined ? [() => durability.shutdown()] : [],
+      ...slot.launchPromise !== undefined ? [() => durability.shutdown({ deregister: true })] : [],
       shutdownLocalDbos
     ];
     for (const shutdown of actions) {
@@ -40594,6 +40642,7 @@ async function shutdownDbos() {
       slot.state = "shut_down";
       slot.configured = undefined;
       slot.active = undefined;
+      slot.wrappers = undefined;
     }
   })().catch(async (error) => {
     slot.failure = await durabilityFailure("shutdown", error);
@@ -86933,6 +86982,13 @@ function createRunStoreMethods(context) {
         state.runs[index] = run;
       context.bumpAndNotify();
     },
+    recordRunSummary(runId, summary, summarizedThrough) {
+      const run = context.findRun(runId);
+      if (!run)
+        return;
+      Object.assign(run, { summary, summarizedThrough });
+      context.bumpAndNotify();
+    },
     recordRunExecutionState(runId, update) {
       const run = context.findRun(runId);
       if (run === undefined || run.endedAt !== undefined)
@@ -91838,8 +91894,8 @@ function canonicalDirectory(path) {
     return process.platform === "win32" ? absolute.toLowerCase() : absolute;
   }
 }
-function isSdkDurableRunInScope(handle, cwd) {
-  return cwd !== undefined && handle.invocationCwd !== undefined && canonicalDirectory(cwd) === canonicalDirectory(handle.invocationCwd) && handle.modelOwner !== undefined && (handle.rootWorkflowId === undefined || handle.rootWorkflowId === handle.workflowId);
+function isSdkDurableRunInScope(handle, cwd, canonicalize = canonicalDirectory) {
+  return cwd !== undefined && handle.invocationCwd !== undefined && handle.modelOwner !== undefined && (handle.rootWorkflowId === undefined || handle.rootWorkflowId === handle.workflowId) && canonicalize(cwd) === canonicalize(handle.invocationCwd);
 }
 function isSdkCrashedRunAdoptable(handle, cwd) {
   return isSdkDurableRunInScope(handle, cwd) && handle.status === "running" && handle.ownerExecutorId !== undefined && handle.ownerExecutorId !== getAtomicExecutorId() && !isLiveRunningWorkflow(handle) && isDatabaseExecutor(handle.ownerExecutorId) && handle.ownerLiveness === "dead";
@@ -94202,6 +94258,12 @@ function stickyStageDeliveryStatuses(runs, rootRunId) {
   return result;
 }
 
+// dist/builtin/workflows/src/shared/workflow-identity.ts
+function workflowIdentity(id, label, inputs) {
+  const text = label?.trim() || [inputs?.objective, inputs?.prompt, inputs?.task, inputs?.request, ...Object.values(inputs ?? {})].find((value2) => typeof value2 === "string" && value2.trim().length > 0) || id;
+  return text.replace(/\s+/g, " ").trim();
+}
+
 // dist/builtin/workflows/src/runs/background/run-inspect.ts
 function inspectRun(runId, opts) {
   const activeStore = opts?.store ?? store;
@@ -94220,6 +94282,10 @@ function inspectRun(runId, opts) {
     runId: copy.id,
     ...copy.rootRunId === undefined ? {} : { rootRunId: copy.rootRunId },
     name: copy.name,
+    label: copy.label,
+    identity: workflowIdentity(copy.id, copy.label, copy.inputs),
+    summary: copy.summary,
+    summarizedThrough: copy.summarizedThrough,
     status: effectiveRunStatus(copy),
     mode: expandedStages.length > 1 ? "chain" : "single",
     startedAt: copy.startedAt,
@@ -109228,6 +109294,132 @@ init_dbos_admission();
 init_dbos_sdk_handle();
 init_factory();
 
+// dist/builtin/workflows/src/durable/fork-workflow.ts
+import { randomUUID as randomUUID8 } from "node:crypto";
+import { SessionManager as SessionManager3 } from "@bastani/atomic";
+async function forkDurableWorkflow(backend, source, cwd, modelOwner) {
+  source = structuredClone(source);
+  const workflowId = randomUUID8();
+  const ids = new Map([[source.workflowId, workflowId]]);
+  const mapId = (id) => {
+    let mapped = ids.get(id);
+    if (mapped === undefined) {
+      mapped = randomUUID8();
+      ids.set(id, mapped);
+    }
+    return mapped;
+  };
+  const mapTarget = (target) => {
+    const parsed = parseWorkflowStageTarget(target);
+    if (parsed === undefined || parsed.rootRunId !== source.workflowId)
+      return target;
+    return formatWorkflowStageTarget(workflowId, ...parsed.segments.map((segment) => ids.get(segment) ?? segment));
+  };
+  const mapRun = (run) => ({
+    ...run,
+    runId: mapId(run.runId),
+    ...run.parentRunId === undefined ? {} : { parentRunId: mapId(run.parentRunId) },
+    ...run.rootRunId === undefined ? {} : { rootRunId: workflowId }
+  });
+  const sessions = new Map;
+  const checkpoints = [];
+  for (const checkpoint of backend.listCheckpoints(source.workflowId)) {
+    const copy = structuredClone(checkpoint);
+    if (copy.kind === "ui") {
+      checkpoints.push({ ...copy, workflowId });
+      continue;
+    }
+    const topology = copy.topology;
+    if (copy.kind === "tool") {
+      checkpoints.push({
+        ...copy,
+        workflowId,
+        ...topology === undefined ? {} : {
+          topology: {
+            ...copy.topology,
+            ...copy.topology?.run === undefined ? {} : { run: mapRun(copy.topology.run) }
+          }
+        }
+      });
+      continue;
+    }
+    const stageTopology = copy.topology;
+    const boundary = stageTopology?.boundary;
+    const taskOutput = isToolPayloadObject(copy.output) && typeof copy.output.text === "string" ? copy.output : undefined;
+    const sessionFile = copy.sessionFile ?? (typeof taskOutput?.sessionFile === "string" ? taskOutput.sessionFile : undefined);
+    let session = sessionFile === undefined ? undefined : sessions.get(sessionFile);
+    if (session === undefined && sessionFile !== undefined) {
+      session = await SessionManager3.forkFromAsync(sessionFile, cwd, undefined, {
+        internal: true,
+        workflow: { runId: workflowId, stageId: stageTopology?.stageId ?? copy.checkpointId, stageName: copy.name }
+      });
+      sessions.set(sessionFile, session);
+    }
+    const childOutput = boundary === undefined ? undefined : parseWorkflowChildResult(copy.output);
+    checkpoints.push({
+      ...copy,
+      workflowId,
+      ...childOutput === undefined ? {} : { output: { ...childOutput, runId: mapId(childOutput.runId) } },
+      ...taskOutput === undefined ? {} : {
+        output: { ...taskOutput, sessionId: session?.getSessionId(), sessionFile: session?.getSessionFile() }
+      },
+      sessionId: session?.getSessionId(),
+      sessionFile: session?.getSessionFile(),
+      ...stageTopology === undefined ? {} : {
+        topology: {
+          ...stageTopology,
+          intercomGroup: undefined,
+          ...stageTopology.run === undefined ? {} : { run: mapRun(stageTopology.run) },
+          ...boundary === undefined ? {} : {
+            boundary: {
+              ...boundary,
+              child: {
+                ...boundary.child,
+                runId: mapId(boundary.child.runId),
+                parentRunId: mapId(boundary.child.parentRunId),
+                rootRunId: workflowId
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+  const fork = {
+    ...source,
+    workflowId,
+    rootWorkflowId: undefined,
+    invocationCwd: cwd,
+    workflowCwd: undefined,
+    repositoryRoot: undefined,
+    gitWorktreeRoot: undefined,
+    sessionFile: undefined,
+    modelOwner,
+    releasedModelOwner: undefined,
+    ownerExecutorId: undefined,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    completedCheckpoints: 0,
+    pendingStageMessages: source.pendingStageMessages?.map((message) => ({
+      ...message,
+      runId: mapId(message.runId),
+      stageKey: mapTarget(message.stageKey),
+      ...message.targetPath === undefined ? {} : { targetPath: mapTarget(message.targetPath) }
+    }))
+  };
+  backend.registerWorkflow({ ...fork, status: "running", resumable: false });
+  await backend.flush(workflowId);
+  for (const checkpoint of checkpoints)
+    await backend.recordCheckpointAsync(checkpoint);
+  await backend.flush(workflowId);
+  backend.registerWorkflow({
+    ...fork,
+    resumable: source.resumable ?? true,
+    completedCheckpoints: backend.getWorkflow(workflowId).completedCheckpoints
+  });
+  await backend.flush(workflowId);
+  return workflowId;
+}
 // dist/builtin/workflows/src/durable/tool-resume-frontier.ts
 function resolveToolResumeFrontier(source, backend) {
   const fail = (detail) => ({
@@ -109309,6 +109501,9 @@ function resolveDurableEntry(workflowId, catalog) {
     return resolution;
   return catalog.find((entry) => entry.workflowId === resolution.runId);
 }
+function crossProjectResumeMessage(workflowId, cwd) {
+  return `Workflow run found in different project: ${cwd}. Run /workflow resume ${workflowId} in an interactive session to fork it into the current directory, or open the original project to resume it.`;
+}
 var pendingResumes = new WeakMap;
 var unsettledResumeClaims = new WeakMap;
 async function resumeDurableWorkflow(workflowId, deps, catalog) {
@@ -109348,11 +109543,15 @@ async function resumeDurableWorkflowClaimed(workflowId, deps, catalog) {
   } else {
     workflowId = target.runId;
   }
+  const initial = backend.getWorkflow(workflowId);
+  const currentCwd = deps.baseRunOpts.cwd;
+  const crossProject = initial?.invocationCwd !== undefined && currentCwd !== undefined && canonicalDirectory(initial.invocationCwd) !== canonicalDirectory(currentCwd);
   const recovering = backend.isAdmissionUnavailable?.(workflowId) || backend.isCheckpointUnavailable?.(workflowId);
   if (recovering && hasActiveLiveRun(deps.baseRunOpts.store, workflowId)) {
     return alreadyRunningResult(backend.getWorkflow(workflowId)?.name ?? workflowId, workflowId, deps.baseRunOpts.store);
   }
-  await backend.reconcileWorkflowAdmission?.(workflowId, deps.signal);
+  if (!crossProject)
+    await backend.reconcileWorkflowAdmission?.(workflowId, deps.signal);
   const resolvedCatalog = recovering ? backend.listResumableWorkflows() : catalog ?? backend.listResumableWorkflows();
   const resolved = resolveDurableEntry(workflowId, resolvedCatalog);
   if (resolved === undefined) {
@@ -109416,7 +109615,21 @@ async function resumeDurableWorkflowClaimed(workflowId, deps, catalog) {
   if (adopting && !isSdkRunAdoptable(handle, deps.baseRunOpts.cwd)) {
     return { ok: false, reason: "owned_elsewhere", message: foreignInstanceMessage(backend, resolved.workflowId) };
   }
-  const def = handle.invocationCwd === undefined ? deps.registry.get(handle.name) : await deps.resolveDefinition?.(handle.name, handle.invocationCwd) ?? deps.registry.get(handle.name);
+  if (crossProject) {
+    if (deps.confirmCrossProjectFork === undefined)
+      return {
+        ok: false,
+        reason: "different_project",
+        message: crossProjectResumeMessage(workflowId, initial.invocationCwd)
+      };
+    if (!await deps.confirmCrossProjectFork(initial.invocationCwd))
+      return {
+        ok: false,
+        reason: "different_project",
+        message: "Workflow resume cancelled; the source run was not changed."
+      };
+  }
+  const def = crossProject ? deps.registry.get(handle.name) ?? await deps.resolveDefinition?.(handle.name, handle.invocationCwd) : handle.invocationCwd === undefined ? deps.registry.get(handle.name) : await deps.resolveDefinition?.(handle.name, handle.invocationCwd) ?? deps.registry.get(handle.name);
   if (def === undefined) {
     return { ok: false, reason: "workflow_not_found", message: `Workflow definition not found: ${handle.name}` };
   }
@@ -109437,6 +109650,18 @@ async function resumeDurableWorkflowClaimed(workflowId, deps, catalog) {
       message: `invalid_inputs: ${err instanceof Error ? err.message : String(err)}`
     };
   }
+  if (crossProject) {
+    deps.signal?.throwIfAborted();
+    const forkId = await forkDurableWorkflow(backend, handle, currentCwd, deps.forkModelOwner ?? requestedOwner);
+    const fork = backend.getWorkflow(forkId);
+    const result = await resumeDurableWorkflow(forkId, {
+      ...deps,
+      confirmCrossProjectFork: undefined,
+      resolveDefinition: async () => def,
+      onBeforeResume: deps.onBeforeResume === undefined ? undefined : (runId) => deps.onBeforeResume(runId, handle.workflowId)
+    }, [resumableEntryFromHandle(fork)]);
+    return result.ok ? { ...result, message: `Forked workflow ${workflowId} into the current directory. ${result.message}` } : result;
+  }
   let toolContinuation = deps.baseRunOpts.continuation;
   if (handle.status === "failed" && (handle.failedToolNodeId !== undefined || /^atomic-workflows: ctx\.tool .* aborted by node abort$/s.test(handle.error ?? ""))) {
     const source = durableWorkflowRunSnapshots(backend, handle).find((run) => run.id === handle.workflowId);
@@ -109481,6 +109706,7 @@ async function resumeDurableWorkflowClaimed(workflowId, deps, catalog) {
     onRestored?.();
     return true;
   };
+  await deps.onBeforeResume?.(resolved.workflowId);
   let claimed;
   try {
     claimed = await boundedAdmission((signal) => dbosAdmissionContext.run(signal, async () => {
@@ -109732,6 +109958,9 @@ function rootSnapshot(backend, handle, graph) {
   const terminalDurationMs = priorDurationMs ?? Math.max(0, handle.updatedAt - handle.createdAt);
   return {
     id: handle.workflowId,
+    label: handle.label,
+    summary: handle.summary,
+    summarizedThrough: handle.summarizedThrough,
     name: handle.name,
     inputs: { ...handle.inputs },
     status: handle.status,
@@ -110407,43 +110636,45 @@ function workflowStatusPresentation(status, kind) {
     return { label: "crashed", color: "error" };
   return { label: status };
 }
-function liveRunSession(run) {
+function liveRunSession(run, saved) {
   const completed = completedStageCount(run);
   const total = run.stages.length;
   const modified = new Date(latestRunTimestamp(run));
   const presentation = workflowStatusPresentation(run.status, "live");
   const stageText = `${completed}/${total} stages`;
+  const identity = workflowIdentity(run.id, run.label ?? saved?.label, run.inputs);
+  const summary = run.summary ?? saved?.summary;
   return {
     result: { kind: "live", runId: run.id },
     session: {
       path: `workflow-live:${run.id}`,
       id: run.id,
-      cwd: "Live workflow runs",
+      cwd: "Live",
       created: new Date(run.startedAt),
       modified,
       messageCount: total,
-      firstMessage: run.id,
-      summary: `${presentation.label}  ${stageText}  ${run.name}`,
-      allMessagesText: `${run.id} ${run.name} ${presentation.label} ${stageText}`,
+      firstMessage: summary ? `${presentation.label} ${completed}/${total} ${run.name}  ${identity}` : identity,
+      summary: summary || `${presentation.label}  ${stageText}  ${run.name}`,
+      allMessagesText: `${run.id} ${identity} ${summary ?? ""} ${run.name} ${presentation.label} ${stageText}`,
       ...presentation.color !== undefined ? { messageColor: presentation.color } : {}
     }
   };
 }
 function durableWorkflowSession(entry, kind) {
-  const checkpointText = `${entry.completedCheckpoints} checkpoints`;
   const presentation = workflowStatusPresentation(entry.status, kind);
+  const identity = workflowIdentity(entry.workflowId, entry.label, entry.inputs);
   return {
     result: { kind, workflowId: entry.workflowId },
     session: {
       path: `workflow-${kind}:${entry.workflowId}`,
       id: entry.workflowId,
-      cwd: kind === "completed" ? "Completed workflow runs" : "Durable workflow runs",
+      cwd: kind === "completed" ? "Completed" : "Durable",
       created: new Date(entry.createdAt),
       modified: new Date(entry.updatedAt),
       messageCount: entry.completedCheckpoints,
-      firstMessage: entry.workflowId,
-      summary: `${presentation.label}  ${checkpointText}  ${entry.name}`,
-      allMessagesText: `${entry.workflowId} ${entry.name} ${presentation.label} ${checkpointText}`,
+      firstMessage: entry.summary ? `${presentation.label} ${entry.name}  ${identity}` : identity,
+      summary: entry.summary || `${presentation.label}  ${entry.name}`,
+      allMessagesText: `${entry.workflowId} ${identity} ${entry.summary ?? ""} ${entry.name} ${presentation.label}`,
       ...presentation.color !== undefined ? { messageColor: presentation.color } : {}
     }
   };
@@ -110462,8 +110693,11 @@ function workflowResumeSelectorItems(liveRuns, durableEntries, completedEntries
   const suppressedLiveIds = new Set(classifiedLiveRuns.filter(({ run, resumable }) => resumable || !(run.status === "running" && run.endedAt === undefined)).map(({ run }) => run.id));
   const visibleDurableEntries = durableEntries.filter((entry) => !suppressedLiveIds.has(entry.workflowId));
   const durableIds = new Set(visibleDurableEntries.map((entry) => entry.workflowId));
+  const savedEntries = new Map(completedEntries.map((entry) => [entry.workflowId, entry]));
+  for (const entry of durableEntries)
+    savedEntries.set(entry.workflowId, entry);
   return [
-    ...eligibleLiveRuns.map(liveRunSession),
+    ...eligibleLiveRuns.map((run) => liveRunSession(run, savedEntries.get(run.id))),
     ...visibleDurableEntries.map((entry) => durableWorkflowSession(entry, "durable")),
     ...completedEntries.filter((entry) => !visibleLiveIds.has(entry.workflowId) && !durableIds.has(entry.workflowId)).map((entry) => durableWorkflowSession(entry, "completed"))
   ].sort(compareResumeItemsByRecency);
@@ -110670,6 +110904,45 @@ function workflowPolicyFromContext(ctx) {
   return ctx?.hasUI === false ? HEADLESS_WORKFLOW_POLICY : INTERACTIVE_WORKFLOW_POLICY;
 }
 
+// dist/builtin/workflows/src/extension/workflow-resume-summary.ts
+init_factory();
+var delivered = new WeakMap;
+async function injectWorkflowResumeSummary(pi, ctx, runId, run, forkedFrom) {
+  if (ctx.isSessionSummaryEnabled?.() === false || pi.sendMessage === undefined)
+    return;
+  const owner = ("sessionManager" in ctx && typeof ctx.sessionManager === "object" ? ctx.sessionManager : undefined) ?? ctx;
+  const manager = "sessionManager" in ctx ? ctx.sessionManager : undefined;
+  const sessionId = manager && typeof manager.getSessionId === "function" ? manager.getSessionId() : "";
+  const key = `${sessionId}:${runId}`;
+  const seen = delivered.get(owner) ?? new Map;
+  let handle;
+  try {
+    handle = getAvailableDurableBackend()?.getLoadableWorkflow(runId);
+  } catch {}
+  const boundary = run?.pausedAt ?? (handle?.status !== "running" ? handle?.transitionClaimId : undefined);
+  if (seen.has(key) && (boundary === undefined || seen.get(key) === boundary))
+    return;
+  const summary = handle?.summary ?? run?.summary;
+  if (!summary)
+    return;
+  const through = handle?.summarizedThrough ?? run?.summarizedThrough;
+  const content = [
+    `Workflow resume context: ${runId}${forkedFrom === undefined ? "" : ` (forked from ${forkedFrom})`}`,
+    `Workflow: ${handle?.name ?? run?.name ?? runId}`,
+    `Status: ${handle?.status ?? run?.status ?? "unknown"}`,
+    `Summarized through: ${through === undefined ? "unknown" : new Date(through).toISOString()}`,
+    summary
+  ].join(`
+`);
+  seen.set(key, boundary);
+  delivered.set(owner, seen);
+  try {
+    await pi.sendMessage({ customType: "workflow-resume-summary", content, display: true }, { triggerTurn: false, deliverAs: "steer", persistWhenStreaming: true });
+  } catch {
+    seen.delete(key);
+  }
+}
+
 // dist/builtin/workflows/src/extension/workflow-durable-resume-command.ts
 function stageScopedDurableResumeMessage(workflowId) {
   return `Stage-scoped resume is not supported for durable workflow ${workflowId}. Omit the stage selector to resume the whole run.`;
@@ -110726,6 +110999,8 @@ async function handleDurableResume(target, ctx, reporter, deps, preparedCatalog)
     const result = await runtime.resumeDurableWorkflow(target, {
       policy,
       actor: "user",
+      ...crossProjectConfirmation(ctx),
+      onBeforeResume: (runId, forkedFrom) => injectWorkflowResumeSummary(deps.pi, ctx, runId, undefined, forkedFrom),
       ...releasedRunAdoption("workflowId" in resolved ? resolved.workflowId : target, ctx)
     });
     if (result.ok) {
@@ -110806,10 +111081,19 @@ function releasedRunAdoption(workflowId, ctx) {
   const handle = getDurableBackend().getLoadableWorkflow(workflowId);
   return handle !== undefined && isSdkReleasedRunAdoptable(handle, ctx.cwd) ? { modelOwner: workflowCaller(ctx) } : {};
 }
+function crossProjectConfirmation(ctx) {
+  const confirm = ctx.ui.confirm;
+  return workflowPolicyFromContext(ctx).allowInputPicker && confirm !== undefined ? {
+    forkModelOwner: workflowCaller(ctx),
+    confirmCrossProjectFork: (cwd) => confirm("Resume workflow", `Workflow run found in different project: ${cwd}. Fork it into the current directory?`)
+  } : {};
+}
 async function resumeDurableTarget(workflowId, ctx, reporter, deps, runtime) {
   const result = await runtime.resumeDurableWorkflow(workflowId, {
     policy: workflowPolicyFromContext(ctx),
     actor: "user",
+    ...crossProjectConfirmation(ctx),
+    onBeforeResume: (runId, forkedFrom) => injectWorkflowResumeSummary(deps.pi, ctx, runId, undefined, forkedFrom),
     ...releasedRunAdoption(workflowId, ctx)
   });
   if (!result.ok)
@@ -111832,12 +112116,12 @@ async function warm_first_fan_out(ctx, steps, prefixKeyOf, options = {}) {
 }
 
 // dist/builtin/workflows/builtin/pattern-artifact-root.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { mkdir as mkdir4 } from "node:fs/promises";
 import { join as join16 } from "node:path";
 async function stableArtifactRoot(ctx, workflowName) {
   const cwd = ctx.cwd ?? process.cwd();
-  const artifactDir = await ctx.tool("artifact-root", { workflow: workflowName }, async () => join16(cwd, ".atomic", "workflows", "runs", `${workflowName}-${randomUUID8()}`));
+  const artifactDir = await ctx.tool("artifact-root", { workflow: workflowName }, async () => join16(cwd, ".atomic", "workflows", "runs", `${workflowName}-${randomUUID9()}`));
   await mkdir4(artifactDir, { recursive: true });
   return artifactDir;
 }
@@ -113096,7 +113380,7 @@ async function writeReviewRoundArtifact(artifactDir, reviews, consolidatedFindin
 }
 
 // dist/builtin/workflows/builtin/goal-ledger.ts
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import { readFile as readFile4, rename as rename2, rm as rm3, writeFile as writeFile8 } from "node:fs/promises";
 import { dirname as dirname12, join as join22 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual4 } from "node:util";
@@ -113426,7 +113710,7 @@ async function createGoalLedger(objective, acceptanceCriteria, artifactDir) {
       await writeGoalLedger(ledgerPath, existing);
     return { ledger: existing, ledgerPath, artifactDir };
   }
-  const goalId = randomUUID9();
+  const goalId = randomUUID10();
   const now = new Date().toISOString();
   const ledger = {
     goal_id: goalId,
@@ -113455,7 +113739,7 @@ async function writeGoalLedger(ledgerPath, ledger) {
   const stateContents = `${JSON.stringify(ledger, null, 2)}
 `;
   const statePath = goalLedgerStatePath(ledgerPath);
-  const pendingStatePath = `${statePath}.${randomUUID9()}.tmp`;
+  const pendingStatePath = `${statePath}.${randomUUID10()}.tmp`;
   await writeFile8(pendingStatePath, stateContents, { encoding: "utf8" });
   try {
     await rename2(pendingStatePath, statePath);
@@ -117211,7 +117495,7 @@ __export(exports_sdk_surface, {
 import {
   isStaleExtensionContextError as isStaleExtensionContextError5,
   resolveRestoredModelReference,
-  SessionManager as SessionManager3
+  SessionManager as SessionManager4
 } from "@bastani/atomic";
 
 // dist/builtin/workflows/src/extension/atomic-stage-session.ts
@@ -117810,7 +118094,7 @@ function createAgentSessionAdapter(baseOptions = {}) {
         if (value2 !== undefined)
           Object.assign(options, { [key]: value2 });
       }
-      options.sessionManager ??= SessionManager3.inMemory(options.cwd ?? process.cwd());
+      options.sessionManager ??= SessionManager4.inMemory(options.cwd ?? process.cwd());
       return options;
     }
   }, { createAgentSession: (options, prepareOptions) => createPiSdkAgentSession(options, prepareOptions) });
@@ -118313,6 +118597,119 @@ function discoverBundledManifest() {
   return { registry, sources, errors: diagnostics };
 }
 
+// dist/builtin/workflows/src/extension/workflow-summary.ts
+init_factory();
+var services = new WeakMap;
+function ensureWorkflowSummaryService(store, context) {
+  const existing = services.get(store);
+  if (existing) {
+    existing.context = context;
+    return;
+  }
+  const entry = {
+    context,
+    service: createWorkflowSummaryService({
+      store,
+      resolveContext: () => services.get(store)?.context ?? context,
+      persist: async (runId, summary, summarizedThrough) => {
+        await getAvailableDurableBackend()?.persistSummary?.(runId, summary, summarizedThrough);
+        store.recordRunSummary?.(runId, summary, summarizedThrough);
+      }
+    })
+  };
+  services.set(store, entry);
+}
+function disposeWorkflowSummaryService(store) {
+  services.get(store)?.service.dispose();
+  services.delete(store);
+}
+function requestWorkflowSummary(store, runId) {
+  services.get(store)?.service.request(runId);
+}
+function createWorkflowSummaryService(options) {
+  const contexts = new Map;
+  const pending = new Map;
+  const finalized = new Map;
+  let disposed = false;
+  const request = (runId) => {
+    const run = options.store.runs().find((entry) => entry.id === runId);
+    const context = contexts.get(runId) ?? options.resolveContext();
+    if (disposed || !run || !context?.generateWorkflowSummary || context.isSessionSummaryEnabled?.() === false || pending.has(runId))
+      return;
+    contexts.set(runId, context);
+    const controller = new AbortController;
+    pending.set(runId, controller);
+    const through = Date.now();
+    const text = workflowSummaryInput(run);
+    (async () => {
+      const summary = await context.generateWorkflowSummary(text, controller.signal, { terminal: terminal(run) });
+      if (summary && !controller.signal.aborted && !disposed && context.isSessionSummaryEnabled?.() !== false) {
+        await options.persist(runId, summary, through);
+      }
+    })().catch(() => {}).finally(() => {
+      if (pending.get(runId) === controller)
+        pending.delete(runId);
+    });
+  };
+  const refresh = () => {
+    for (const run of options.store.runs()) {
+      if (run.parentRunId)
+        continue;
+      if (!contexts.has(run.id)) {
+        const context = options.resolveContext();
+        if (context)
+          contexts.set(run.id, context);
+      }
+      const status = effectiveRunStatus(run);
+      if (!terminal(run))
+        finalized.delete(run.id);
+      else if (finalized.get(run.id) !== status) {
+        finalized.set(run.id, status);
+        pending.get(run.id)?.abort();
+        pending.delete(run.id);
+        request(run.id);
+      }
+    }
+  };
+  const unsubscribe = subscribeStoreInvalidation(options.store, refresh);
+  refresh();
+  return {
+    request,
+    dispose: () => {
+      disposed = true;
+      unsubscribe();
+      for (const controller of pending.values())
+        controller.abort();
+      pending.clear();
+      contexts.clear();
+    }
+  };
+}
+function terminal(run) {
+  const status = effectiveRunStatus(run);
+  return status === "blocked" || isTerminalRunStatus(status);
+}
+function workflowSummaryInput(run) {
+  const preferred = ["objective", "prompt", "task", "request", "input"];
+  const keys = [...new Set([...preferred.filter((key) => (key in run.inputs)), ...Object.keys(run.inputs)])].slice(0, 20);
+  const objective = keys.map((key) => {
+    const value2 = run.inputs[key];
+    const text = typeof value2 === "string" ? value2.slice(0, 2000) : typeof value2 === "object" && value2 !== null ? "[structured input]" : String(value2);
+    return `${key.slice(0, 100)}: ${text}`;
+  }).join(`
+`).slice(0, 4000);
+  const stages = run.stages.slice(-40).map((stage) => `${stage.name.slice(0, 100)}: ${stage.status}
+${(stage.result ?? stage.error ?? "").slice(-1500)}`).join(`
+`).slice(-11000);
+  return `Workflow: ${run.name.slice(0, 200)}
+Run: ${run.id}
+Status: ${effectiveRunStatus(run)}
+Objective/inputs:
+${objective}
+Latest stages and outputs:
+${stages}`.slice(0, 16000);
+}
+
 // dist/builtin/workflows/src/extension/runtime.ts
 init_backend();
 init_factory();
@@ -118639,6 +119036,9 @@ function createDurableResumeRuntime(deps) {
           registry: deps.registry,
           signal: options?.signal,
           onRunAccepted: options?.onRunAccepted,
+          onBeforeResume: options?.onBeforeResume,
+          confirmCrossProjectFork: options?.confirmCrossProjectFork,
+          forkModelOwner: options?.forkModelOwner,
           baseRunOpts: {
             ...deps.baseRunOpts(options?.policy),
             ...options?.budget === undefined ? {} : { budget: options.budget },
@@ -118739,6 +119139,8 @@ function createExtensionRuntime(opts = {}) {
   const registry = opts.registry ?? createRegistry(opts.definitions ?? []);
   const adapters = opts.adapters;
   const activeStore = opts.store ?? currentWorkflowStore();
+  if (opts.summaryContext)
+    ensureWorkflowSummaryService(activeStore, opts.summaryContext);
   const cancellation = opts.cancellation ?? currentCancellationRegistry();
   const stageControlRegistry = opts.stageControlRegistry ?? currentStageControlRegistry();
   const toolControlRegistry = opts.toolControlRegistry ?? currentToolControlRegistry();
@@ -119582,7 +119984,7 @@ function installWorkflowHeartbeatScheduler(options) {
         continue;
       }
       observed.add(run.id);
-      if (state.pending.has(run.id) || !isWorkflowHeartbeatEligibleRun(run)) {
+      if (state.pending.has(run.id) && options.onSummaryBoundary === undefined || !isWorkflowHeartbeatEligibleRun(run)) {
         state.scheduled.delete(run.id);
         continue;
       }
@@ -119651,6 +120053,7 @@ function installWorkflowHeartbeatScheduler(options) {
       const run = findRun(snapshot, details.runId);
       if (run === undefined || !isWorkflowHeartbeatEligibleRun(run))
         continue;
+      options.onSummaryBoundary?.(run.id);
       enqueueWorkflowHeartbeat(details);
     }
     refresh();
@@ -120042,6 +120445,7 @@ function createWorkflowExtensionRuntimeState(pi, adapters, options = {}) {
       });
   });
   pi.on?.("session_shutdown", () => {
+    disposeWorkflowSummaryService(store);
     detachHumanInput?.();
     detachHumanInput = undefined;
   });
@@ -120140,6 +120544,7 @@ function createWorkflowExtensionRuntimeState(pi, adapters, options = {}) {
       store,
       state: workflowHeartbeatSchedulerState,
       sendMessage: sendWorkflowNotificationMessage,
+      onSummaryBoundary: (runId) => requestWorkflowSummary(store, runId),
       resolveIntervalMinutes: (workflowName) => runtimeProxy.registry.get(workflowName)?.heartbeatIntervalMinutes,
       parentAvailabilityReported,
       anchorStore: durableWorkflowHeartbeatAnchorStore()
@@ -120254,7 +120659,7 @@ function createWorkflowExtensionRuntimeState(pi, adapters, options = {}) {
   function runtimeForContext(ctx) {
     const models = workflowModelCatalogFromContext(ctx, resolveLiveModelContext);
     const durabilityWarningSink = durabilityWarningSinkFromContext(ctx);
-    if (models === undefined && durabilityWarningSink === undefined)
+    if (models === undefined && durabilityWarningSink === undefined && !ctx?.generateWorkflowSummary)
       return runtimeProxy;
     return createExtensionRuntime({
       registry: runtimeRef.current.registry,
@@ -120268,6 +120673,7 @@ function createWorkflowExtensionRuntimeState(pi, adapters, options = {}) {
       config: runtimeConfigRef.current,
       resolvePossibleStageEntry,
       ...models === undefined ? {} : { models },
+      summaryContext: ctx,
       ...durabilityWarningSink === undefined ? {} : { durabilityWarningSink },
       resolveDefaultStageSessionDir,
       beforeRestoreCompleted,
@@ -122446,6 +122852,7 @@ Picker requires an interactive UI surface. Pass a runId: /workflow attach <id> [
             return true;
           }
           const run = store.runs().find((r) => r.id === resolved.runId);
+          await injectWorkflowResumeSummary(deps.pi, ctx, resolved.runId, run);
           const isPaused = run !== undefined && workflowHasPausedState(store, resolved.runId);
           const isDurableAuthorExit = run?.exited === true && run.status === "failed" && run.resumable === true;
           const isResumableContinuation = run !== undefined && !isPaused && run.exitReason !== "quit" && isWorkflowRunResumable(workflowRunResumeCandidate(run, store.runs()));
@@ -122604,6 +123011,7 @@ Picker requires an interactive UI surface. Pass a runId: /workflow attach <id> [
       fail(`Workflow ${stageRunId} is already running in this session. Attach with \`/workflow connect ${stageRunId}\` instead of resuming.`);
       return true;
     }
+    await injectWorkflowResumeSummary(deps.pi, ctx, stageRunId, run);
     if (isDurableAuthorExit) {
       return await handleDurableResume(stageRunId, ctx, reporter, deps);
     }
@@ -122946,6 +123354,7 @@ function resumeFailureCode(reason) {
     case "run_not_found":
       return "run_not_found";
     case "workflow_not_found":
+    case "different_project":
     case "invalid_inputs":
     case "startup_failed":
     case "insufficient_state":
@@ -122965,6 +123374,7 @@ function executeContext(ctx) {
     hasHumanInput: ctx.hasHumanInput,
     model: ctx.model,
     modelRegistry: ctx.modelRegistry,
+    isSessionSummaryEnabled: ctx.isSessionSummaryEnabled,
     cwd: ctx.cwd
   };
 }
@@ -123051,7 +123461,55 @@ function createSessionRunControl(host) {
       });
       if (result.action !== "status")
         throw failure3("control_failed", `Unexpected workflow result: ${result.action}`, undefined);
-      return result.runs;
+      const catalog = filter?.includeDurable ? await host.catalog?.() : undefined;
+      const cwd = host.context()?.cwd;
+      const canonicalPaths = new Map;
+      const canonicalize = (path) => {
+        const cached = canonicalPaths.get(path);
+        if (cached !== undefined)
+          return cached;
+        const canonical = canonicalDirectory(path);
+        canonicalPaths.set(path, canonical);
+        return canonical;
+      };
+      const entries = [...catalog?.resumable ?? [], ...catalog?.completed ?? []].filter((entry) => isSdkDurableRunInScope(entry, cwd, canonicalize));
+      const saved = new Map(entries.map((entry) => [entry.workflowId, entry]));
+      const snapshots = new Map(host.store.runs().map((run) => [run.id, run]));
+      const runs = result.runs.map((run) => {
+        const snapshot = snapshots.get(run.runId);
+        const entry = saved.get(run.runId);
+        const label = snapshot?.label ?? entry?.label;
+        return {
+          ...run,
+          label,
+          identity: workflowIdentity(run.runId, label, snapshot?.inputs ?? entry?.inputs),
+          summary: snapshot?.summary ?? entry?.summary,
+          summarizedThrough: snapshot?.summarizedThrough ?? entry?.summarizedThrough
+        };
+      });
+      const seen = new Set(runs.map((run) => run.runId));
+      for (const entry of entries) {
+        if (seen.has(entry.workflowId))
+          continue;
+        if (filter?.status === "awaiting_input" ? entry.pendingPrompts === 0 : filter?.status !== undefined && filter.status !== entry.status)
+          continue;
+        seen.add(entry.workflowId);
+        runs.push({
+          runId: entry.workflowId,
+          name: entry.name,
+          status: entry.status,
+          startedAt: entry.createdAt,
+          elapsedMs: Math.max(0, entry.updatedAt - entry.createdAt),
+          activeStages: [],
+          awaitingInputCount: entry.pendingPrompts,
+          awaitingInput: [],
+          label: entry.label,
+          identity: workflowIdentity(entry.workflowId, entry.label, entry.inputs),
+          summary: entry.summary,
+          summarizedThrough: entry.summarizedThrough
+        });
+      }
+      return runs;
     },
     async getRun(runId) {
       const result = await request({ action: "status", runId });
@@ -124223,6 +124681,7 @@ async function workflowResumeAction(args, deps) {
       warning = formatWorkflowResourceLoadWarning(error);
     }
     deps.signal?.throwIfAborted();
+    await deps.beforeResume?.(stageRunId);
     const continuation = await deps.getRuntime().resumeFailedRun(stageRunId, stage.stageId, {
       policy: deps.policy,
       actor: "agent",
@@ -124242,6 +124701,7 @@ ${continuation.message}`;
     };
   }
   try {
+    await deps.beforeResume?.(stageRunId);
     const result = await resumeRun(stageRunId, {
       ...owner,
       stageId: stage.stageId,
@@ -124598,7 +125058,7 @@ function durableInspectionError(action, runId, message) {
     truncated: false
   };
 }
-function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflowResourcesLoaded = () => {}, owner = captureWorkflowOwnerResources()) {
+function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflowResourcesLoaded = () => {}, owner = captureWorkflowOwnerResources(), pi = {}) {
   const { store, toolControlRegistry } = owner;
   return async function executeWorkflowTool(args, ctx, signal, onRunAccepted, access) {
     signal?.throwIfAborted();
@@ -124632,6 +125092,9 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
       if (access === "sdk" && isFullRunId(args.runId?.trim() ?? "") && (action === "status" || action === "stages" || action === "resume" && handle !== undefined && isSdkCrashedRunAdoptable(handle, recoveryCwd)) && !store.runs().some((run) => run.id === id) && handle !== undefined && isSdkDurableRunInScope(handle, recoveryCwd))
         return;
       assertWorkflowInstanceOwner(id, ctx, store);
+      if (action === "resume" && recoveryCwd !== undefined && handle?.invocationCwd !== undefined && canonicalDirectory(recoveryCwd) !== canonicalDirectory(handle.invocationCwd)) {
+        throw new Error(crossProjectResumeMessage(id, handle.invocationCwd));
+      }
     };
     if (action === "status" && args.runId === undefined) {
       for (const run of topLevelWorkflowRuns(store.runs()))
@@ -124652,7 +125115,10 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
       const resolved = typeof runtime === "function" ? runtime(ctx) : runtime;
       return {
         ...resolved,
-        resumeDurableWorkflow: (id, options) => resolved.resumeDurableWorkflow(id, access === "sdk" || adoptsReleasedRun(id) ? { ...options, modelOwner: workflowCaller(ctx) } : options)
+        resumeDurableWorkflow: async (id, options) => {
+          await injectWorkflowResumeSummary(pi, ctx, id);
+          return resolved.resumeDurableWorkflow(id, access === "sdk" || adoptsReleasedRun(id) ? { ...options, modelOwner: workflowCaller(ctx) } : options);
+        }
       };
     };
     const ensureWorkflowResourcesVisible = async () => {
@@ -124770,7 +125236,8 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
           signal,
           onRunAccepted,
           owner,
-          authorize
+          authorize,
+          beforeResume: (id) => injectWorkflowResumeSummary(pi, ctx, id, store.runs().find((run) => run.id === id))
         }));
       default: {
         const _exhaustive = action;
@@ -125402,7 +125869,7 @@ function factory(pi) {
   const workflowCommands = new Map;
   const storeWidgetRef = { current: null };
   const intercomControlRef = { current: null };
-  const executeWorkflowTool = makeExecuteWorkflowTool((ctx) => runtimeState.runtimeForContext(ctx), runtimeState.reloadWorkflowResources, runtimeState.ensureWorkflowResourcesLoaded, owner);
+  const executeWorkflowTool = makeExecuteWorkflowTool((ctx) => runtimeState.runtimeForContext(ctx), runtimeState.reloadWorkflowResources, runtimeState.ensureWorkflowResourcesLoaded, owner, pi);
   let sessionContext;
   pi.on?.("session_start", (_event, ctx) => {
     sessionContext = ctx;
@@ -125410,7 +125877,15 @@ function factory(pi) {
   pi.on?.("session_shutdown", () => {
     sessionContext = undefined;
   });
-  pi.registerWorkflowRunControl?.(createSessionRunControl({ execute: executeWorkflowTool, context: () => sessionContext, store: owner.store }));
+  pi.registerWorkflowRunControl?.(createSessionRunControl({
+    execute: executeWorkflowTool,
+    context: () => sessionContext,
+    store: owner.store,
+    catalog: async () => {
+      const runtime = runtimeState.runtimeForContext(sessionContext);
+      return await runtime.prepareDurableCatalog?.() ?? { resumable: [], completed: [] };
+    }
+  }));
   const executeWorkflowToolWithAutoAttach = async (args, ctx, signal, onRunAccepted) => {
     const result = await executeWorkflowTool(args, ctx, signal, onRunAccepted);
     if (workflowPolicyFromContext(ctx).allowInputPicker && result.action === "run" && result.status === "running" && result.runId.length > 0 && result.name !== undefined && runtimeState.runtimeProxy.registry.get(result.name)?.autoAttach === true) {