@bastani/atomic 0.9.34 → 0.9.35-alpha.2

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [0.9.35-alpha.2] - 2026-10-12
+
+### Fixed
+
+- Fixed `read` reporting success when it refuses a selected range as too large. The refusal is now an error result, so models see a failed read with guidance to read a smaller range, and code mode's `tools.read(...)` throws instead of resolving with the refusal text as if it were the file's contents ([#3574](https://github.com/bastani-inc/atomic/issues/3574)).
+
+## [0.9.35-alpha.1] - 2026-10-12
+
+### Added
+
+- `session.workflows.resume(runId)` now adopts a paused run that was launched through the model-facing `workflow` tool once its owning session has been disposed, in the same process or after the owning process exits. Disposing a session quits its in-flight runs at their last checkpoint and durably records that it released its checkpointed paused runs; the adopting session becomes the owner and the run continues under the same UUID. Runs whose owner is still open, runs whose owner crashed without disposing, and finished runs are still refused ([#3566](https://github.com/bastani-inc/atomic/issues/3566)).
+- Switching sessions with `/new`, `/fork`, or `/resume` now releases the previous session's paused workflow runs, the same way disposing a session does. The model in the new session can inspect them with the `workflow` tool's `status` and `stages` actions and resume them, and `session.workflows.resume(runId)` can adopt them; adoption, including the `/workflow resume <id>` slash command, transfers ownership to the resuming session. The new session lists the released runs with their `/workflow resume <id>` commands, and, in the process that released it, a run another session already adopted now reports that it is owned by another session. `/reload` still keeps runs executing and releases nothing ([#3569](https://github.com/bastani-inc/atomic/issues/3569)).
+
+### Changed
+
+- Changed `serializeConversation()` (branch summaries, resume-picker session summaries, and the policy-refusal summary fallback) to omit thinking blocks; replayed thinking is often not in the live context, so including it could make a summarization request larger than the context it summarizes and fail. Verbatim line compaction still serializes thinking lines.
+- Changed `openai-codex/gpt-6.1-sol` to a 500,000-token context window (up from 272,000) with no long-context price tier on Standard, Fast, or Ultrafast. OpenAI raised GPT-6.1 Sol's default context to 500k in Codex & Work for ChatGPT subscriptions and does not charge long-context fees when usage draws from the subscription. `openai/gpt-6.1-sol` and the other Codex models are unchanged.
+
+### Fixed
+
+- Fixed the code mode tool description claiming every failed tool call throws; a tool that declares an output schema resolves with its value on failure too (for example `bash` with a non-zero exit), so scripts should check its fields.
+
 ## [0.9.34] - 2026-10-11
 
 ### Fixed

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.34",
+  "version": "0.9.35-alpha.2",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.35-alpha.1] - 2026-10-12
+
+### Fixed
+
+- Fixed OAuth exchanging an authorization code whose `iss` parameter could not be checked because no authorization server metadata was discovered. It now throws `OAuthIssuerMismatchError`, whose `expected` is `undefined` in that case (RFC 9207). Reported by [@AizenvoltPrime](https://github.com/AizenvoltPrime).
+
 ## [0.9.28] - 2026-10-08
 
 ### Fixed

package/dist/builtin/mcp/OAUTH.md

@@ -71,7 +71,7 @@ Atomic normally finds the authorization server through protected resource metada
 
 The document may use RFC 8414 or OpenID Connect discovery. Atomic trusts it as configured, including its issuer, so only point it at a document you trust. The URL must use HTTPS except for HTTP on `localhost`, `127.0.0.1`, or `[::1]`.
 
-An authorization response's `iss` must name the flow's authorization server. If the metadata promises `authorization_response_iss_parameter_supported`, the response must include `iss`. Mismatched or required-but-missing issuers are rejected before code exchange under RFC 9207. Pasted redirect URLs have the same checks as browser callbacks.
+An authorization response's `iss` must name the flow's authorization server. If the metadata promises `authorization_response_iss_parameter_supported`, the response must include `iss`. Mismatched or required-but-missing issuers are rejected before code exchange under RFC 9207, and when no authorization server metadata was discovered any `iss` is rejected because there is no issuer to compare it with. Pasted redirect URLs have the same checks as browser callbacks.
 
 ## Tokens and refresh
 

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.34",
+  "version": "0.9.35-alpha.2",
   "private": true,
   "description": "Atomic's pi-compatible MCP integration for server connections, OAuth, tools, resources, and terminal management.",
   "contributors": [

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.34",
+  "version": "0.9.35-alpha.2",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with parallel execution. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.34",
+  "version": "0.9.35-alpha.2",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.35-alpha.1] - 2026-10-12
+
+### Added
+
+- `session.workflows.resume(runId)` now adopts a paused run that was launched through the model-facing `workflow` tool once its owning session has been disposed, in the same process or after the owning process exits. Disposing a session quits its in-flight runs at their last checkpoint and durably records that it released its checkpointed paused runs; the adopting session becomes the owner and the run continues under the same UUID. Runs whose owner is still open, runs whose owner crashed without disposing, and finished runs are still refused ([#3566](https://github.com/bastani-inc/atomic/issues/3566)).
+- Switching sessions with `/new`, `/fork`, or `/resume` now releases the previous session's paused workflow runs, the same way disposing a session does. The model in the new session can inspect them with the `workflow` tool's `status` and `stages` actions and resume them, and `session.workflows.resume(runId)` can adopt them; adoption, including the `/workflow resume <id>` slash command, transfers ownership to the resuming session. The new session lists the released runs with their `/workflow resume <id>` commands, and, in the process that released it, a run another session already adopted now reports that it is owned by another session. `/reload` still keeps runs executing and releases nothing ([#3569](https://github.com/bastani-inc/atomic/issues/3569)).
+
+### Fixed
+
+- Fixed an SDK session started after another session in the same process was disposed falling back to non-durable workflows with `Managed Postgres health observer is stopped.`. Releasing the last session now discards the stopped workflow database configuration, so the next session starts a fresh managed Postgres and launches durably ([#3565](https://github.com/bastani-inc/atomic/issues/3565)).
+
 ## [0.9.33] - 2026-10-10
 
 ### Fixed

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.34",
+  "version": "0.9.35-alpha.2",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [

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

@@ -1001,6 +1001,7 @@ class InMemoryDurableBackend {
       ...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,
+      ...handle.releasedModelOwner !== undefined ? { releasedModelOwner: handle.releasedModelOwner } : {},
       ...handle.workflowCwd !== undefined ? { workflowCwd: handle.workflowCwd } : existing?.handle.workflowCwd !== undefined ? { workflowCwd: existing.handle.workflowCwd } : {},
       ...handle.repositoryRoot !== undefined ? { repositoryRoot: handle.repositoryRoot } : existing?.handle.repositoryRoot !== undefined ? { repositoryRoot: existing.handle.repositoryRoot } : {},
       ...handle.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: handle.gitWorktreeRoot } : existing?.handle.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: existing.handle.gitWorktreeRoot } : {},
@@ -1214,14 +1215,20 @@ class InMemoryDurableBackend {
     if (pendingPrompts !== undefined)
       this.promptReservations.delete(workflowId);
   }
-  async transitionWorkflowStatus(workflowId, expected, status, pendingPrompts, resumable, expectedUpdatedAt, modelOwner) {
+  async transitionWorkflowStatus(workflowId, expected, status, pendingPrompts, resumable, expectedUpdatedAt, modelOwner, releasedModelOwner) {
     const record = this.workflows.get(workflowId);
     const current = record?.handle;
     if (current === undefined || !expected.includes(current.status) || expectedUpdatedAt !== undefined && current.updatedAt !== expectedUpdatedAt)
       return false;
     this.setWorkflowStatus(workflowId, status, pendingPrompts, resumable);
-    if (modelOwner !== undefined && record !== undefined)
-      record.handle = { ...record.handle, modelOwner };
+    if (record !== undefined) {
+      const { releasedModelOwner: _previousRelease, ...settled } = record.handle;
+      record.handle = {
+        ...settled,
+        ...modelOwner !== undefined ? { modelOwner } : {},
+        ...releasedModelOwner !== undefined ? { releasedModelOwner } : {}
+      };
+    }
     return true;
   }
   adjustPendingPrompts(workflowId, delta) {
@@ -1303,6 +1310,7 @@ class InMemoryDurableBackend {
       ...h.invocationCwd !== undefined ? { invocationCwd: h.invocationCwd } : {},
       ...h.origin !== undefined ? { origin: h.origin } : {},
       modelOwner: h.modelOwner,
+      ...h.releasedModelOwner !== undefined ? { releasedModelOwner: h.releasedModelOwner } : {},
       ...h.workflowCwd !== undefined ? { workflowCwd: h.workflowCwd } : {},
       ...h.repositoryRoot !== undefined ? { repositoryRoot: h.repositoryRoot } : {},
       ...h.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: h.gitWorktreeRoot } : {},
@@ -4344,6 +4352,7 @@ function encodeMetadata(metadata) {
       ...metadata.failedToolNodeId !== undefined ? { failedToolNodeId: metadata.failedToolNodeId } : {},
       ...metadata.origin !== undefined ? { origin: metadata.origin } : {},
       modelOwner: metadata.modelOwner,
+      ...metadata.releasedModelOwner !== undefined ? { releasedModelOwner: metadata.releasedModelOwner } : {},
       ...metadata.invocationCwd !== undefined ? { invocationCwd: metadata.invocationCwd } : {},
       ...metadata.workflowCwd !== undefined ? { workflowCwd: metadata.workflowCwd } : {},
       ...metadata.repositoryRoot !== undefined ? { repositoryRoot: metadata.repositoryRoot } : {},
@@ -4392,7 +4401,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.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.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 {
@@ -36438,7 +36447,9 @@ async function configureDbosDurableBackend(config) {
     throw new Error("Existing workflow executor has no database ownership fence; restart the host before recovering workflows");
   let launch = owner.active?.launch ?? (() => sdk.launch());
   let checkReady;
-  if (existing === undefined) {
+  if (existing === undefined || owner.active === undefined) {
+    if (owner.executorFence?.closed)
+      owner.executorId = undefined;
     const url = effectiveSystemDatabaseUrl(config?.systemDatabaseUrl);
     await Promise.resolve().then(() => init_dbos_admission_config());
     const database = configureAdmissionDatabase(sdk, {
@@ -36918,7 +36929,7 @@ class DbosDurableBackend {
       await this.writeMetadata(workflowId);
     });
   }
-  async transitionWorkflowStatus(workflowId, expected, status, pendingPrompts, resumable, expectedUpdatedAt, modelOwner) {
+  async transitionWorkflowStatus(workflowId, expected, status, pendingPrompts, resumable, expectedUpdatedAt, modelOwner, releasedModelOwner) {
     this.ensureGeneration();
     let records = [];
     const transition = () => transitionDbosWorkflowStatus({
@@ -36935,13 +36946,14 @@ class DbosDurableBackend {
         const pendingPrompts = this.promptReservations.hydrate(workflowId, entry.pendingPrompts, records, entry.promptReservationEpoch);
         this.applyMetadata(workflowId, { ...entry, pendingPrompts });
       },
-      claim: (authoritative, generation) => this.claimStatusTransition(workflowId, authoritative, generation, status, pendingPrompts, resumable, modelOwner),
+      claim: (authoritative, generation) => this.claimStatusTransition(workflowId, authoritative, generation, status, pendingPrompts, resumable, modelOwner, releasedModelOwner),
       write: async () => {
         const handle = this.mem.getWorkflow(workflowId);
         if (handle !== undefined)
           this.mem.registerWorkflow({
             ...handle,
             legacyRecoveryPending: undefined,
+            releasedModelOwner,
             ...modelOwner !== undefined ? { modelOwner } : {}
           }, true);
         this.setWorkflowStatus(workflowId, status, pendingPrompts, resumable);
@@ -36953,7 +36965,7 @@ class DbosDurableBackend {
     await this.flush(workflowId);
     return await this.sdk.withWorkflowClaim(workflowId, transition);
   }
-  async claimStatusTransition(workflowId, authoritative, generation, status, pendingPrompts, resumable, modelOwner) {
+  async claimStatusTransition(workflowId, authoritative, generation, status, pendingPrompts, resumable, modelOwner, releasedModelOwner) {
     const stepName = claimMetadataStepName(generation);
     const transitionClaimId = crypto.randomUUID();
     const claim = {
@@ -36962,6 +36974,7 @@ class DbosDurableBackend {
       ...pendingPrompts !== undefined ? { pendingPrompts } : {},
       ...resumable !== undefined ? { resumable } : {},
       ...modelOwner === undefined ? {} : { modelOwner },
+      releasedModelOwner,
       legacyRecoveryPending: undefined,
       ownerExecutorId: this.executorId,
       transitionClaimId,
@@ -40577,8 +40590,11 @@ async function shutdownDbos() {
     }
     if (errors.length > 0)
       throw combinedShutdownFailure(errors);
-    if (wasReady)
+    if (wasReady) {
       slot.state = "shut_down";
+      slot.configured = undefined;
+      slot.active = undefined;
+    }
   })().catch(async (error) => {
     slot.failure = await durabilityFailure("shutdown", error);
     slot.state = "failed";
@@ -91770,6 +91786,44 @@ init_dbos_lifecycle();
 init_factory();
 import { registerExtensionContextRetirementEffect, sessionScopedExtensionState as sessionScopedExtensionState2 } from "@bastani/atomic";
 
+// dist/builtin/workflows/src/durable/sdk-owner-release.ts
+var releasedRuns = new WeakMap;
+async function releasePausedRunsOwnedBy(backend, modelOwner) {
+  const settled = await Promise.allSettled(backend.listResumableWorkflows().filter((entry) => entry.status === "paused" && entry.modelOwner === modelOwner).map(async (entry) => {
+    const released = await backend.transitionWorkflowStatus(entry.workflowId, ["paused"], "paused", undefined, undefined, undefined, undefined, modelOwner);
+    return released ? entry.workflowId : undefined;
+  }));
+  const failures = settled.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+  if (failures.length > 0)
+    throw new AggregateError(failures, failures.map(String).join("; "));
+  const releasedIds = settled.flatMap((result) => result.status === "fulfilled" && result.value !== undefined ? [result.value] : []);
+  let remembered = releasedRuns.get(backend);
+  if (remembered === undefined) {
+    remembered = new Set;
+    releasedRuns.set(backend, remembered);
+  }
+  for (const runId of releasedIds)
+    remembered.add(runId);
+  return releasedIds;
+}
+async function reclaimReleasedRunsOwnedBy(backend, modelOwner) {
+  const settled = await Promise.allSettled(backend.listResumableWorkflows().filter((entry) => entry.status === "paused" && entry.modelOwner === modelOwner).flatMap((entry) => {
+    const handle = backend.getWorkflow(entry.workflowId);
+    return handle?.releasedModelOwner === modelOwner ? [handle] : [];
+  }).map(async (handle) => {
+    const reclaimed = await backend.transitionWorkflowStatus(handle.workflowId, ["paused"], "paused", undefined, undefined, handle.updatedAt);
+    if (reclaimed)
+      releasedRuns.get(backend)?.delete(handle.workflowId);
+  }));
+  const failures = settled.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+  if (failures.length > 0)
+    throw new AggregateError(failures, failures.map(String).join("; "));
+}
+var FOREIGN_INSTANCE_MESSAGE = "Workflow instance belongs to another caller/session.";
+function foreignInstanceMessage(backend, runId) {
+  return releasedRuns.get(backend)?.has(runId) === true && backend.getWorkflow(runId)?.releasedModelOwner === undefined ? `Workflow ${runId} is now owned by another session; it was already adopted after its previous session was switched away.` : FOREIGN_INSTANCE_MESSAGE;
+}
+
 // dist/builtin/workflows/src/durable/sdk-recovery-scope.ts
 init_dbos_owner_fence();
 init_dbos_sdk_handle();
@@ -91790,6 +91844,12 @@ function isSdkDurableRunInScope(handle, cwd) {
 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";
 }
+function isSdkReleasedRunAdoptable(handle, cwd) {
+  return isSdkDurableRunInScope(handle, cwd) && handle.status === "paused" && handle.releasedModelOwner !== undefined && handle.releasedModelOwner === handle.modelOwner;
+}
+function isSdkRunAdoptable(handle, cwd) {
+  return isSdkCrashedRunAdoptable(handle, cwd) || isSdkReleasedRunAdoptable(handle, cwd);
+}
 
 // dist/builtin/workflows/src/engine/run-durable-admission.ts
 init_dbos_admission();
@@ -93721,6 +93781,9 @@ async function markDurableQuit(runId, run, resumable = true) {
   if (backend === undefined)
     return "not_needed";
   await backend.settleWorkflowAdmission?.(runId);
+  const durable = backend.getWorkflow(runId);
+  if (durable?.status === "paused" && durable.releasedModelOwner !== undefined)
+    return "not_needed";
   const transitioned = await transitionDurableWorkflowStatus(backend, runId, ["running", "paused"], "paused", undefined, resumable);
   if (!transitioned)
     return "refused";
@@ -109350,8 +109413,8 @@ async function resumeDurableWorkflowClaimed(workflowId, deps, catalog) {
   }
   const requestedOwner = deps.baseRunOpts.modelOwner;
   const adopting = requestedOwner !== undefined && requestedOwner !== handle.modelOwner && (handle.modelOwner !== undefined || handle.origin === "agent");
-  if (adopting && !isSdkCrashedRunAdoptable(handle, deps.baseRunOpts.cwd)) {
-    return { ok: false, reason: "owned_elsewhere", message: "Workflow instance belongs to another caller/session." };
+  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 (def === undefined) {
@@ -110528,6 +110591,61 @@ function openWorkflowResumeSelector(ui, liveRuns, hydrate, options = {}) {
   });
 }
 
+// dist/builtin/workflows/src/extension/workflow-instance-owner.ts
+init_factory();
+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)
+    return sessionId;
+  const caller = ctx.sessionManager ?? ctx;
+  let id = anonymousCallers.get(caller);
+  if (id === undefined) {
+    id = crypto.randomUUID();
+    anonymousCallers.set(caller, id);
+  }
+  return id;
+}
+function assertWorkflowInstanceOwner(id, ctx, store) {
+  const runs = store.runs();
+  const backend = getDurableBackend();
+  const seen = new Set;
+  const assertOne = (runId) => {
+    if (seen.has(runId))
+      return;
+    seen.add(runId);
+    const local = runs.find((run) => run.id === runId);
+    const durable = backend.getWorkflow(runId);
+    const modelOwner = durable?.modelOwner ?? local?.modelOwner;
+    if (modelOwner !== undefined) {
+      if (modelOwner !== workflowCaller(ctx))
+        throw new WorkflowInstanceOwnershipError(foreignInstanceMessage(backend, runId));
+    } else if ((durable?.origin ?? local?.origin) === "agent") {
+      throw new WorkflowInstanceOwnershipError("Workflow instance ownership is unavailable; another caller cannot assume authority.");
+    }
+    const parentId = durable?.rootWorkflowId ?? local?.parentRunId;
+    if (parentId !== undefined)
+      assertOne(parentId);
+  };
+  assertOne(id);
+  const descendants = [id];
+  for (const parentId of descendants) {
+    for (const run of runs) {
+      if (run.parentRunId !== parentId || descendants.includes(run.id))
+        continue;
+      assertOne(run.id);
+      descendants.push(run.id);
+    }
+  }
+}
+
 // dist/builtin/workflows/src/shared/types.ts
 var INTERACTIVE_WORKFLOW_POLICY = Object.freeze({
   mode: "interactive",
@@ -110605,7 +110723,11 @@ async function handleDurableResume(target, ctx, reporter, deps, preparedCatalog)
       fail(completedAttempt.message);
       return true;
     }
-    const result = await runtime.resumeDurableWorkflow(target, { policy, actor: "user" });
+    const result = await runtime.resumeDurableWorkflow(target, {
+      policy,
+      actor: "user",
+      ...releasedRunAdoption("workflowId" in resolved ? resolved.workflowId : target, ctx)
+    });
     if (result.ok) {
       print(result.message);
       if (policy.allowInputPicker)
@@ -110680,10 +110802,15 @@ function isExplicitResumeCandidate(run, sessionRuns) {
     return true;
   return isWorkflowRunResumable(workflowRunResumeCandidate(run, sessionRuns)) || run.endedAt === undefined && run.status === "running";
 }
+function releasedRunAdoption(workflowId, ctx) {
+  const handle = getDurableBackend().getLoadableWorkflow(workflowId);
+  return handle !== undefined && isSdkReleasedRunAdoptable(handle, ctx.cwd) ? { modelOwner: workflowCaller(ctx) } : {};
+}
 async function resumeDurableTarget(workflowId, ctx, reporter, deps, runtime) {
   const result = await runtime.resumeDurableWorkflow(workflowId, {
     policy: workflowPolicyFromContext(ctx),
-    actor: "user"
+    actor: "user",
+    ...releasedRunAdoption(workflowId, ctx)
   });
   if (!result.ok)
     reporter.error(result.message);
@@ -110715,61 +110842,6 @@ function openCompleted(runtime, workflowId, catalog, beforeRestoreCompleted, sto
   }, catalog);
 }
 
-// dist/builtin/workflows/src/extension/workflow-instance-owner.ts
-init_factory();
-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)
-    return sessionId;
-  const caller = ctx.sessionManager ?? ctx;
-  let id = anonymousCallers.get(caller);
-  if (id === undefined) {
-    id = crypto.randomUUID();
-    anonymousCallers.set(caller, id);
-  }
-  return id;
-}
-function assertWorkflowInstanceOwner(id, ctx, store) {
-  const runs = store.runs();
-  const backend = getDurableBackend();
-  const seen = new Set;
-  const assertOne = (runId) => {
-    if (seen.has(runId))
-      return;
-    seen.add(runId);
-    const local = runs.find((run) => run.id === runId);
-    const durable = backend.getWorkflow(runId);
-    const modelOwner = durable?.modelOwner ?? local?.modelOwner;
-    if (modelOwner !== undefined) {
-      if (modelOwner !== workflowCaller(ctx))
-        throw new WorkflowInstanceOwnershipError("Workflow instance belongs to another caller/session.");
-    } else if ((durable?.origin ?? local?.origin) === "agent") {
-      throw new WorkflowInstanceOwnershipError("Workflow instance ownership is unavailable; another caller cannot assume authority.");
-    }
-    const parentId = durable?.rootWorkflowId ?? local?.parentRunId;
-    if (parentId !== undefined)
-      assertOne(parentId);
-  };
-  assertOne(id);
-  const descendants = [id];
-  for (const parentId of descendants) {
-    for (const run of runs) {
-      if (run.parentRunId !== parentId || descendants.includes(run.id))
-        continue;
-      assertOne(run.id);
-      descendants.push(run.id);
-    }
-  }
-}
-
 // dist/builtin/workflows/src/extension/extension-lifecycle.ts
 var startupRecoveries = new Set;
 function trackStartupRecovery(recovery) {
@@ -110809,6 +110881,18 @@ function sessionSwitchQuitConfirmation(reason, inFlightWorkflowCount) {
     message: `Continuing quits ${runs} now. ${pronoun} stops at its last checkpoint and can be resumed later with /workflow resume.`
   };
 }
+async function releasePausedRunsOfSession(sessionCaller) {
+  const backend = getAvailableDurableBackend();
+  return sessionCaller !== undefined && backend !== undefined ? releasePausedRunsOwnedBy(backend, sessionCaller) : [];
+}
+function releasedRunsNotice(runs) {
+  const count = runs.length === 1 ? "1 workflow run" : `${runs.length} workflow runs`;
+  return [
+    `Released ${count} from the previous session. Resume ${runs.length === 1 ? "it" : "any"} here:`,
+    ...runs.map((run) => `  /workflow resume ${run.id}  (${run.name})`)
+  ].join(`
+`);
+}
 function eventReason(event) {
   return typeof event === "object" && event !== null && "reason" in event ? event.reason : undefined;
 }
@@ -110958,9 +111042,31 @@ function registerWorkflowLifecycleHandlers(pi, deps) {
     if (errors.length)
       throw new AggregateError(errors, "Workflow observation retirement failed");
   };
+  let sessionCaller;
+  let switchHandoff;
+  const handOffRunsToSuccessor = () => {
+    switchHandoff ??= attemptAll([
+      ...[...lifetime.generations].map((quitRuns) => () => quitRuns("switch")),
+      async () => {
+        const released = await releasePausedRunsOfSession(sessionCaller);
+        lifetime.releasedRunIds = [...new Set([...lifetime.releasedRunIds ?? [], ...released])];
+      },
+      flushDbos
+    ]);
+    lifetime.activeSwitchHandoff = switchHandoff;
+    return switchHandoff;
+  };
   pi.on("session_start", async (event, ctx) => {
-    if (ctx)
+    const departingHandoff = lifetime.pendingSwitchHandoff;
+    lifetime.pendingSwitchHandoff = handOffRunsToSuccessor;
+    if (ctx) {
       registerExtensionContextRetirementEffect(ctx, closeObservation);
+      sessionCaller = workflowCaller(ctx);
+    }
+    if (isSessionSwitch(eventReason(event)) && departingHandoff !== undefined && lifetime.closing === undefined)
+      await departingHandoff().catch(() => {
+        return;
+      });
     lifetime.release ??= getDurableBackendProcessOwner().injectedBackend === undefined ? acquireDbosLease() : async () => {};
     const reason = typeof event === "object" && event !== null && "reason" in event ? event.reason : undefined;
     const stopsWorkflows = replacementStopsWorkflows(reason) && !(reason === "startup" && lifetime.startupStarted);
@@ -110989,6 +111095,28 @@ function registerWorkflowLifecycleHandlers(pi, deps) {
       deps.storeWidgetRef.current?.();
       deps.storeWidgetRef.current = installStoreWidget({ ui: ctx.ui }, store);
     }
+    if (isSessionSwitch(reason) && sessionCaller !== undefined) {
+      const backend = getAvailableDurableBackend();
+      if (backend !== undefined)
+        await reclaimReleasedRunsOwnedBy(backend, sessionCaller).catch(() => {
+          return;
+        });
+    }
+    if (reason !== "reload") {
+      const releasedRunIds = lifetime.releasedRunIds;
+      lifetime.releasedRunIds = undefined;
+      if (isSessionSwitch(reason) && releasedRunIds !== undefined && releasedRunIds.length > 0) {
+        const backend = getAvailableDurableBackend();
+        const cwd = ctx?.cwd ?? ctx?.sessionManager?.getCwd?.() ?? runtimeState.resolveInvocationCwd();
+        const adoptable = releasedRunIds.flatMap((runId) => {
+          const handle = backend?.getWorkflow(runId);
+          return handle !== undefined && isSdkReleasedRunAdoptable(handle, cwd) ? [{ id: runId, name: handle.name }] : [];
+        });
+        lifetime.releasedRunIds = adoptable.map((run) => run.id);
+        if (adoptable.length > 0)
+          ctx?.ui?.notify?.(releasedRunsNotice(adoptable), "info");
+      }
+    }
     runtimeState.updateHostStageSessionDir(ctx?.sessionManager ?? pi.sessionManager);
     const generation = ++recoveryGeneration;
     if (stopsWorkflows)
@@ -111011,8 +111139,12 @@ function registerWorkflowLifecycleHandlers(pi, deps) {
     const closeGeneration = closeObservation;
     if (replacementStopsWorkflows(reason)) {
       lifetime.closing ??= attemptAll([
+        () => lifetime.activeSwitchHandoff?.catch(() => {
+          return;
+        }),
         closeGeneration,
         ...lifetime.generations,
+        () => releasePausedRunsOfSession(sessionCaller),
         () => {
           lifetime.generations.clear();
         },
@@ -111020,11 +111152,7 @@ function registerWorkflowLifecycleHandlers(pi, deps) {
       ]);
       await lifetime.closing;
     } else if (isSessionSwitch(reason)) {
-      await attemptAll([
-        closeGeneration,
-        ...[...lifetime.generations].map((quitRuns) => () => quitRuns("switch")),
-        flushDbos
-      ]);
+      await attemptAll([closeGeneration, handOffRunsToSuccessor]);
     } else {
       await attemptAll([closeGeneration, () => stageControlRegistry.clearDetached(), flushDbos]);
     }
@@ -124493,8 +124621,14 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
       };
     }
     const recoveryCwd = typeof ctx.cwd === "string" ? ctx.cwd : undefined;
+    const adoptsReleasedRun = (id) => {
+      const handle = getDurableBackend().getLoadableWorkflow(id);
+      return handle !== undefined && isSdkReleasedRunAdoptable(handle, recoveryCwd);
+    };
     const authorize = (id) => {
       const handle = getDurableBackend().getLoadableWorkflow(id);
+      if ((action === "resume" || action === "status" || action === "stages") && handle !== undefined && isSdkReleasedRunAdoptable(handle, recoveryCwd))
+        return;
       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);
@@ -124516,11 +124650,9 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
     const awaitRequest = (operation) => raceAbort(operation, signal);
     const getRuntime = () => {
       const resolved = typeof runtime === "function" ? runtime(ctx) : runtime;
-      if (access !== "sdk")
-        return resolved;
       return {
         ...resolved,
-        resumeDurableWorkflow: (id, options) => resolved.resumeDurableWorkflow(id, { ...options, modelOwner: workflowCaller(ctx) })
+        resumeDurableWorkflow: (id, options) => resolved.resumeDurableWorkflow(id, access === "sdk" || adoptsReleasedRun(id) ? { ...options, modelOwner: workflowCaller(ctx) } : options)
       };
     };
     const ensureWorkflowResourcesVisible = async () => {