@bastani/atomic 0.9.58-alpha.1 → 0.9.59-alpha.1

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [0.9.59] - 2026-11-01
+
+GitHub Copilot tokens that work from `/login`, and intercom that recovers on Windows.
+
+- **Copilot tokens saved through `/login`:** a GitHub Copilot personal access token saved with `/login` → **Use an API key** now works for business and enterprise accounts, so you no longer need `COPILOT_GITHUB_TOKEN` to avoid `421 Misdirected Request` ([#4151](https://github.com/bastani-inc/atomic/pull/4151))
+- **Intercom recovers on Windows:** when the intercom broker dies, sessions start a new one right away instead of waiting out the start-up timeout and failing with `Broker failed to start within timeout` ([#4152](https://github.com/bastani-inc/atomic/pull/4152))
+
+### Fixed
+
+- Fixed GitHub Copilot personal access tokens saved through `/login` → **Use an API key** being sent to the individual Copilot host, where business and enterprise accounts fail with `421 Misdirected Request`. Saved tokens now get the same endpoint routing as `COPILOT_GITHUB_TOKEN`, so the environment variable is no longer required. A `models.json` `baseUrl` still takes precedence, and OAuth logins are unchanged. ([#4151](https://github.com/bastani-inc/atomic/pull/4151))
+
+## [0.9.59-alpha.1] - 2026-11-01
+
+GitHub Copilot tokens that work from `/login`, and intercom that recovers on Windows.
+
+- **Copilot tokens saved through `/login`:** a GitHub Copilot personal access token saved with `/login` → **Use an API key** now works for business and enterprise accounts, so you no longer need `COPILOT_GITHUB_TOKEN` to avoid `421 Misdirected Request` ([#4151](https://github.com/bastani-inc/atomic/pull/4151))
+- **Intercom recovers on Windows:** when the intercom broker dies, sessions start a new one right away instead of waiting out the start-up timeout and failing with `Broker failed to start within timeout` ([#4152](https://github.com/bastani-inc/atomic/pull/4152))
+
+### Fixed
+
+- Fixed GitHub Copilot personal access tokens saved through `/login` → **Use an API key** being sent to the individual Copilot host, where business and enterprise accounts fail with `421 Misdirected Request`. Saved tokens now get the same endpoint routing as `COPILOT_GITHUB_TOKEN`, so the environment variable is no longer required. A `models.json` `baseUrl` still takes precedence, and OAuth logins are unchanged. ([#4151](https://github.com/bastani-inc/atomic/pull/4151))
+
 ## [0.9.58] - 2026-11-01
 
 Task heartbeats, stage chats that work on local workers, and a local worker pool that holds up under load.
@@ -11,6 +33,7 @@ Task heartbeats, stage chats that work on local workers, and a local worker pool
 - **A local worker pool that holds up under load:** reloading workflows or starting other runs no longer fails a running root's children with `Stale lease for run <id>`, a busy machine no longer fails stages on delivery or lease errors, `/workflow pause` pauses a root's stages even while its own steps run, and an overloaded machine starts stages one at a time, tunable with `workflows.localWorkers.maxLoadPerCpu` ([#4138](https://github.com/bastani-inc/atomic/pull/4138), [#4145](https://github.com/bastani-inc/atomic/pull/4145), [#4146](https://github.com/bastani-inc/atomic/pull/4146))
 - **Resuming pooled runs:** a root that runs children on local workers resumes from a new process, including one paused or failed by 0.9.57, and runs again the children that failed on a pool fault instead of replaying the failure ([#4146](https://github.com/bastani-inc/atomic/pull/4146))
 - **Stopped tasks finish:** a shell stopped with `kill`, from `/tasks` or with Esc no longer stays "stopping" in the Tasks indicator forever; it ends as failed with the resource that could not be cleaned up ([#4142](https://github.com/bastani-inc/atomic/pull/4142))
+- **Subagents that start and run as asked:** a subagent launched with an effort such as `model: "openai/gpt-5.5:xhigh"`, or from a chat turn that a workflow started, no longer stays `running` with no session, and one whose session still does not start within 5 minutes fails with the cause. An effort applies exactly where the model supports it, including on a fallback that starts in place of the requested model, and `status` lists only the children your session launched ([#4148](https://github.com/bastani-inc/atomic/pull/4148), [#4150](https://github.com/bastani-inc/atomic/pull/4150))
 - **Quieter PDF fetches:** pdf.js font warnings such as `Warning: TT: undefined function: 32` no longer print over the terminal UI when a PDF is fetched ([#4136](https://github.com/bastani-inc/atomic/pull/4136))
 
 ### Added
@@ -27,6 +50,10 @@ Task heartbeats, stage chats that work on local workers, and a local worker pool
 - `/workflow pause` pauses a root's stages on local workers even while the root's own steps run, instead of reporting `No active stages to pause`, and pause or resume no longer fails with `Worker control acknowledgement unresolved` on a busy machine; the result says how many stages have not confirmed the pause yet. ([#4145](https://github.com/bastani-inc/atomic/pull/4145))
 - Resuming a workflow root that runs children on local workers, including one paused or failed by 0.9.57, runs again the children an earlier process failed on a fault of the pool itself instead of replaying their failure, and a paused root with durable progress says it can be resumed from a new process. ([#4146](https://github.com/bastani-inc/atomic/pull/4146))
 - On an overloaded machine, stages of workflow children on local workers start one at a time, at most one every 5 seconds, instead of all at once while earlier ones are still starting. Tune or turn off with `workflows.localWorkers.maxLoadPerCpu` (default `3`, `0` off). ([#4146](https://github.com/bastani-inc/atomic/pull/4146))
+- A subagent launched from a chat turn that a running workflow started, for example with its completion notice, no longer stays `running` for good with no session, transcript or Intercom name. Its session waited for a permit from that workflow's resource admission (such as `admission.host.minFreeMemoryBytes` on a busy host) that it never received. A child session built from `getChildSessionOptions()` now takes its parent's admission or none, never one a `withResourceAdmission` scope the parent's turn happened to run in; SDK callers can pass `resourceAdmission: null` for a session that takes no permit inside such a scope. ([#4148](https://github.com/bastani-inc/atomic/pull/4148))
+- A subagent whose session does not start within 5 minutes now fails with `Subagent session did not start within 5 min (still <step>)` instead of staying `running`, and `subagent({ action: "status" })` shows it failed with that cause, in its text and its expanded card. ([#4148](https://github.com/bastani-inc/atomic/pull/4148), [#4150](https://github.com/bastani-inc/atomic/pull/4150))
+- A subagent launched with an effort, such as `model: "openai/gpt-5.5:xhigh"`, runs at exactly that effort on a model that supports it, and at that model's default level (its `modelThinkingLevels` entry, else `defaultThinkingLevel`) on one that does not, instead of the nearest level. A model its fallback chain switches to follows the same rule, so a fallback no longer drops the child to the default level silently, and a fallback the child starts on because the requested model's provider has no auth runs at its own effort. ([#4148](https://github.com/bastani-inc/atomic/pull/4148), [#4150](https://github.com/bastani-inc/atomic/pull/4150))
+- `subagent({ action: "status" })` lists only the children this session launched, each with the child id `pause`, `resume` and `quit` take (`· id <run-id>:<n>`), and those actions also take the listed path. It no longer lists children of other sessions in the same process, such as a workflow stage's, that `quit` then refused with `this session launched no such child`, and `status` with a child id finds the child. ([#4148](https://github.com/bastani-inc/atomic/pull/4148))
 
 ## [0.9.58-alpha.1] - 2026-11-01
 

package/dist/builtin/intercom/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.9.59] - 2026-11-01
+
+### Fixed
+
+- On Windows, sessions reconnect to a new intercom broker right after the running one dies, instead of waiting out the whole broker start-up timeout and failing with `Broker failed to start within timeout`. The dead broker's hidden `cmd.exe` launcher holds `broker.log` for a moment after the broker exits, and the respawn mistook that for another broker still starting; it now waits up to a second for the log to be released first. ([#4152](https://github.com/bastani-inc/atomic/pull/4152))
+
+## [0.9.59-alpha.1] - 2026-11-01
+
+### Fixed
+
+- On Windows, sessions reconnect to a new intercom broker right after the running one dies, instead of waiting out the whole broker start-up timeout and failing with `Broker failed to start within timeout`. The dead broker's hidden `cmd.exe` launcher holds `broker.log` for a moment after the broker exits, and the respawn mistook that for another broker still starting; it now waits up to a second for the log to be released first. ([#4152](https://github.com/bastani-inc/atomic/pull/4152))
+
 ## [0.9.56] - 2026-10-30
 
 ### Fixed

package/dist/builtin/intercom/broker/spawn.ts

@@ -291,9 +291,15 @@ export function getBrokerSpawnOptions(
   };
 }
 
+/**
+ * How long a spawn waits for the Windows launcher of a broker that just exited to let go of the log. Its `cmd.exe`
+ * outlives the broker by a moment, and a broker that is really still starting keeps the log for as long as it runs.
+ */
+export const BROKER_LOG_RELEASE_WAIT_MS = 1_000;
+
 /**
  * Preserve a bounded previous log across truncation. Returns false when a
- * Windows broker that is still starting holds the log through its launcher's stderr redirect.
+ * Windows launcher holds the log through its stderr redirect.
  */
 function resetBrokerLog(logPath: string = BROKER_LOG): boolean {
   ensurePrivateDirectory(dirname(logPath));
@@ -315,6 +321,20 @@ function resetBrokerLog(logPath: string = BROKER_LOG): boolean {
   }
 }
 
+/**
+ * Reset the log, waiting up to {@link BROKER_LOG_RELEASE_WAIT_MS} for the launcher of a broker that just exited, as
+ * one does when a running broker dies and its clients reconnect at once. Returns false only when the log stays held,
+ * which means a broker is still starting.
+ */
+async function resetBrokerLogOnceReleased(): Promise<boolean> {
+  const deadline = Date.now() + BROKER_LOG_RELEASE_WAIT_MS;
+  while (!resetBrokerLog()) {
+    if (Date.now() >= deadline) return false;
+    await sleep(50);
+  }
+  return true;
+}
+
 /** Read at most {@link BROKER_LOG_TAIL_BYTES} trailing bytes of the broker log. */
 export function readBrokerLogTail(logPath: string = BROKER_LOG, maxBytes: number = BROKER_LOG_TAIL_BYTES): string {
   let fd: number | undefined;
@@ -392,7 +412,7 @@ export async function spawnBrokerIfNeeded(
       writeWindowsHiddenLauncher(launch.launcherCommandLine, launch.launcherPath);
     }
     // Reset before spawning either way: the Windows launcher appends to this same path.
-    if (!resetBrokerLog()) {
+    if (!(await resetBrokerLogOnceReleased())) {
       await waitForBroker(readyTimeoutMs);
       return;
     }

package/dist/builtin/intercom/index.bundle.mjs

@@ -2487,6 +2487,15 @@ function resetBrokerLog(logPath = BROKER_LOG) {
     throw error;
   }
 }
+async function resetBrokerLogOnceReleased() {
+  const deadline = Date.now() + BROKER_LOG_RELEASE_WAIT_MS;
+  while (!resetBrokerLog()) {
+    if (Date.now() >= deadline)
+      return false;
+    await sleep(50);
+  }
+  return true;
+}
 function readBrokerLogTail(logPath = BROKER_LOG, maxBytes = BROKER_LOG_TAIL_BYTES) {
   let fd;
   try {
@@ -2545,7 +2554,7 @@ async function spawnBrokerIfNeeded(brokerCommand, brokerArgs, readyTimeoutMs = B
     if (launch.kind === "windows-launcher") {
       writeWindowsHiddenLauncher(launch.launcherCommandLine, launch.launcherPath);
     }
-    if (!resetBrokerLog()) {
+    if (!await resetBrokerLogOnceReleased()) {
       await waitForBroker(readyTimeoutMs);
       return;
     }
@@ -2718,7 +2727,7 @@ ${describeBrokerLog()}`);
 ` + "The broker did not answer on its socket in time; it may still be starting, which a busy machine or an empty jiti " + "cache slows. Try again, or raise `brokerStartupTimeoutMs` in the Intercom config.json (default " + `${BROKER_READY_TIMEOUT_MS} ms).
 ${describeBrokerLog()}`);
 }
-var INTERCOM_DIR, EXTENSION_DIR, BROKER_SOCKET2, BROKER_PID, BROKER_SPAWN_LOCK, BROKER_LOG, BROKER_START_ANNOUNCEMENT, BROKER_LOG_TAIL_BYTES, BROKER_POLL_INITIAL_INTERVAL_MS = 10, BROKER_POLL_MAX_INTERVAL_MS = 100, BROKER_SPAWN_LOCK_MAX_AGE_MS = 60000, INTERNAL_INTERCOM_BROKER_ARG = "--atomic-internal-intercom-broker";
+var INTERCOM_DIR, EXTENSION_DIR, BROKER_SOCKET2, BROKER_PID, BROKER_SPAWN_LOCK, BROKER_LOG, BROKER_START_ANNOUNCEMENT, BROKER_LOG_TAIL_BYTES, BROKER_POLL_INITIAL_INTERVAL_MS = 10, BROKER_POLL_MAX_INTERVAL_MS = 100, BROKER_SPAWN_LOCK_MAX_AGE_MS = 60000, INTERNAL_INTERCOM_BROKER_ARG = "--atomic-internal-intercom-broker", BROKER_LOG_RELEASE_WAIT_MS = 1000;
 var init_spawn = __esm(() => {
   init_socket_liveness();
   init_start_announcement();

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.58-alpha.1",
+  "version": "0.9.59-alpha.1",
   "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/package.json

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

package/dist/builtin/subagents/CHANGELOG.md

@@ -8,6 +8,12 @@
 
 - Running subagents now send the parent periodic task heartbeats (every 15 minutes by default) with their current tool call, time since their last activity, and turn, tool-call and token counts. Set `heartbeatMs` on a `subagent` call, or on a `tasks` entry, to change a child's cadence; `0` turns it off.
 
+### Fixed
+
+- A subagent launched from a chat turn that a running workflow started no longer stays `running` for good with no session: its session no longer waits on that workflow's resource admission. A subagent whose session still does not start within 5 minutes fails with `Subagent session did not start within 5 min (still <step>)`, and `status` shows the cause in its text and its expanded card. ([#4148](https://github.com/bastani-inc/atomic/pull/4148), [#4150](https://github.com/bastani-inc/atomic/pull/4150))
+- A subagent launched with an effort, such as `model: "openai/gpt-5.5:xhigh"`, runs at exactly that effort on a model that supports it, and at that model's default level on one that does not; each model in its fallback chain follows the same rule instead of falling back to the default level, including a fallback the child starts on in place of a requested model whose provider has no auth. ([#4148](https://github.com/bastani-inc/atomic/pull/4148), [#4150](https://github.com/bastani-inc/atomic/pull/4150))
+- `status` lists only the children this session launched, with the child id `pause`, `resume` and `quit` take, and those actions also take the listed path; `status` with a child id finds the child. ([#4148](https://github.com/bastani-inc/atomic/pull/4148))
+
 ## [0.9.58-alpha.1] - 2026-11-01
 
 ### Added

package/dist/builtin/subagents/README.md

@@ -570,6 +570,8 @@ subagent({ action: "quit", id: "<child-id>" })
 subagent({ action: "quit", all: true })
 ```
 
+`status` lists the children this session launched that are still in this process, each as `<run-id>/<agent>_<n> — <state> (loaded|cold) · id <child-id>`, with the cause of a failed or interrupted child after it; `pause`, `resume` and `quit` take the child id or that path, and `status` takes either to show one child. Children other sessions in the same process launched, such as a workflow stage's, are not listed, since this session cannot control them. A child whose session has not started within 5 minutes fails with `Subagent session did not start within 5 min (still <step>)` instead of staying running.
+
 `pause` stops a child and holds its queued messages until `resume`; `quit` stops it gracefully, including a child already paused by you or with its workflow stage. Both stay resumable while the session or workflow stage that launched the child can still resume it, as do children stopped because their workflow stage was paused or quit, including by Atomic exiting or a session switch. `resume` reopens the child's own session under the same id and Intercom name. A paused, quit, or interrupted child receives `message` once as its next prompt and then continues where it left off; a completed or failed child receives `message` as one fresh prompt. Without `message`, every resumable child, including a completed or failed one, is asked to continue where it left off. Children cancelled for good (owner or batch cancellation, including a `/tasks` stop, and the removed `kill` action), children whose workflow stage ended (the stage finished, or its run ended or was cancelled; this covers all of that stage's children, including ones you paused or quit), and children reported gone after a restart cannot be resumed: `resume` returns an error that says why, and follow-up work requires a fresh launch with explicit context. A parallel child waiting for a reply is not terminal and continues in its original execution. Parent cancellation of a still-running child uses the interrupted/abort state: receipts and progress present it as cancelled rather than failed, persisted metadata keeps the abort cause, and bounded partial findings remain available. Migrate old subagent calls from `action: "kill"` or `action: "interrupt"` to `action: "quit"`; the old actions are rejected with `The subagent action "kill" was removed. Use { action: "quit", id } to stop a child gracefully; it stays resumable with { action: "resume", id, message? }.` (naming the action that was used). Host interrupt APIs are unchanged.
 
 ## Worktree isolation
@@ -814,7 +816,7 @@ The main runtime files are:
 
 ### Suffix-first reasoning levels
 
-Reasoning levels are configured suffix-first using the `model_name:thinking_effort` syntax on `model` and each `fallbackModels` entry: `model: claude-sonnet-4:high` and `fallbackModels: claude-sonnet-4:medium, gpt-5:low, claude-haiku-4:off`. Canonical efforts are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. `xhigh` and `max` are forwarded only when the selected model supports them. The older `thinking` field is deprecated; it remains supported as a legacy default only when a model candidate has no suffix, and a suffix always wins.
+Reasoning levels are configured suffix-first using the `model_name:thinking_effort` syntax on `model` and each `fallbackModels` entry: `model: claude-sonnet-4:high` and `fallbackModels: claude-sonnet-4:medium, gpt-5:low, claude-haiku-4:off`. Canonical efforts are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. A child runs at exactly the effort it was launched with on a model that supports it; a model that does not support it, `xhigh` or `max` on many models, runs at its own default level instead (its `modelThinkingLevels` setting, else `defaultThinkingLevel`). Fallback models follow the same rule, using their own suffix or, without one, the launch's effort. The older `thinking` field is deprecated; it remains supported as a legacy default only when a model candidate has no suffix, and a suffix always wins.
 
 Migrate legacy `thinking` frontmatter by folding the effort into `model` and `fallbackModels`:
 

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.58-alpha.1",
+  "version": "0.9.59-alpha.1",
   "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/subagents/src/extension/index.bundle.mjs

@@ -8939,6 +8939,13 @@ function subagentChildCardRecord(childId, taskId) {
   const id = childId ?? childIdsByTaskId.get(taskId);
   return id === undefined ? undefined : latest.get(id);
 }
+function observedSubagentRunIds(ownerSessionId) {
+  const runIds = new Set;
+  for (const record of latest.values())
+    if (record.owner?.sessionId === ownerSessionId)
+      runIds.add(record.runId);
+  return runIds;
+}
 function watchSubagentChildCard(card, invalidate, key, ownerSessionId) {
   invalidators.set(card, invalidate);
   const cards = watchers.get(key) ?? new Set;
@@ -11825,7 +11832,10 @@ import {
 import {
   SubagentControl
 } from "@bastani/atomic-natives";
-import { clampThinkingLevel } from "@bastani/pi-ai/compat";
+import {
+  clampThinkingLevel,
+  getSupportedThinkingLevels
+} from "@bastani/pi-ai/compat";
 
 // dist/builtin/subagents/src/agents/skills.ts
 import * as fs14 from "node:fs";
@@ -12566,6 +12576,23 @@ function createInProcessChildPromptBehavior(policy) {
 }
 
 // dist/builtin/subagents/src/runs/inprocess/runner.ts
+var SUBAGENT_SESSION_START_TIMEOUT_MS = 5 * 60000;
+function formatStartTimeout(ms) {
+  return ms % 60000 === 0 ? `${ms / 60000} min` : `${Math.max(1, Math.round(ms / 1000))}s`;
+}
+var DEFAULT_THINKING_LEVEL = "medium";
+function explicitEffortFor(model, requested, settings) {
+  if (getSupportedThinkingLevels(model).includes(requested))
+    return requested;
+  return clampThinkingLevel(model, settings.getModelThinkingLevel(model.provider, model.id) ?? settings.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL);
+}
+function pinFallbackEffort(entry, requested, settings, resolve) {
+  const resolved = resolve?.(entry);
+  if (!resolved)
+    return entry;
+  const { baseModel } = splitKnownThinkingSuffix(entry.trim());
+  return `${baseModel}:${explicitEffortFor(resolved.model, resolved.thinkingLevel ?? requested, settings)}`;
+}
 function modelIdForCandidate(candidate, fallbackModel) {
   return candidate.modelId ?? (candidate.model ? `${candidate.model.provider}/${candidate.model.id}` : undefined) ?? (fallbackModel ? `${fallbackModel.provider}/${fallbackModel.id}` : undefined);
 }
@@ -13018,12 +13045,23 @@ class SubagentControlRuntime {
   delivered = new Set;
   deliveredEnvelopes = new Map;
   killedChildren = new Set;
+  childIds = new Map;
   nextAttemptId = 1;
   constructor(parent, sessionRoot, runningCapacity) {
     this.parent = { ...parent };
     this.sessionRoot = trustedSessionRoot(this.parent, sessionRoot);
     this.native = new SubagentControl(this.parent.path, runningCapacity);
   }
+  childIdOf(pathValue) {
+    return this.childIds.get(pathValue);
+  }
+  pathOfChildId(childId) {
+    let latest;
+    for (const [pathValue, id] of this.childIds)
+      if (id === childId)
+        latest = pathValue;
+    return latest;
+  }
   registerAgents(agents) {
     for (const agent of agents)
       this.native.registerAgent(agent.name);
@@ -13041,6 +13079,8 @@ class SubagentControlRuntime {
     if (!native.child)
       return refusal(native);
     const identity = native.child;
+    if (spec.childId !== undefined)
+      this.childIds.set(identity.path, spec.childId);
     const childModePolicy = resolveChildModePolicy(spec);
     const sessionDir = spec.sessionManager?.getSessionDir() || sessionDirectory(this.sessionRoot, identity.path);
     mkdirSync7(sessionDir, { recursive: true });
@@ -13183,9 +13223,34 @@ class SubagentControlRuntime {
     signals.interrupt.addEventListener("abort", interruptListener, {
       once: true
     });
+    const startTimeoutMs = admitted.spec.sessionStartTimeoutMs ?? SUBAGENT_SESSION_START_TIMEOUT_MS;
+    const startDeadline = new AbortController;
+    let startPhase = "opening its session";
+    const startTimer = setTimeout(() => startDeadline.abort(new Error(`Subagent session did not start within ${formatStartTimeout(startTimeoutMs)} (still ${startPhase}); it was stopped before its task ran.`)), startTimeoutMs);
+    const beforeStartDeadline = (phase, work, abandon) => {
+      startPhase = phase;
+      return new Promise((resolve, reject) => {
+        const expire = () => {
+          work.then((late) => abandon?.(late), () => {
+            return;
+          });
+          reject(startDeadline.signal.reason);
+        };
+        if (startDeadline.signal.aborted)
+          return expire();
+        startDeadline.signal.addEventListener("abort", expire, { once: true });
+        work.then((value) => {
+          startDeadline.signal.removeEventListener("abort", expire);
+          resolve(value);
+        }, (error) => {
+          startDeadline.signal.removeEventListener("abort", expire);
+          reject(error);
+        });
+      });
+    };
     try {
       const workflow = workflowMetadataFromContext(admitted.spec.parent?.orchestrationContext);
-      const sessionManager = admitted.sessionManager ? await SessionManager3.open(admitted.sessionManager.getSessionStore(), admitted.sessionManager.getSessionId(), admitted.policy.cwd) : await SessionManager3.create(admitted.policy.cwd, admitted.sessionDir, workflow ? { internal: true, workflow } : { internal: true });
+      const sessionManager = await beforeStartDeadline("opening its session", admitted.sessionManager ? SessionManager3.open(admitted.sessionManager.getSessionStore(), admitted.sessionManager.getSessionId(), admitted.policy.cwd) : SessionManager3.create(admitted.policy.cwd, admitted.sessionDir, workflow ? { internal: true, workflow } : { internal: true }));
       transcriptManager = sessionManager;
       taskHooks?.bindTranscript?.(sessionManager);
       const childSession = {
@@ -13195,7 +13260,7 @@ class SubagentControlRuntime {
       taskHooks?.bindChildSession?.(childSession);
       admitted.spec.onChildSession?.(childSession);
       if (workflow)
-        await sessionManager.markSessionInternal(workflow);
+        await beforeStartDeadline("opening its session", sessionManager.markSessionInternal(workflow));
       const launchLeafId = sessionManager.getLeafId();
       ownMessages = () => messagesSinceLaunch(sessionManager, launchLeafId);
       let created;
@@ -13221,6 +13286,13 @@ class SubagentControlRuntime {
         } : inherited.extensionBindings;
         const agentDir = inherited.agentDir ?? getAgentDir2();
         const settingsManager = inherited.settingsManager ?? SettingsManager.create(admitted.policy.cwd, agentDir);
+        const requested = admitted.spec.requestedThinking;
+        const startSuffix = splitKnownThinkingSuffix(candidate.modelId ?? "").thinkingSuffix.slice(1);
+        const startEffort = THINKING_LEVELS.find((level) => level === startSuffix) ?? requested;
+        const explicitEffort = requested === undefined || startEffort === undefined ? {} : {
+          ...inherited.model ? { thinkingLevel: explicitEffortFor(inherited.model, startEffort, settingsManager) } : {},
+          fallbackModels: (inherited.fallbackModels ?? settingsManager.getFallbackModels() ?? []).map((entry) => pinFallbackEffort(entry, requested, settingsManager, admitted.spec.resolveCandidateModel))
+        };
         const resourceLoader = new DefaultResourceLoader(inProcessChildResourceLoaderOptions({
           cwd: admitted.policy.cwd,
           agentDir,
@@ -13230,7 +13302,7 @@ class SubagentControlRuntime {
           resourceLoaderInheritanceSnapshot: admitted.spec.parent?.resourceLoaderInheritanceSnapshot,
           orchestrationContext: admitted.spec.parent?.orchestrationContext
         }));
-        await resourceLoader.reload();
+        await beforeStartDeadline("loading its resources", resourceLoader.reload());
         const selectedSkills = resolveSkillsFromCatalog([...admitted.policy.skills], resourceLoader.getSkillCatalog(), admitted.policy.cwd);
         skillReport = {
           ...selectedSkills.resolved.length > 0 ? { skills: selectedSkills.resolved.map((skill) => skill.name) } : {},
@@ -13242,26 +13314,28 @@ class SubagentControlRuntime {
         const skillInjection = buildSkillInjection(selectedSkills.resolved);
         const promptBehavior = createInProcessChildPromptBehavior(admitted.policy);
         const systemPromptTransform = createInProcessChildSystemPromptTransform(admitted.policy, skillInjection);
-        created = {
-          session: (await createAgentSession({
-            ...inherited,
-            extensionBindings,
-            customTools: admitted.policy.customTools ?? inherited.customTools,
-            resourceLoader,
-            resourceAdmissionSignal: AbortSignal.any([signals.abort, signals.interrupt]),
-            subagentPolicy: {
-              ...admitted.policy,
-              executionEnded: executionEnded.signal,
-              ...!childAllowsIntercom(inherited) ? { intercom: undefined, intercomGroup: undefined } : {}
-            },
-            settingsManager,
-            orchestrationContext: admitted.spec.parent?.orchestrationContext,
-            sessionManager,
-            systemPromptTransform,
-            initialContextTransform: promptBehavior.initialContextTransform
-          })).session
-        };
+        created = await beforeStartDeadline("creating its agent session, which includes any wait for a resource-admission permit", createAgentSession({
+          ...inherited,
+          ...explicitEffort,
+          extensionBindings,
+          customTools: admitted.policy.customTools ?? inherited.customTools,
+          resourceLoader,
+          resourceAdmissionSignal: AbortSignal.any([signals.abort, signals.interrupt, startDeadline.signal]),
+          subagentPolicy: {
+            ...admitted.policy,
+            executionEnded: executionEnded.signal,
+            ...!childAllowsIntercom(inherited) ? { intercom: undefined, intercomGroup: undefined } : {}
+          },
+          settingsManager,
+          orchestrationContext: admitted.spec.parent?.orchestrationContext,
+          sessionManager,
+          systemPromptTransform,
+          initialContextTransform: promptBehavior.initialContextTransform
+        }), (late) => void late.session.dispose().catch(() => {
+          return;
+        }));
       }
+      clearTimeout(startTimer);
       session = created.session;
       const transcriptSession = session;
       let observedStreamingMessage;
@@ -13493,6 +13567,7 @@ class SubagentControlRuntime {
         ...skillReport
       };
     } finally {
+      clearTimeout(startTimer);
       executionEnded.abort();
       signals.abort.removeEventListener("abort", abortListener);
       signals.interrupt.removeEventListener("abort", interruptListener);
@@ -13680,11 +13755,24 @@ function findSubagentControl(id) {
   if (direct)
     return direct;
   for (const control of controls.values()) {
+    if (control.pathOfChildId(id) !== undefined)
+      return control;
     if (control.native.listChildren().some((child) => child.path === id))
       return control;
   }
   return;
 }
+function subagentChildPath(control, id) {
+  return control.pathOfChildId(id) ?? id;
+}
+function subagentChildIdOfPath(id) {
+  for (const control of controls.values()) {
+    const childId = control.childIdOf(id);
+    if (childId !== undefined)
+      return childId;
+  }
+  return;
+}
 function listSubagentControls() {
   return [...controls.values()];
 }
@@ -14030,6 +14118,8 @@ async function runSingleInProcess(runtimeCwd, agent, task, options) {
   const resolvedCandidate = candidate ? options.resolveCandidateModel?.(candidate) : undefined;
   if (options.modelRoute && !resolvedCandidate)
     throw new Error("Subagent auto-selected model could not be resolved before execution. Retry explicitly with the current catalog.");
+  const requestedSuffix = splitKnownThinkingSuffix(options.modelOverride ?? agent.model ?? "").thinkingSuffix.slice(1);
+  const requestedThinking = options.modelRoute ? undefined : THINKING_LEVELS.find((level) => level === requestedSuffix);
   const orchestrationContext = workflowOrchestrationContext(options);
   const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
   const parent = {
@@ -14056,6 +14146,7 @@ ${task}`);
   const testSession = options.testSession ?? defaultTestSession();
   const spec = {
     taskName: agent.name,
+    childId: `${options.runId}:${options.index ?? 0}`,
     task,
     agent,
     cwd,
@@ -14069,6 +14160,11 @@ ${task}`);
     ...options.progressPath ? { progressPath: options.progressPath } : {},
     ...options.progressArtifactPath ? { progressArtifactPath: options.progressArtifactPath } : options.progressPath && artifactsDir ? { progressArtifactPath: options.progressPath } : {},
     ...artifactPaths?.outputPath ? { outputArtifactPath: artifactPaths.outputPath } : {},
+    ...options.sessionStartTimeoutMs === undefined ? {} : { sessionStartTimeoutMs: options.sessionStartTimeoutMs },
+    ...requestedThinking === undefined ? {} : {
+      requestedThinking,
+      ...options.resolveCandidateModel ? { resolveCandidateModel: options.resolveCandidateModel } : {}
+    },
     tools: agent.tools,
     mcpDirectTools: agent.mcpDirectTools,
     skills: options.skills ?? agent.skills,
@@ -15898,34 +15994,52 @@ function handleSubagentControlNotice(input) {
 function canonicalChildren(control) {
   return [...control.listChildren()].sort((left, right) => left.path.localeCompare(right.path));
 }
+function settledCause(control, path, status) {
+  if (status !== "error" && status !== "interrupted")
+    return;
+  const cause = control.getDeliveredResult(path)?.cause?.replace(/\s+/g, " ").trim();
+  return cause || undefined;
+}
 function childLines(control, id) {
-  if (!control)
-    return [];
   if (id) {
-    const child = control.findChild(id);
+    const path = subagentChildPath(control, id);
+    const child = control.findChild(path);
     if (!child)
       return [];
-    const delivered = control.getDeliveredResult(id);
+    const delivered = control.getDeliveredResult(path);
+    const childId = control.childIdOf(path);
+    const cause = settledCause(control, path, child.status);
     return [
+      ...childId ? [`Id: ${childId}`] : [],
       `Child: ${child.path}`,
       `Parent: ${child.parentPath}`,
       `Task: ${child.taskName}`,
       `Depth: ${child.depth}`,
       `Status: ${child.status}`,
+      ...cause ? [`Cause: ${cause}`] : [],
       `Residency: ${child.loaded ? "loaded" : "cold"}`,
       ...delivered?.sessionFile ? [`Session: ${delivered.sessionFile}`] : []
     ];
   }
-  return control.listChildren().map((child) => `${child.path} — ${child.status} (${child.loaded ? "loaded" : "cold"})`);
+  return control.listChildren().map((child) => {
+    const childId = control.childIdOf(child.path);
+    const cause = settledCause(control, child.path, child.status);
+    return `${child.path} — ${child.status} (${child.loaded ? "loaded" : "cold"})${childId ? ` · id ${childId}` : ""}${cause ? ` · ${cause}` : ""}`;
+  });
 }
 function statusGroup(control, id) {
+  const path = id === undefined ? undefined : subagentChildPath(control, id);
   return {
     parentPath: control.parent.path,
-    children: canonicalChildren(control).filter((child) => !id || id === control.parent.path || child.path === id).map((child) => {
+    children: canonicalChildren(control).filter((child) => !path || path === control.parent.path || child.path === path).map((child) => {
       const delivered = control.getDeliveredResult(child.path);
       const metadata = control.getChildMetadata(child.path) ?? delivered;
+      const childId = control.childIdOf(child.path);
+      const failure = settledCause(control, child.path, child.status);
       return {
         ...child,
+        ...childId === undefined ? {} : { childId },
+        ...failure === undefined ? {} : { failure },
         sessionFile: delivered?.sessionFile,
         ...metadata?.model === undefined ? {} : { model: metadata.model },
         ...metadata?.thinking === undefined ? {} : { thinking: metadata.thinking }
@@ -15933,10 +16047,11 @@ function statusGroup(control, id) {
     })
   };
 }
-function inspectInProcessChildStatus(id) {
+function inspectInProcessChildStatus(id, ownsRun) {
+  const owned = (control) => ownsRun?.(control.parent.path) ?? true;
   if (id) {
     const control = findSubagentControl(id);
-    if (!control)
+    if (!control || !owned(control))
       return;
     const text = id === control.parent.path ? [`Parent: ${control.parent.path}`, ...childLines(control)].join(`
 `) : childLines(control, id).join(`
@@ -15948,7 +16063,7 @@ function inspectInProcessChildStatus(id) {
       details: { mode: "management", results: [], statusGroups: [statusGroup(control, id)] }
     };
   }
-  const controls = listSubagentControls();
+  const controls = listSubagentControls().filter(owned);
   const lines = controls.flatMap((control) => [`Parent: ${control.parent.path}`, ...childLines(control)]);
   if (lines.length === 0)
     return;
@@ -17561,10 +17676,22 @@ function liveTaskIds(host) {
 function ownedRecords(ctx) {
   return readSubagentChildRecords(ctx.sessionManager.getEntries(), subagentChildOwner(ctx).sessionId);
 }
+async function subagentRunsLaunchedBy(ctx) {
+  const owner = subagentChildOwner(ctx).sessionId;
+  await subagentChildRecordsAppended(owner);
+  const runIds = observedSubagentRunIds(owner);
+  for (const record of ownedRecords(ctx).values())
+    runIds.add(record.runId);
+  return runIds;
+}
 function resolveRecord(records, id) {
   const direct = findSubagentChildRecord(records, id);
   if (direct)
     return direct;
+  const listedAs = subagentChildIdOfPath(id.trim());
+  const byPath = listedAs === undefined ? undefined : records.get(listedAs);
+  if (byPath)
+    return byPath;
   const inRun = [...records.values()].filter((record) => record.runId === id.trim());
   if (inRun.length === 1)
     return inRun[0];
@@ -17905,7 +18032,8 @@ async function handleManagementRequest(input) {
   if (action === "status") {
     const targetRunId = paramsWithResolvedCwd.id ?? paramsWithResolvedCwd.runId;
     const foreground = getForegroundControl(deps.state, targetRunId);
-    const live = inspectInProcessChildStatus(targetRunId) ?? (foreground ? foregroundStatusResult(foreground) : undefined);
+    const launched = await subagentRunsLaunchedBy(ctx);
+    const live = inspectInProcessChildStatus(targetRunId, (runId) => launched.has(runId)) ?? (foreground ? foregroundStatusResult(foreground) : undefined);
     if (awaitingResume.length > 0) {
       const liveText = live?.content.map((part) => part.type === "text" ? part.text : "").join(`
 `);
@@ -19263,11 +19391,13 @@ function childStatusLines(child, expanded, theme, width) {
   return [
     heading,
     ...metadata,
+    ...child.childId ? [theme.fg("dim", `  Id: ${displayText(child.childId)}`)] : [],
     theme.fg("dim", `  Path: ${displayText(child.path)}`),
     theme.fg("dim", `  Parent: ${displayText(child.parentPath)} · Depth: ${child.depth}`),
     theme.fg("dim", `  Task: ${displayText(child.taskName)}`),
     theme.fg("dim", `  Residency: ${child.loaded ? "loaded" : "cold"}`),
     ...child.cause ? [theme.fg("muted", `  Cause: ${displayText(child.cause)}`)] : [],
+    ...child.failure ? [theme.fg("error", `  Error: ${displayText(child.failure)}`)] : [],
     ...child.sessionFile ? [theme.fg("dim", `  Session: ${displayText(child.sessionFile)}`)] : []
   ];
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.58-alpha.1",
+  "version": "0.9.59-alpha.1",
   "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/package.json

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