@bastani/atomic 0.9.25-alpha.2 → 0.9.25-alpha.4

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

@@ -30558,7 +30558,7 @@ function createRecoverablePostgresPool(initialUrl, options = {}) {
         release(true);
       for (const { client } of held) {
         if (client.listenerCount("error") > 0) {
-          client.emit("error", new Error("Postgres dependency invalidated"));
+          client.emit("error", new DbosDependencyError("Postgres dependency invalidated"));
         }
       }
     }
@@ -30674,6 +30674,7 @@ function createRecoverablePostgresPool(initialUrl, options = {}) {
 var import_datasource;
 var init_dbos_recoverable_pool = __esm(() => {
   init_esm();
+  init_dbos_admission();
   import_datasource = __toESM(require_datasource(), 1);
 });
 
@@ -87745,6 +87746,9 @@ function isMonitoringConnectionFailure(error) {
     return ["ECONNREFUSED", "ECONNRESET", "EPIPE", "ETIMEDOUT", "57P01", "57P02", "57P03"].includes(String(error.code));
   return error.message === "timeout expired" || error.message === "Connection terminated due to connection timeout";
 }
+function isQueryReadTimeout(error) {
+  return error instanceof Error && error.message === "Query read timeout";
+}
 
 class PostgresHealth {
   operations;
@@ -87777,11 +87781,20 @@ class PostgresHealth {
     try {
       if (this.stopped)
         throw new DbosDependencyError;
-      await this.operations.validate?.(client);
+      try {
+        await this.operations.validate?.(client);
+      } catch (error) {
+        if (!isQueryReadTimeout(error) || this.stopped)
+          throw error;
+        await this.operations.validate?.(client);
+      }
     } catch (error) {
       this.failure = error instanceof Error ? error : new Error(String(error));
-      this.invalidate();
-      throw error;
+      if (!isQueryReadTimeout(error)) {
+        this.invalidate();
+        throw error;
+      }
+      throw new DbosDependencyError("Managed PostgreSQL did not answer a connection identity check in time.");
     }
   }
   check() {
@@ -87815,7 +87828,7 @@ class PostgresHealth {
     try {
       identity = await this.operations.probe();
     } catch (error) {
-      if (!isMonitoringConnectionFailure(error) || this.stopped)
+      if (!(isMonitoringConnectionFailure(error) || isQueryReadTimeout(error)) || this.stopped)
         throw error;
       try {
         identity = await this.operations.probe();
@@ -87845,6 +87858,10 @@ class PostgresHealth {
       if (ready !== undefined)
         return ready;
     } catch (error) {
+      if (isQueryReadTimeout(error)) {
+        this.failure = new DbosDependencyError("Managed PostgreSQL did not answer a health check in time.");
+        throw this.failure;
+      }
       this.failure = error instanceof Error ? error : new Error(String(error));
       if (!(error instanceof Error && ("code" in error) && error.code === "53300"))
         this.invalidate();
@@ -88108,6 +88125,7 @@ var POSTGRES_IDENTITY_SQL = `SELECT current_setting('data_directory') AS data_di
 	split_part(pg_read_file('postmaster.pid'), E'\\n', 3) AS started,
 	system_identifier::text, current_setting('server_version') AS server_version FROM pg_control_system()`;
 var POSTGRES_TIMEZONE_SQL = "SELECT set_config('timezone_abbreviations', 'Default', true)";
+var POSTGRES_HEALTH_QUERY_TIMEOUT_MS = 3000;
 async function probePostgresTimezoneData(port) {
   const client = new Client({
     host: "127.0.0.1",
@@ -88117,8 +88135,8 @@ async function probePostgresTimezoneData(port) {
     database: "postgres",
     ssl: false,
     connectionTimeoutMillis: 1000,
-    query_timeout: 1000,
-    statement_timeout: 1000
+    query_timeout: POSTGRES_HEALTH_QUERY_TIMEOUT_MS,
+    statement_timeout: POSTGRES_HEALTH_QUERY_TIMEOUT_MS
   });
   client.on("error", () => {});
   try {
@@ -88137,8 +88155,8 @@ async function probePostgresIdentity(port) {
     database: "postgres",
     ssl: false,
     connectionTimeoutMillis: 1000,
-    query_timeout: 1000,
-    statement_timeout: 1000
+    query_timeout: POSTGRES_HEALTH_QUERY_TIMEOUT_MS,
+    statement_timeout: POSTGRES_HEALTH_QUERY_TIMEOUT_MS
   });
   client.on("error", () => {});
   try {
@@ -88146,6 +88164,8 @@ async function probePostgresIdentity(port) {
     const result = await client.query(POSTGRES_IDENTITY_SQL);
     return result.rows[0];
   } catch (error) {
+    if (isQueryReadTimeout(error))
+      throw error;
     const code = error instanceof Error && "code" in error ? error.code : undefined;
     if (code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE" || code === "57P01" || code === "57P02" || code === "57P03" || error instanceof Error && /timeout|timed out|connection terminated/i.test(error.message))
       return;
@@ -88313,6 +88333,15 @@ async function ensureCluster(options = {}) {
       }
       let verified;
       const existingServerProbe = () => options.probeIdentity ?? probePostgresIdentity;
+      const startupServerProbe = async (probePort) => {
+        try {
+          return await existingServerProbe()(probePort);
+        } catch (error) {
+          if (isQueryReadTimeout(error))
+            return;
+          throw error;
+        }
+      };
       let prepared = options.prepared ? options.binaries : undefined;
       let selectedIdentity = options.runtimeIdentity;
       let reservedLiveGeneration;
@@ -88433,7 +88462,7 @@ async function ensureCluster(options = {}) {
         }
       } else if (existing) {
         await waitForClusterReadiness(logFile, undefined, async () => {
-          verified = await verifyPostgresIdentity(metadata, port, existing.pid, existingServerProbe());
+          verified = await verifyPostgresIdentity(metadata, port, existing.pid, startupServerProbe);
           return verified !== undefined || managedPostmaster(metadata) === undefined;
         }, READY_ATTEMPTS, delay, port, dataDir);
       }
@@ -88465,7 +88494,7 @@ async function ensureCluster(options = {}) {
             startedCluster = { lease };
             activeCluster = startedCluster;
             await waitForClusterReadiness(logFile, startedCluster, async () => {
-              verified = await verifyPostgresIdentity(metadata, port, lease.pid, options.probeIdentity);
+              verified = await verifyPostgresIdentity(metadata, port, lease.pid, startupServerProbe);
               return verified !== undefined;
             }, READY_ATTEMPTS, delay, port, dataDir);
             break;
@@ -88534,14 +88563,14 @@ async function ensureCluster(options = {}) {
           probe: () => inspect(),
           validate: async (client) => {
             const identity = await inspect(async () => {
-              const query = { text: POSTGRES_IDENTITY_SQL, query_timeout: 1000 };
+              const query = { text: POSTGRES_IDENTITY_SQL, query_timeout: POSTGRES_HEALTH_QUERY_TIMEOUT_MS };
               const result = await client.query(query);
               return result.rows[0];
             });
             if (!identity)
               throw new DbosDependencyError;
             if (options.probeIdentity === undefined) {
-              const query = { text: POSTGRES_TIMEZONE_SQL, query_timeout: 1000 };
+              const query = { text: POSTGRES_TIMEZONE_SQL, query_timeout: POSTGRES_HEALTH_QUERY_TIMEOUT_MS };
               await client.query(query);
             }
           },
@@ -92489,6 +92518,11 @@ async function resumeRun(runId, opts) {
     ...acknowledgementMessage !== undefined ? { message: acknowledgementMessage } : {}
   };
 }
+function isRunFullyPaused(activeStore, runId, controlRunIds) {
+  const runs = activeStore.runs();
+  const hasLiveStage = controlRunIds.some((controlRunId) => runs.find((candidate) => candidate.id === controlRunId)?.stages.some((stage) => stage.status === "running" || stage.status === "pending") === true);
+  return !hasLiveStage && runs.find((candidate) => candidate.id === runId)?.status === "paused";
+}
 async function pauseRunWithAction(runId, opts, action = "pause") {
   const activeStore = opts?.store ?? store;
   const registry = opts?.stageControlRegistry ?? stageControlRegistry;
@@ -92531,7 +92565,11 @@ async function pauseRunWithAction(runId, opts, action = "pause") {
         message: `Run ${runId} paused (${run.controlPersistence ?? "observed"}). ${run.controlPersistence === "durable" ? "Database persistence confirmed." : "Pause observed locally, not confirmed persisted."} Resume with /workflow resume on this live process; untracked initialization or workflow code may still finish, but further workflow steps and completion wait for resume. Cross-process resume requires durable checkpoint or pending prompt progress.`
       };
     }
-    return { ok: false, runId, reason: "no_active_stages" };
+    return {
+      ok: false,
+      runId,
+      reason: isRunFullyPaused(activeStore, runId, controlRunIds) ? "already_paused" : "no_active_stages"
+    };
   }
   const paused = [];
   const pausedRunIds = new Set;
@@ -92574,12 +92612,22 @@ async function pauseRun(runId, opts) {
 async function pauseAllRuns(opts) {
   const activeStore = opts?.store ?? store;
   const inFlight = topLevelWorkflowRuns(activeStore.runs()).filter((run) => run.endedAt === undefined);
-  return Promise.all(inFlight.map((run) => pauseRun(run.id, {
+  const settled = await Promise.allSettled(inFlight.map((run) => pauseRun(run.id, {
     store: activeStore,
     stageControlRegistry: opts?.stageControlRegistry,
     toolControlRegistry: opts?.toolControlRegistry,
     jobs: opts?.jobs
   })));
+  return settled.map((result, index) => {
+    if (result.status === "fulfilled")
+      return result.value;
+    return {
+      ok: false,
+      runId: inFlight[index].id,
+      reason: "pause_failed",
+      message: result.reason instanceof Error ? result.reason.message : String(result.reason)
+    };
+  });
 }
 
 // dist/builtin/workflows/src/shared/persistence-compaction-policy.ts
@@ -93598,6 +93646,8 @@ function stageFailureMessage(runId, resultReason, action) {
       return `Run not found: ${runId}`;
     case "already_ended":
       return `Run already ended: ${runId}`;
+    case "already_paused":
+      return `Run ${runId} is already paused.`;
     case "stage_not_found":
       return `Stage not found for run: ${runId}`;
     default:
@@ -93688,7 +93738,7 @@ function resolveStageTarget(runId, stageTarget, activeStore = store) {
     return ambiguousUuidStageTarget(target, uuidMatches);
   const matches = graph.stages.filter((stage) => stageMatchesExpandedIdentifier(stage, target));
   if (matches.length === 0)
-    return { ok: false, message: `Stage not found in run ${runId}: ${target}` };
+    return { ok: false, message: `Stage not found in run ${runId}: ${target}`, code: "stage_not_found" };
   if (matches.length > 1)
     return ambiguousStageTarget(target, matches);
   return resolvedStageTarget(matches[0]);
@@ -93711,12 +93761,14 @@ function matchingUuidStages(stages, target) {
 function ambiguousUuidStageTarget(target, stages) {
   return {
     ok: false,
+    code: "stage_ambiguous",
     message: `Ambiguous stage UUID prefix "${target}" matches: ${stages.map((stage) => stage.workflowGraphTarget.stageId).join(", ")}. Use the full 36-character UUID.`
   };
 }
 function ambiguousStageTarget(target, stages) {
   return {
     ok: false,
+    code: "stage_ambiguous",
     message: `Ambiguous stage identifier "${target}" matches: ${stages.map(expandedStageLabel).join(", ")}`
   };
 }
@@ -93742,10 +93794,11 @@ function resolveControlNodeTarget(runId, stageTarget, activeStore = store) {
     if (matches.length > 1)
       return {
         ok: false,
+        code: "stage_ambiguous",
         message: `Ambiguous stage identifier "${target}" matches: ${matches.map(expandedStageLabel).join(", ")}`
       };
   }
-  return { ok: false, message: `Stage not found in run ${runId}: ${target}` };
+  return { ok: false, message: `Stage not found in run ${runId}: ${target}`, code: "stage_not_found" };
 }
 function resolvedControlNodeTarget(node) {
   const graphTarget = node.workflowGraphTarget;
@@ -106960,7 +107013,7 @@ async function resumeDurableWorkflowClaimed(workflowId, deps, catalog) {
 function foreignRunningResult(name, workflowId) {
   return {
     ok: false,
-    reason: "not_resumable",
+    reason: "owned_elsewhere",
     message: `Workflow "${name}" (${workflowId}) is actively running in another Atomic session. ` + "Control it from that session; it becomes resumable here only after that session pauses, quits, or crashes."
   };
 }
@@ -114012,7 +114065,8 @@ async function run(def, inputs, opts = {}) {
   let admissionControlError;
   let pausePersistence;
   let resumePersistence;
-  let controlAttempt;
+  let controlSettlements = Promise.resolve();
+  let latestControl = 0;
   let pauseGeneration = 0;
   const persistRunControl = async (status) => {
     ownController.signal.throwIfAborted();
@@ -114026,27 +114080,30 @@ async function run(def, inputs, opts = {}) {
     }
     if (durableBackend.getWorkflow(runId) === undefined)
       return;
-    controlAttempt?.abort(new Error("Workflow control superseded"));
-    const attempt = new AbortController;
-    controlAttempt = attempt;
+    const previous = controlSettlements;
+    const control = ++latestControl;
     const settlement = (async () => {
       try {
-        await boundedAdmission((signal) => dbosAdmissionContext.run(signal, async () => {
-          if (!await transitionDurableWorkflowStatus(durableBackend, runId, ["running", "paused"], status, undefined, true)) {
-            throw new Error(`Workflow ${runId} refused the durable ${status} transition`);
-          }
-          signal.throwIfAborted();
-          recordRunTimingCheckpoint(durableBackend, runSnapshot);
-          await durableBackend.flush(runId);
-        }), AbortSignal.any([ownController.signal, attempt.signal]), DBOS_ADMISSION_TIMEOUT_MS);
-        attempt.signal.throwIfAborted();
+        await boundedAdmission(async (signal) => {
+          await raceAbort(previous, signal);
+          await dbosAdmissionContext.run(signal, async () => {
+            if (!await transitionDurableWorkflowStatus(durableBackend, runId, ["running", "paused"], status, undefined, true)) {
+              throw new Error(`Workflow ${runId} refused the durable ${status} transition`);
+            }
+            signal.throwIfAborted();
+            recordRunTimingCheckpoint(durableBackend, runSnapshot);
+            await durableBackend.flush(runId);
+          });
+        }, ownController.signal, DBOS_ADMISSION_TIMEOUT_MS);
         ownController.signal.throwIfAborted();
+        if (control !== latestControl)
+          return;
         activeStore.recordRunExecutionState(runId, {
           controlPersistence: durableBackend.persistent ? "durable" : "observed",
           ...durableRootAdmitted ? { phase: "executing", dependencyError: undefined } : {}
         });
       } catch (error) {
-        if (!attempt.signal.aborted && !ownController.signal.aborted && isDbosDependencyError(error)) {
+        if (control === latestControl && !ownController.signal.aborted && isDbosDependencyError(error)) {
           activeStore.recordRunExecutionState(runId, {
             phase: "blocked_dependency",
             dependencyError: `Workflow database unavailable during ${status === "paused" ? "pause" : "resume"}; persistence not confirmed.`
@@ -114057,6 +114114,11 @@ async function run(def, inputs, opts = {}) {
         throw error;
       }
     })();
+    controlSettlements = settlement.then(() => {
+      return;
+    }, () => {
+      return;
+    });
     if (status === "running")
       return settlement;
     let acknowledgementTimer;
@@ -114085,7 +114147,6 @@ async function run(def, inputs, opts = {}) {
     pause: () => {
       ownController.signal.throwIfAborted();
       pauseGeneration++;
-      controlAttempt?.abort(new Error("Workflow control superseded by pause"));
       scheduler.pauseRun();
       activeStore.recordRunPaused(runId, undefined, { resumable: true });
       pausePersistence = persistRunControl("paused");
@@ -115625,7 +115686,7 @@ function createExtensionRuntime(opts = {}) {
     if (!resumed.ok)
       return {
         ok: false,
-        reason: resumed.reason === "workflow_not_found" ? "workflow_not_found" : resumed.reason === "not_resumable" || resumed.reason === "stale" ? "not_resumable" : "insufficient_state",
+        reason: resumed.reason === "workflow_not_found" ? "workflow_not_found" : resumed.reason === "owned_elsewhere" ? "owned_elsewhere" : resumed.reason === "not_resumable" || resumed.reason === "stale" ? "not_resumable" : "insufficient_state",
         message: resumed.message
       };
     return {
@@ -119459,6 +119520,33 @@ function openWorkflowResumeSelector(ui, liveRuns, hydrate, options = {}) {
   });
 }
 
+// dist/builtin/workflows/src/extension/workflow-bulk-control.ts
+function isAlreadyPaused(result) {
+  return !result.ok && result.reason === "already_paused";
+}
+function leavesRunActive(result) {
+  return !result.ok && result.reason !== "already_paused" && result.reason !== "already_ended";
+}
+function bulkFailedRuns(results) {
+  return results.filter(leavesRunActive).map((result) => ({
+    runId: result.runId,
+    reason: result.reason,
+    ...result.message === undefined ? {} : { message: result.message }
+  }));
+}
+function bulkAlreadyPausedCount(results) {
+  return results.filter(isAlreadyPaused).length;
+}
+function bulkUnstoppedStatus(results) {
+  return results.some((result) => result.ok) ? { status: "partial" } : { status: "noop", code: "control_failed" };
+}
+function bulkFailureMessage(verb, action, results, describeSuccess) {
+  const successes = results.filter((result) => result.ok).length;
+  const failures = results.filter(leavesRunActive).length;
+  const outcomes = results.map((result) => result.ok ? describeSuccess(result) : `${result.runId}: ${result.reason}${result.message === undefined ? "" : ` (${result.message})`}`).join(", ");
+  return `${successes > 0 ? `${verb} ${successes} run(s); ` : ""}failed to ${action} ${failures} run(s); outcomes: ${outcomes}.`;
+}
+
 // dist/builtin/workflows/src/durable/resume-catalog.ts
 function formatResumableWorkflowList(entries) {
   if (entries.length === 0)
@@ -119819,12 +119907,11 @@ ${renderSessionList(store.runs(), { theme, includeAll: true })}`);
         }
       }
       const results = action === "quit" ? await quitAllRuns({ ...owner, actor: "user" }) : await pauseAllRuns(owner);
-      const successes = results.filter((result) => result.ok);
+      const successes = results.flatMap((result) => result.ok ? [result] : []);
       const changed = successes.length;
-      const failures = results.filter((result) => !result.ok);
-      if (action === "quit" && failures.length > 0) {
-        const outcomes = results.map((result) => result.ok ? result.message ?? `${result.runId}: quit` : `${result.runId}: ${result.reason}${"message" in result ? ` (${result.message})` : ""}`).join(", ");
-        const message = `${changed > 0 ? `Quit ${changed} run(s); ` : ""}failed to quit ${failures.length} run(s); outcomes: ${outcomes}.`;
+      const alreadyPaused = bulkAlreadyPausedCount(results);
+      if (bulkFailedRuns(results).length > 0) {
+        const message = bulkFailureMessage(action === "quit" ? "Quit" : "Paused", action, results, (result) => result.message ?? `${result.runId}: ${action === "quit" ? "quit" : "paused"}`);
         if (changed > 0)
           print(message);
         else
@@ -119832,6 +119919,8 @@ ${renderSessionList(store.runs(), { theme, includeAll: true })}`);
       } else if (changed > 0) {
         print(successes.some((result) => result.message !== undefined) ? successes.map((result) => result.message ?? `Run ${result.runId} stopped.`).join(`
 `) : action === "quit" ? `Quit ${changed} run(s); resume with /workflow resume.` : `Paused ${changed} run(s).`);
+      } else if (alreadyPaused > 0) {
+        print(`${alreadyPaused} in-flight run(s) already paused.`);
       } else {
         fail(`No in-flight runs to ${action}.`);
       }
@@ -119878,6 +119967,8 @@ ${renderSessionList(store.runs(), { theme, includeAll: true })}`);
       const result = await pauseRun(resolved.runId, owner);
       if (result.ok)
         print(result.message ?? `Run ${result.runId} paused and can be resumed.`);
+      else if (result.reason === "already_paused")
+        print(`Run ${result.runId} is already paused.`);
       else
         fail(result.reason === "not_found" ? `Run not found: ${target}` : result.reason === "already_ended" ? `Run already ended: ${target}` : result.reason === "stage_not_found" ? `Stage not found for run ${resolved.runId}.` : `No active stages to pause on run ${resolved.runId}.`);
     } catch (error) {
@@ -120401,11 +120492,31 @@ function createWorkflowObservation(store, publisher, ownerSessionId) {
   };
 }
 
-// dist/builtin/workflows/src/extension/workflow-tool.ts
-import { getSupportedThinkingLevels } from "@bastani/pi-ai/compat";
+// dist/builtin/workflows/src/extension/workflow-session-run-control.ts
+import {
+  WorkflowRunControlError,
+  WorkflowRunControlUnavailableError,
+  WorkflowRunDatabaseError,
+  WorkflowRunNotFoundError,
+  WorkflowRunNotResumableError,
+  WorkflowRunOwnershipError,
+  WorkflowStageAmbiguousError,
+  WorkflowStageNotFoundError,
+  WorkflowStageResumeUnsupportedError
+} from "@bastani/atomic";
+
+// dist/builtin/workflows/src/extension/workflow-control-failure.ts
+init_dbos_admission();
 
 // dist/builtin/workflows/src/extension/workflow-instance-owner.ts
 var anonymousCallers = new WeakMap;
+
+class WorkflowInstanceOwnershipError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorkflowInstanceOwnershipError";
+  }
+}
 function workflowCaller(ctx) {
   const sessionId = ctx.sessionId ?? ctx.sessionManager?.getSessionId?.();
   if (sessionId)
@@ -120431,9 +120542,9 @@ function assertWorkflowInstanceOwner(id, ctx, store) {
     const modelOwner = durable?.modelOwner ?? local?.modelOwner;
     if (modelOwner !== undefined) {
       if (modelOwner !== workflowCaller(ctx))
-        throw new Error("Workflow instance belongs to another caller/session.");
+        throw new WorkflowInstanceOwnershipError("Workflow instance belongs to another caller/session.");
     } else if ((durable?.origin ?? local?.origin) === "agent") {
-      throw new Error("Workflow instance ownership is unavailable; another caller cannot assume authority.");
+      throw new WorkflowInstanceOwnershipError("Workflow instance ownership is unavailable; another caller cannot assume authority.");
     }
     const parentId = durable?.rootWorkflowId ?? local?.parentRunId;
     if (parentId !== undefined)
@@ -120451,6 +120562,176 @@ function assertWorkflowInstanceOwner(id, ctx, store) {
   }
 }
 
+// dist/builtin/workflows/src/extension/workflow-control-failure.ts
+function classifyControlError(error) {
+  if (error instanceof WorkflowInstanceOwnershipError)
+    return "owned_elsewhere";
+  if (error instanceof DbosDurabilityError || isDbosDependencyError(error))
+    return "database_unavailable";
+  return "control_failed";
+}
+function resumeFailureCode(reason) {
+  switch (reason) {
+    case "not_resumable":
+    case "stale":
+      return "not_resumable";
+    case "owned_elsewhere":
+      return "owned_elsewhere";
+    case "not_registered":
+    case "run_not_found":
+      return "run_not_found";
+    case "workflow_not_found":
+    case "invalid_inputs":
+    case "startup_failed":
+    case "insufficient_state":
+      return "control_failed";
+  }
+}
+
+// dist/builtin/workflows/src/extension/workflow-session-run-control.ts
+function executeContext(ctx) {
+  if (ctx === undefined)
+    throw new WorkflowRunControlUnavailableError;
+  return {
+    sessionId: ctx.sessionManager?.getSessionId?.(),
+    sessionManager: ctx.sessionManager,
+    ui: ctx.ui,
+    hasUI: ctx.hasUI,
+    hasHumanInput: ctx.hasHumanInput,
+    model: ctx.model,
+    modelRegistry: ctx.modelRegistry,
+    cwd: ctx.cwd
+  };
+}
+function errorOptions(runId, cause, failedRuns) {
+  return {
+    ...runId === undefined || runId === "--all" ? {} : { runId },
+    ...cause === undefined ? {} : { cause },
+    ...failedRuns === undefined ? {} : { failedRuns }
+  };
+}
+function failure3(code, message, runId, cause, failedRuns) {
+  const options = errorOptions(runId, cause, failedRuns);
+  switch (code) {
+    case "run_not_found":
+      return new WorkflowRunNotFoundError(message, options);
+    case "not_resumable":
+      return new WorkflowRunNotResumableError(message, options);
+    case "owned_elsewhere":
+      return new WorkflowRunOwnershipError(message, options);
+    case "stage_not_found":
+      return new WorkflowStageNotFoundError(message, options);
+    case "stage_ambiguous":
+      return new WorkflowStageAmbiguousError(message, options);
+    case "stage_resume_unsupported":
+      return new WorkflowStageResumeUnsupportedError(message, options);
+    case "database_unavailable":
+      return new WorkflowRunDatabaseError(message, options);
+    case "control_failed":
+      return new WorkflowRunControlError("WORKFLOW_RUN_CONTROL_FAILED", message, options);
+  }
+}
+function translateThrown(error, runId) {
+  const code = classifyControlError(error);
+  return code === "owned_elsewhere" || code === "database_unavailable" ? failure3(code, error.message, runId, error) : error;
+}
+function controlStatus(status, runId) {
+  switch (status) {
+    case "ok":
+    case "running":
+    case "paused":
+    case "partial":
+    case "noop":
+    case "cancelled":
+      return status;
+    default:
+      throw failure3("control_failed", `Unexpected workflow control status: ${status}`, runId);
+  }
+}
+function controlOutcome(result) {
+  if (result.action !== "pause" && result.action !== "quit" && result.action !== "resume") {
+    throw failure3("control_failed", `Unexpected workflow result: ${result.action}`, undefined);
+  }
+  if ("code" in result && result.code !== undefined) {
+    throw failure3(result.code, result.message, result.runId, undefined, "failedRuns" in result ? result.failedRuns : undefined);
+  }
+  return { ...result, status: controlStatus(result.status, result.runId) };
+}
+function rejectUnknownRunPrefix(store, runId) {
+  const target = runId.trim();
+  if (!isRunIdPrefix(target))
+    return;
+  const resolution = resolveRunIdTarget(target, store.runs().map((run) => run.id));
+  if (resolution.kind === "not_found") {
+    throw failure3("run_not_found", `Run not found: ${target} (no run in this session has that prefix; pass the full run id for a run recorded elsewhere).`, runId);
+  }
+}
+function createSessionRunControl(host) {
+  const request = async (args) => {
+    try {
+      const ctx = executeContext(host.context());
+      if (args.runId !== undefined && (args.action === "status" || args.action === "stages"))
+        rejectUnknownRunPrefix(host.store, args.runId);
+      return await host.execute(args, ctx);
+    } catch (error) {
+      throw error instanceof Error ? translateThrown(error, args.runId) : error;
+    }
+  };
+  const target = (runId) => typeof runId === "string" ? { runId } : { all: true };
+  return {
+    async listRuns(filter) {
+      const result = await request({
+        action: "status",
+        ...filter?.status === undefined ? {} : { statusFilter: filter.status }
+      });
+      if (result.action !== "status")
+        throw failure3("control_failed", `Unexpected workflow result: ${result.action}`, undefined);
+      return result.runs;
+    },
+    async getRun(runId) {
+      const result = await request({ action: "status", runId });
+      if (result.action !== "statusDetail")
+        throw failure3("control_failed", `Unexpected workflow result: ${result.action}`, runId);
+      if ("error" in result)
+        throw failure3("run_not_found", result.error, runId);
+      return result.detail;
+    },
+    async getStages(runId, filter) {
+      const result = await request({
+        action: "stages",
+        runId,
+        ...filter?.status === undefined ? {} : { statusFilter: filter.status }
+      });
+      if (result.action !== "stages")
+        throw failure3("control_failed", `Unexpected workflow result: ${result.action}`, runId);
+      if (result.error !== undefined)
+        throw failure3("run_not_found", result.error, runId);
+      return result.stages;
+    },
+    async pause(runId, options) {
+      return controlOutcome(await request({
+        action: "pause",
+        ...target(runId),
+        ...options?.stageId === undefined ? {} : { stageId: options.stageId }
+      }));
+    },
+    async quit(runId) {
+      return controlOutcome(await request({ action: "quit", ...target(runId) }));
+    },
+    async resume(runId, options) {
+      return controlOutcome(await request({
+        action: "resume",
+        runId,
+        ...options?.stageId === undefined ? {} : { stageId: options.stageId },
+        ...options?.message === undefined ? {} : { message: options.message }
+      }));
+    }
+  };
+}
+
+// dist/builtin/workflows/src/extension/workflow-tool.ts
+import { getSupportedThinkingLevels } from "@bastani/pi-ai/compat";
+
 // dist/builtin/workflows/src/extension/workflow-status-summary.ts
 var workflowStatusRenderRuns = new WeakMap;
 function setWorkflowStatusRenderRuns(result, runs) {
@@ -121054,12 +121335,41 @@ async function abortToolNode(runId, nodeId, opts) {
 }
 
 // dist/builtin/workflows/src/extension/workflow-tool-control.ts
-function controlFailure(action, runId, error) {
+async function foreignRunFailure(action, target, guard) {
+  if (guard === undefined || !isFullRunId(target))
+    return;
+  let durable;
+  try {
+    durable = await guard.getRuntime().inspectDurableWorkflow(target);
+  } catch (error) {
+    return controlFailure(action, target, error, "database_unavailable");
+  }
+  if (durable.kind !== "found")
+    return;
+  const runId = durable.detail.runId;
+  const foreign = (message) => ({
+    action,
+    runId,
+    status: "noop",
+    message,
+    code: "owned_elsewhere"
+  });
+  try {
+    guard.authorize?.(runId);
+  } catch (error) {
+    if (error instanceof WorkflowInstanceOwnershipError)
+      return foreign(error.message);
+    throw error;
+  }
+  return durable.detail.ownerActiveElsewhere === true ? foreign(`Workflow ${runId} is actively running in another Atomic session. Control it from that session; it can be ${action === "pause" ? "paused" : "quit"} only by its owner.`) : undefined;
+}
+function controlFailure(action, runId, error, code = classifyControlError(error)) {
   return {
     action,
     runId,
     status: "noop",
-    message: `Failed to ${action} run ${runId}: ${error instanceof Error ? error.message : String(error)}`
+    message: `Failed to ${action} run ${runId}: ${error instanceof Error ? error.message : String(error)}`,
+    code
   };
 }
 function resumeControlFailure(runId, error, store) {
@@ -121070,7 +121380,8 @@ function resumeControlFailure(runId, error, store) {
     action: "resume",
     runId,
     status: visiblyRunning ? "partial" : "noop",
-    message: `Failed to resume run ${runId}: ${detail}`
+    message: `Failed to resume run ${runId}: ${detail}`,
+    ...visiblyRunning ? {} : { code: classifyControlError(error) }
   };
 }
 async function workflowReloadAction(args, deps) {
@@ -121096,12 +121407,6 @@ async function workflowReloadAction(args, deps) {
     };
   }
 }
-function bulkQuitFailureMessage(results) {
-  const successes = results.filter((result) => result.ok).length;
-  const failures = results.length - successes;
-  const outcomes = results.map((result) => result.ok ? result.message ?? `${result.runId}: quit${abandonedToolSuffix(result.abandonedTools)}` : `${result.runId}: ${result.reason}${"message" in result ? ` (${result.message})` : ""}`).join(", ");
-  return `${successes > 0 ? `Quit ${successes} run(s); ` : ""}failed to quit ${failures} run(s); outcomes: ${outcomes}.`;
-}
 function abandonedToolSuffix(abandonedTools) {
   return abandonedTools.length === 0 ? "" : ` (abandoned tool node(s): ${abandonedTools.map(formatToolNodeIdentity).join(", ")})`;
 }
@@ -121140,7 +121445,7 @@ async function quitToolNodeAction(runId, nodeId, action, owner) {
     message: `Cancelled ctx.tool ${aborted.name} (${nodeId}) on run ${runId}.${abandonedNote}` + ` Sibling work was not aborted. Current workflow status: ${workflowStatus}.` + " If workflow code awaited this call without catching cancellation, the workflow may fail." + " A later resume re-runs this call."
   };
 }
-async function workflowQuitAction(args, owner = captureWorkflowOwnerResources()) {
+async function workflowQuitAction(args, owner = captureWorkflowOwnerResources(), guard) {
   const { store } = owner;
   const target = resolveToolRunTarget(args, "No in-flight runs to quit.", store);
   const action = "quit";
@@ -121151,21 +121456,32 @@ async function workflowQuitAction(args, owner = captureWorkflowOwnerResources())
     const results = await quitAllRuns({ ...owner, actor: "agent" });
     const successes = results.filter((result) => result.ok);
     const quitCount = successes.length;
-    const failures = results.filter((result) => !result.ok);
+    const failedRuns = bulkFailedRuns(results);
+    if (failedRuns.length > 0) {
+      return {
+        action,
+        runId: "--all",
+        ...bulkUnstoppedStatus(results),
+        message: bulkFailureMessage("Quit", action, results, (result) => result.message ?? `${result.runId}: quit${abandonedToolSuffix(result.abandonedTools)}`),
+        failedRuns
+      };
+    }
     return {
       action,
       runId: "--all",
-      status: failures.length > 0 ? quitCount > 0 ? "partial" : "noop" : quitCount > 0 ? "paused" : "noop",
-      message: failures.length > 0 ? bulkQuitFailureMessage(results) : quitCount > 0 ? successes.some((result) => result.message !== undefined) ? successes.map((result) => result.message ?? `Run ${result.runId} quit.`).join(`
+      status: quitCount > 0 ? "paused" : "noop",
+      message: quitCount > 0 ? successes.some((result) => result.message !== undefined) ? successes.map((result) => result.message ?? `Run ${result.runId} quit.`).join(`
 `) : `Quit ${quitCount} run(s); resume with /workflow resume.` : "No in-flight runs to quit."
     };
   }
   if (target.kind === "malformed" || target.kind === "not_found") {
-    return { action, runId: target.target, status: "noop", message: target.message };
+    const foreign = target.kind === "not_found" ? await foreignRunFailure(action, target.target, guard) : undefined;
+    return foreign ?? { action, runId: target.target, status: "noop", message: target.message, code: "run_not_found" };
   }
   const controlNode = resolveControlNodeTarget(target.runId, args.stageId, store);
-  if (!controlNode.ok)
-    return { action, runId: target.runId, status: "noop", message: controlNode.message };
+  if (!controlNode.ok) {
+    return { action, runId: target.runId, status: "noop", message: controlNode.message, code: controlNode.code };
+  }
   if (controlNode.kind === "tool")
     return quitToolNodeAction(controlNode.runId, controlNode.nodeId, action, owner);
   try {
@@ -121178,17 +121494,19 @@ async function workflowQuitAction(args, owner = captureWorkflowOwnerResources())
         message: result.message ?? `Run ${result.runId} quit and can be resumed with /workflow resume.${cancelledToolSummary(result)}`
       };
     }
+    const benign = result.reason === "already_ended" || result.reason === "no_active_stages";
     return {
       action,
       runId: target.runId,
       status: "noop",
-      message: result.reason === "already_ended" ? `Run ${target.runId} already ended.` : result.reason === "no_active_stages" ? `No controllable stages on run ${target.runId}; the run remains active.` : `Run not found: ${target.runId}`
+      message: result.reason === "already_ended" ? `Run ${target.runId} already ended.` : result.reason === "no_active_stages" ? `No controllable stages on run ${target.runId}; the run remains active.` : `Run not found: ${target.runId}`,
+      ...benign ? {} : { code: "run_not_found" }
     };
   } catch (error) {
     return controlFailure(action, target.runId, error);
   }
 }
-async function workflowPauseAction(args, owner = captureWorkflowOwnerResources()) {
+async function workflowPauseAction(args, owner = captureWorkflowOwnerResources(), guard) {
   const { store } = owner;
   const target = resolveToolRunTarget(args, "No in-flight runs to pause.", store);
   const action = "pause";
@@ -121199,12 +121517,24 @@ async function workflowPauseAction(args, owner = captureWorkflowOwnerResources()
     try {
       const results = await pauseAllRuns(owner);
       const paused = results.filter((result) => result.ok).length;
+      const failedRuns = bulkFailedRuns(results);
+      if (failedRuns.length > 0) {
+        return {
+          action,
+          runId: "--all",
+          ...bulkUnstoppedStatus(results),
+          message: bulkFailureMessage("Paused", action, results, (result) => result.message ?? `${result.runId}: paused`),
+          failedRuns
+        };
+      }
+      const alreadyPaused = bulkAlreadyPausedCount(results);
+      const summary = paused > 0 ? `Paused ${paused} run(s)${alreadyPaused > 0 ? `; ${alreadyPaused} already paused` : ""}.` : alreadyPaused > 0 ? `${alreadyPaused} in-flight run(s) already paused.` : "No in-flight runs to pause.";
       return {
         action,
         runId: "--all",
         status: paused > 0 ? "paused" : "noop",
         message: [
-          paused > 0 ? `Paused ${paused} run(s).` : "No in-flight runs to pause.",
+          summary,
           ...results.flatMap((result) => result.ok && result.message !== undefined ? [result.message] : [])
         ].join(`
 `)
@@ -121213,16 +121543,19 @@ async function workflowPauseAction(args, owner = captureWorkflowOwnerResources()
       return controlFailure(action, "--all", error);
     }
   }
-  if (target.kind === "malformed" || target.kind === "not_found")
-    return { action, runId: target.target, status: "noop", message: target.message };
+  if (target.kind === "malformed" || target.kind === "not_found") {
+    const foreign = target.kind === "not_found" ? await foreignRunFailure(action, target.target, guard) : undefined;
+    return foreign ?? { action, runId: target.target, status: "noop", message: target.message, code: "run_not_found" };
+  }
   const controlNode = resolveControlNodeTarget(target.runId, args.stageId, store);
-  if (!controlNode.ok)
-    return { action, runId: target.runId, status: "noop", message: controlNode.message };
+  if (!controlNode.ok) {
+    return { action, runId: target.runId, status: "noop", message: controlNode.message, code: controlNode.code };
+  }
   if (controlNode.kind === "tool")
     return quitToolNodeAction(controlNode.runId, controlNode.nodeId, action, owner);
   const stage = resolveToolStageTarget(target.runId, args.stageId, store);
   if (!stage.ok)
-    return { action, runId: target.runId, status: "noop", message: stage.message };
+    return { action, runId: target.runId, status: "noop", message: stage.message, code: stage.code };
   const stageRunId = stage.runId ?? target.runId;
   try {
     const result = await pauseRun(stageRunId, { ...owner, stageId: stage.stageId });
@@ -121238,7 +121571,9 @@ async function workflowPauseAction(args, owner = captureWorkflowOwnerResources()
       action,
       runId: stageRunId,
       status: "noop",
-      message: stageFailureMessage(stageRunId, result.reason, "pause")
+      message: stageFailureMessage(stageRunId, result.reason, "pause"),
+      ...result.reason === "not_found" ? { code: "run_not_found" } : {},
+      ...result.reason === "stage_not_found" ? { code: "stage_not_found" } : {}
     };
   } catch (error) {
     return controlFailure(action, stageRunId, error);
@@ -121273,7 +121608,8 @@ ${resumed.message}`;
     action: "resume",
     runId: resumed.ok ? resumed.runId : runId,
     status: resumed.ok ? "running" : "noop",
-    message
+    message,
+    ...resumed.ok ? {} : { code: resumeFailureCode(resumed.reason) }
   };
 }
 async function resumePreparedDurableTarget(runId, deps, budget) {
@@ -121291,7 +121627,8 @@ async function resumePreparedDurableTarget(runId, deps, budget) {
       action: "resume",
       runId: resumed.ok ? resumed.runId : runId,
       status: resumed.ok ? "running" : "noop",
-      message: resumed.message
+      message: resumed.message,
+      ...resumed.ok ? {} : { code: resumeFailureCode(resumed.reason) }
     };
   } catch (error) {
     return controlFailure("resume", runId, error);
@@ -121305,7 +121642,8 @@ function refuseStageScopedDurableResume(runId, args) {
     action: "resume",
     runId,
     status: "noop",
-    message: stageScopedDurableResumeMessage(runId)
+    message: stageScopedDurableResumeMessage(runId),
+    code: "stage_resume_unsupported"
   };
 }
 async function resolveExplicitDurableTarget(target, args, deps, liveRuns = []) {
@@ -121331,7 +121669,7 @@ async function resolveExplicitDurableTarget(target, args, deps, liveRuns = []) {
   deps.signal?.throwIfAborted();
   const resolved = resolveWorkflowResumeTarget(target, liveRuns, durable, completed);
   if (resolved.kind === "malformed" || resolved.kind === "ambiguous") {
-    return { action: "resume", runId: target, status: "noop", message: resolved.message };
+    return { action: "resume", runId: target, status: "noop", message: resolved.message, code: "run_not_found" };
   }
   if (resolved.kind === "durable" || resolved.kind === "live" || resolved.kind === "completed")
     deps.authorize?.(resolved.workflowId);
@@ -121349,7 +121687,8 @@ async function resolveExplicitDurableTarget(target, args, deps, liveRuns = []) {
       action: "resume",
       runId: resolved.workflowId,
       status: "noop",
-      message: `Workflow ${resolved.workflowId} is completed, not resumable.`
+      message: `Workflow ${resolved.workflowId} is completed, not resumable.`,
+      code: "not_resumable"
     };
   }
   const durableHandle = getDurableBackend().getWorkflow(target);
@@ -121361,7 +121700,8 @@ async function resolveExplicitDurableTarget(target, args, deps, liveRuns = []) {
       action: "resume",
       runId: target,
       status: "noop",
-      message: `Workflow ${target} has no durable checkpoint or pending prompt progress and is not resumable.`
+      message: `Workflow ${target} has no durable checkpoint or pending prompt progress and is not resumable.`,
+      code: "not_resumable"
     };
   }
   if (durableHandle !== undefined) {
@@ -121370,7 +121710,13 @@ async function resolveExplicitDurableTarget(target, args, deps, liveRuns = []) {
       return refusal;
     return resumePreparedDurableTarget(target, deps, args.budget);
   }
-  return { action: "resume", runId: target, status: "noop", message: `Run not found: ${target}` };
+  return {
+    action: "resume",
+    runId: target,
+    status: "noop",
+    message: `Run not found: ${target}`,
+    code: "run_not_found"
+  };
 }
 async function workflowResumeAction(args, deps) {
   const owner = deps.owner ?? captureWorkflowOwnerResources();
@@ -121385,18 +121731,25 @@ async function workflowResumeAction(args, deps) {
   if (target.kind === "all")
     return { action: "resume", runId: "--all", status: "noop", message: "Resume does not support --all." };
   if (target.kind === "malformed") {
-    return { action: "resume", runId: target.target, status: "noop", message: target.message };
+    return { action: "resume", runId: target.target, status: "noop", message: target.message, code: "run_not_found" };
   }
   if (target.kind === "not_found") {
     if (explicitTarget !== undefined && explicitTarget.length > 0) {
       return resolveExplicitDurableTarget(explicitTarget, args, deps);
     }
-    return { action: "resume", runId: target.target, status: "noop", message: target.message };
+    return { action: "resume", runId: target.target, status: "noop", message: target.message, code: "run_not_found" };
   }
   deps.authorize?.(target.runId);
   const requestedStage = resolveToolStageTarget(target.runId, args.stageId, store);
-  if (!requestedStage.ok)
-    return { action: "resume", runId: target.runId, status: "noop", message: requestedStage.message };
+  if (!requestedStage.ok) {
+    return {
+      action: "resume",
+      runId: target.runId,
+      status: "noop",
+      message: requestedStage.message,
+      code: requestedStage.code
+    };
+  }
   const backend = getDurableBackend();
   const exact = store.runs().find((run) => run.id === target.runId);
   const shadow = exact === undefined ? "not_shadow" : classifyDurableResumeShadow(exact, store, {
@@ -121416,7 +121769,8 @@ async function workflowResumeAction(args, deps) {
       action: "resume",
       runId: target.runId,
       status: "noop",
-      message: `Workflow ${target.runId} has no durable checkpoint or pending prompt progress and is not resumable.`
+      message: `Workflow ${target.runId} has no durable checkpoint or pending prompt progress and is not resumable.`,
+      code: "not_resumable"
     };
   }
   if (toolControlRegistry.runControl(target.runId) === undefined && !backend.isWorkflowLoadable(target.runId)) {
@@ -121432,16 +121786,24 @@ async function workflowResumeAction(args, deps) {
     deps.signal?.throwIfAborted();
     if (!backend.isWorkflowLoadable(target.runId)) {
       store.removeRun(target.runId);
-      return { action: "resume", runId: target.runId, status: "noop", message: `Run not found: ${target.runId}` };
+      return {
+        action: "resume",
+        runId: target.runId,
+        status: "noop",
+        message: `Run not found: ${target.runId}`,
+        code: "run_not_found"
+      };
     }
   }
   let warning;
   const stage = resolveToolStageTarget(target.runId, args.stageId, store);
-  if (!stage.ok)
-    return { action: "resume", runId: target.runId, status: "noop", message: stage.message };
+  if (!stage.ok) {
+    return { action: "resume", runId: target.runId, status: "noop", message: stage.message, code: stage.code };
+  }
   const stageRunId = stage.runId ?? target.runId;
   const run = store.runs().find((candidate) => candidate.id === stageRunId);
   const hadPausedRunState = run?.status === "paused";
+  const endedBeforeResume = run?.endedAt !== undefined;
   const hadPausedStageState = run !== undefined && workflowHasPausedStages(store, stageRunId);
   const isPaused = run !== undefined && workflowHasPausedState(store, stageRunId);
   const isDurableAuthorExit = run?.exited === true && run.status === "failed" && run.resumable === true;
@@ -121473,7 +121835,8 @@ ${continuation.message}`;
       action: "resume",
       runId: continuation.ok ? continuation.runId : stageRunId,
       status: continuation.ok ? "running" : "noop",
-      message
+      message,
+      ...continuation.ok ? {} : { code: resumeFailureCode(continuation.reason) }
     };
   }
   try {
@@ -121489,9 +121852,22 @@ ${continuation.message}`;
       const message = result.message ?? (isPaused ? result.resumed.length === 0 ? runLevelResumed ? `Resumed run ${result.runId}.` : `No paused stages on run ${result.runId}.` : `Resumed ${result.resumed.length} stage(s) on run ${result.runId}${args.message ? ` with message: "${args.message}"` : ""}.` : `Snapshot available: run ${result.runId} (${result.snapshot.name}) — status: ${result.snapshot.status}, stages: ${result.snapshot.stages.length}`);
       const noContinuation = result.mode === "not_resumable" || result.mode === "snapshot" && result.snapshot.status === "blocked";
       const status = result.mode === "partial" ? "partial" : noContinuation || noPausedProgress ? "noop" : "ok";
-      return { action: "resume", runId: result.runId, status, message };
+      const notResumable = result.mode === "not_resumable" || endedBeforeResume && result.mode === "snapshot" && result.snapshot.resumable !== true;
+      return {
+        action: "resume",
+        runId: result.runId,
+        status,
+        message,
+        ...notResumable ? { code: "not_resumable" } : {}
+      };
     }
-    return { action: "resume", runId: stageRunId, status: "noop", message: `Run not found: ${stageRunId}` };
+    return {
+      action: "resume",
+      runId: stageRunId,
+      status: "noop",
+      message: `Run not found: ${stageRunId}`,
+      code: "run_not_found"
+    };
   } catch (error) {
     return resumeControlFailure(stageRunId, error, store);
   }
@@ -121957,11 +122333,11 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
       case "answer":
         return awaitRequest(workflowAnswerAction(args, owner));
       case "pause":
-        return awaitRequest(workflowPauseAction(args, owner));
+        return awaitRequest(workflowPauseAction(args, owner, { getRuntime, authorize }));
       case "reload":
         return awaitRequest(workflowReloadAction(args, { reloadWorkflowResources }));
       case "quit":
-        return awaitRequest(workflowQuitAction(args, owner));
+        return awaitRequest(workflowQuitAction(args, owner, { getRuntime, authorize }));
       case "resume":
         return awaitRequest(workflowResumeAction(args, {
           getRuntime,
@@ -122587,6 +122963,14 @@ function factory(pi) {
   const storeWidgetRef = { current: null };
   const intercomControlRef = { current: null };
   const executeWorkflowTool = makeExecuteWorkflowTool((ctx) => runtimeState.runtimeForContext(ctx), runtimeState.reloadWorkflowResources, runtimeState.ensureWorkflowResourcesLoaded, owner);
+  let sessionContext;
+  pi.on?.("session_start", (_event, ctx) => {
+    sessionContext = ctx;
+  });
+  pi.on?.("session_shutdown", () => {
+    sessionContext = undefined;
+  });
+  pi.registerWorkflowRunControl?.(createSessionRunControl({ execute: executeWorkflowTool, context: () => sessionContext, store: owner.store }));
   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) {