@bastani/atomic 0.9.19-alpha.3 → 0.9.19-alpha.5

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 ## [Unreleased]
 
+## [0.9.19-alpha.5] - 2026-09-11
+
+### Changed
+
+- Open Claude Design now starts with Claude Fable 5.1 at medium effort, followed by Copilot Fable 5.1 and Astra at medium effort, with the same Fable-first order on OpenRouter.
+- Tuned bundled debugger, Goal, and Ralph reasoning efforts: debugger uses Astra/Fable at medium and Sol at high; Goal and Ralph reviewers use Astra/Sol at high; orchestration, Ralph research, and design use Fable at medium and Sol at high in their fallbacks. Ralph prompt refinement and other bundled agents retain their existing configurations.
+
+## [0.9.19-alpha.4] - 2026-09-10
+
+### Breaking Changes
+
+- Workflow controls, completion, help, and status hints use `/workflow pause`, `/workflow quit`, and `/workflow resume`. The workflow tool supports run, stage, and individual durable-tool pause targets; `/workflow pause [run-id|--all]` controls runs. Workflow lifecycle control events report `action: "pause"` for pause requests.
+- Renamed the bundled subagent `interrupt` action to `kill`. Migrate `subagent({ action: "interrupt", id })` to `subagent({ action: "kill", id })`, including calls using `runId`. The old action is no longer accepted. Kill terminally stops the child and cannot be resumed; follow-up work requires a fresh launch. Workflow controls use `/workflow pause`; parent cancellation behavior is unchanged.
+
+### Added
+
+- Added a model row to the `/workflow connect` graph node cards showing each stage's effective model and thinking level, including canonical fast model identity, with model-name truncation preserving the suffixes. Cards retain duration, status and dependencies in a six-row layout, reflect live fallbacks, and restore identity through durable resume ([#1859](https://github.com/bastani-inc/atomic/pull/1859) by [@sina85](https://github.com/sina85)).
+- Added `{ action: "wait", id, budgetMs }` to Bash and PowerShell for observing existing asynchronous tasks without rerunning commands. The observation budget is optional. Waits retain output and terminal metadata, follow owner observation policy, and release on cancellation or incoming messages without stopping execution or extending task lifetime.
+- Added the agent-callable `kill({ id })` tool for owned background bash and PowerShell tasks in main and workflow-stage chat. It cancels by task ID, preserves retained output and original outcomes, reports current cleanup state, and rejects other owners' tasks and subagents.
+- Added exact per-model overrides through `compaction.modelOverrides` for `compaction.reserveTokens` and Atomic's `compaction.preserve_recent` message count. Each field falls back to ordinary settings and then built-in defaults, with non-negative safe-integer validation. Manual, automatic, and post-tool compaction use the active model's budgets while retaining verbatim line compaction.
+
+### Fixed
+
+- First-loaded TypeScript extensions share the live host's classes and singletons when native import falls back to transformation, avoiding duplicate host evaluation and slow startup.
+- Fixed repeated yielded shell waits replaying the first output page instead of progressing through retained output while the task is still running ([#2972](https://github.com/bastani-inc/atomic/pull/2972)).
+- Preserved an explicit subagent kill when parent cancellation arrives during execution-capacity waiting, and kept grouped Intercom cancellation status consistent when a killed child has parent-cancelled siblings.
+- Embedded Postgres now starts on Windows administrative accounts. PostgreSQL refuses to run for a member of the Administrators or Power Users groups, so Atomic launches the retained server process with the same restricted access token `pg_ctl` uses, keeping exact-process shutdown semantics; non-administrative Windows accounts are unchanged. Postgres processes that exit during startup (including that administrator refusal on older builds) now fail fast with the actual server log instead of a readiness timeout.
+- Preserved embedded Postgres startup logs on regular Windows accounts, honored Unicode environment overrides on administrative launches, and prevented Windows handle leaks across repeated launches.
+- Preserved `PATH` lookup and relative executable paths for administrative Windows Postgres launches. Invalid launch inputs containing embedded NUL characters now fail before starting a process rather than using truncated paths, arguments, or environment values.
+- Fixed custom Windows Postgres `.cmd` and `.bat` launchers failing with arguments on administrative accounts, including launcher paths containing spaces. Batch arguments retain their existing quoting and line-break rejection.
+- Fixed explicit `cmd.exe` Postgres launchers and safe verbatim working directories on Windows administrative accounts. Concurrent Postgres launches no longer keep one another's log files open or expose them to unrelated commands starting at the same time.
+- Incoming Intercom send and ask messages now act as a priority interrupt queue for working subagents and live workflow stages: the receiver's current model call or cancellable tool is cancelled immediately and the message is processed within the same task, session, and stage generation. Admission survives consumed preflight input and overlapping SDK interrupt turns. Completed tool side effects are never replayed, the original task prompt is not repeated, multiple arrivals stay in arrival order with duplicate suppression, and exact ask/reply correlation survives the cancelled turn. Explicit user abort, host stop, and terminal/closed receivers still win: late input never restarts finished work.
+- Fixed a deadlock where an extension event hook awaiting an ordinary context-only message could wait behind an inbound Intercom delivery that was itself waiting for that event hook.
+- Inbound delivery retries after a transient persistence failure keep their original arrival position and remain part of both child and workflow-stage settlement, and a card appended before a failed flush is completed on retry instead of being appended a second time.
+
 ## [0.9.19-alpha.3] - 2026-09-09
 
 ### Fixed

package/dist/builtin/intercom/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.9.19-alpha.4] - 2026-09-10
+
+### Fixed
+
+- Route lazy initialization, event-relay, and rejected-candidate cleanup diagnostics through the owning interactive session's notifications, including during shutdown, instead of leaking console output and stacks. Retryable initialization uses warning color; non-interactive console diagnostics (including RPC), original failures, acknowledgements, and retry behavior are preserved even when an error cannot be rendered.
+- `send` and `ask` to a working subagent or live workflow stage are delivered as a priority interrupt: the recipient's active model call or cancellable tool is cancelled immediately and the message is processed in the same task instead of waiting for the next natural turn or being refused as busy. Completed side effects are not undone or replayed. Arrival order holds across persistence retries for both receiver kinds; duplicate suppression, exact reply correlation, terminal-child and closed-stage rejection, unrelated headless protection, and group restrictions are unchanged.
+- A cancelled turn that produced no reply no longer consumes the pending ask's reply context, so replies to consecutive asks stay correlated with the right sender and message.
+
 ## [0.9.19-alpha.3] - 2026-09-09
 
 ### Fixed

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

@@ -1989,6 +1989,11 @@ class ReplyTracker {
   endTurn() {
     this.currentTurnContext = null;
   }
+  restoreTurnContext() {
+    if (this.currentTurnContext)
+      this.pendingTurnContexts.unshift(this.currentTurnContext);
+    this.currentTurnContext = null;
+  }
   reset() {
     this.pendingAsks.clear();
     this.pendingTurnContexts.length = 0;
@@ -4579,10 +4584,15 @@ function registerIntercomLifecycle(pi, deps) {
     hasActiveSession = false;
     await cleanupRuntime("Session shutting down");
   });
-  pi.on("turn_end", () => {
+  pi.on("turn_end", (event) => {
     if (!deps.getLiveContext())
       return;
-    activeReplyTracker().endTurn();
+    const message = event.message;
+    const cancelledBeforeReply = message?.role === "assistant" && message.stopReason === "aborted" && message.content?.length === 0;
+    if (cancelledBeforeReply)
+      activeReplyTracker().restoreTurnContext();
+    else
+      activeReplyTracker().endTurn();
     deps.scheduleInboundFlush();
   });
   pi.on("agent_start", () => {
@@ -5674,7 +5684,7 @@ function createIncomingMessageSender(input) {
     if (!input.canDeliver(generation)) {
       return Promise.reject(new Error("Intercom session retired before inbound delivery"));
     }
-    if (delivery === "trigger" && trackReplyContext) {
+    if ((delivery === "trigger" || delivery === "interrupt") && trackReplyContext) {
       input.queueTurnContext(turnContext ?? { from: entry.from, message: entry.message, receivedAt: Date.now() });
     }
     const baseOptions = {
@@ -5682,7 +5692,7 @@ function createIncomingMessageSender(input) {
       persistWhenStreaming: true,
       ...stageAdmissionBarrier ? { stageAdmissionBarrier } : {}
     };
-    const options = delivery === "trigger" ? { ...baseOptions, triggerTurn: true } : delivery === "followUp" ? { ...baseOptions, deliverAs: "followUp" } : baseOptions;
+    const options = delivery === "interrupt" ? { ...baseOptions, triggerTurn: true, deliverAs: "interrupt" } : delivery === "trigger" ? { ...baseOptions, triggerTurn: true } : delivery === "followUp" ? { ...baseOptions, deliverAs: "followUp" } : baseOptions;
     return Promise.resolve(input.pi.sendMessage(buildIncomingCustomMessage(entry), options));
   };
 }
@@ -6034,13 +6044,15 @@ function retryStableDelivery(options) {
 function admitWorkflowStageInbound(ctx, deliver, firstRefusal, onAdmissionFailure) {
   if (ctx.orchestrationContext?.kind !== "workflow-stage")
     return false;
+  const boundary = ctx.orchestrationContext.messageAdmission?.boundary;
+  const run = (barrier) => boundary?.runMessageDelivery(() => deliver(barrier), () => deliver(), true) ?? Promise.resolve(deliver(barrier));
   try {
     let busy = false;
     try {
       busy = ctx.isIdle?.() === false;
     } catch {}
     if (!busy || !firstRefusal)
-      return Promise.resolve(deliver());
+      return run();
     let firstRefusalPromise;
     const admissionBarrier = () => {
       firstRefusalPromise ??= (async () => {
@@ -6053,12 +6065,29 @@ function admitWorkflowStageInbound(ctx, deliver, firstRefusal, onAdmissionFailur
       })();
       return firstRefusalPromise;
     };
-    return Promise.resolve(deliver(admissionBarrier));
+    return run(admissionBarrier);
   } catch (error) {
     return Promise.reject(error);
   }
 }
 
+// dist/builtin/intercom/active-session-admission.ts
+function admitActiveSessionInbound(ctx, deliver, firstRefusal, onAdmissionFailure) {
+  const executionEnded = ctx.subagentPolicy?.executionEnded;
+  if (executionEnded !== undefined) {
+    if (executionEnded.aborted || ctx.subagentPolicy?.messageAdmission?.isOpen() === false) {
+      return Promise.reject(new Error("Subagent execution is terminal and cannot accept messages"));
+    }
+    try {
+      return ctx.subagentPolicy?.messageAdmission?.run(deliver) ?? Promise.resolve(deliver());
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  return admitWorkflowStageInbound(ctx, deliver, firstRefusal, onAdmissionFailure);
+}
+var init_active_session_admission = () => {};
+
 // dist/builtin/intercom/workflow-reply-tracker.ts
 function bindWorkflowReplyTracker(ctx, current) {
   const state = ctx.orchestrationContext?.messageAdmission?.extensionState;
@@ -6112,7 +6141,7 @@ async function settleOpenStageDeliveryFailure(input, error) {
     input.admission.release(input.reservation, failure);
     return;
   }
-  const delivered = await sendWorkflowStageDeliveryFailure(input.entry, failure, input.tracker, input.currentClient, () => input.currentClient()?.isConnected() === true, "Running workflow stage could not admit intercom ask");
+  const delivered = await sendWorkflowStageDeliveryFailure(input.entry, failure, input.tracker, input.currentClient, () => input.currentClient()?.isConnected() === true, input.failurePrefix ?? "Running workflow stage could not admit intercom ask");
   if (delivered)
     input.commit();
   else
@@ -6479,17 +6508,18 @@ function piIntercomExtension(pi, testOverrides = {}) {
       tracker: replyTracker,
       replyContext,
       currentClient: () => client,
-      commit
+      commit,
+      failurePrefix: liveContext.subagentPolicy?.executionEnded === undefined ? undefined : "Subagent could not admit intercom ask"
     });
-    const stageDelivery = admitWorkflowStageInbound(liveContext, (admissionBarrier) => {
+    const activeDelivery = admitActiveSessionInbound(liveContext, (admissionBarrier) => {
       replyTracker.queueTurnContext(replyContext);
       return retryStableDelivery({
-        deliver: () => sendIncomingMessage(entry, "trigger", messageGeneration, false, undefined, admissionBarrier),
-        isCurrent: () => Boolean(getLiveContext(liveContext, messageGeneration))
+        deliver: () => sendIncomingMessage(entry, "interrupt", messageGeneration, false, undefined, admissionBarrier),
+        isCurrent: () => Boolean(getLiveContext(liveContext, messageGeneration)) && liveContext.subagentPolicy?.executionEnded?.aborted !== true && liveContext.subagentPolicy?.messageAdmission?.isOpen() !== false
       });
     }, () => foregroundDetachHandoff.claim(from, message, messageGeneration, () => Boolean(getLiveContext(liveContext, messageGeneration))), release);
-    if (stageDelivery !== false) {
-      stageDelivery.then(commit, release);
+    if (activeDelivery !== false) {
+      activeDelivery.then(commit, release);
       return;
     }
     return (async () => {
@@ -6499,7 +6529,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
           release(new Error("Intercom session retired before inbound delivery"));
           return;
         }
-        if (!activeContext.isIdle()) {
+        if (!activeContext.isIdle() && !activeContext.getAgentTaskHost?.().hasActiveTaskWaits) {
           if (!activeContext.hasUI) {
             const activeClient = client;
             if (!message.replyTo && activeClient?.isConnected()) {
@@ -6542,6 +6572,13 @@ function piIntercomExtension(pi, testOverrides = {}) {
           });
           return;
         }
+        if (!activeContext.isIdle()) {
+          const disposition = await foregroundDetachHandoff.claim(from, message, messageGeneration, () => Boolean(getLiveContext(liveContext, messageGeneration)));
+          if (disposition === "abandoned") {
+            release(new Error("Intercom session retired during foreground-owner admission"));
+            return;
+          }
+        }
         replyTracker.queueTurnContext(replyContext);
         await retryStableDelivery({ deliver: () => sendIncomingMessage(entry, "trigger", messageGeneration, false), isCurrent: () => Boolean(getLiveContext(liveContext, messageGeneration)) });
         commit();
@@ -7118,6 +7155,7 @@ var init_index_heavy = __esm(() => {
   init_terminal_ordering_barrier();
   init_inbound_message_admission();
   init_late_stage_message_router();
+  init_active_session_admission();
   init_workflow_reply_tracker();
   init_closed_workflow_stage_message();
   init_group();
@@ -7135,11 +7173,20 @@ var init_index_heavy = __esm(() => {
 });
 
 // dist/builtin/intercom/index.ts
-init_result_renderers();
 import { APP_NAME as APP_NAME2, getEnvValue } from "@bastani/atomic";
 import { Text as Text4 } from "@earendil-works/pi-tui";
 import { Type as Type3 } from "typebox";
 
+// dist/builtin/intercom/context-owner.ts
+var CONTEXT_OWNERS_KEY = Symbol.for("atomic-coding-agent/extension-context-owners@1");
+function getExtensionContextOwner(context) {
+  const owners = globalThis[CONTEXT_OWNERS_KEY];
+  return owners?.get(context) ?? context;
+}
+
+// dist/builtin/intercom/index.ts
+init_result_renderers();
+
 // dist/builtin/intercom/lazy-tool-execution.ts
 init_recoverable_disconnect();
 init_retry_policy();
@@ -7401,10 +7448,37 @@ function renderHeavyToolResult(loadedHeavy, name, args) {
     return renderer(...args);
   return renderIntercomToolResult(name, args);
 }
-function reportRelayFailure(eventName, error) {
+function diagnosticDetail(error) {
+  try {
+    return String(error instanceof Error ? error.message : error);
+  } catch {
+    return "Unprintable error";
+  }
+}
+function captureDiagnosticRoute(ctx) {
+  try {
+    return ctx?.hasUI && ctx.mode === "tui" ? ctx : "console";
+  } catch {
+    return "silent";
+  }
+}
+function reportDiagnostic(route, message, error, level, consoleMessage = message) {
+  if (route === "console") {
+    console.error(consoleMessage, error);
+    return;
+  }
+  if (route === "silent")
+    return;
+  try {
+    route.ui.notify(message, level);
+  } catch {}
+}
+function reportRelayFailure(route, eventName, error) {
   if (isRecoverableIntercomDisconnect(error))
     return;
-  console.error(`Intercom event relay failed (${eventName}):`, error);
+  const prefix = `Intercom event relay failed (${eventName}):`;
+  const detail = diagnosticDetail(error);
+  reportDiagnostic(route, `${prefix} ${detail}`, error, "error", prefix);
 }
 var WARM_UP_RETRY_ATTEMPTS = 5;
 function intercom(pi, options = {}) {
@@ -7412,6 +7486,7 @@ function intercom(pi, options = {}) {
   let heavyAttempt = null;
   let loadedHeavy = null;
   let sessionSnapshot = null;
+  let shutdownDiagnosticRoute;
   let lifecycleGeneration = 0;
   let nextLeaseId = 1;
   let activeLease = createLifecycleLease(nextLeaseId++);
@@ -7495,6 +7570,8 @@ function intercom(pi, options = {}) {
     await promise;
   }
   async function loadHeavy(ctx) {
+    let diagnosticRoute = captureDiagnosticRoute(ctx);
+    let diagnosticOwner = ctx && getExtensionContextOwner(ctx);
     const lease = activeLease;
     if (lease.retired)
       throw new Error("Intercom initialization unavailable: no active session");
@@ -7511,6 +7588,7 @@ function intercom(pi, options = {}) {
       return handle;
     }
     let promise;
+    let replayCtx = null;
     promise = (async () => {
       const captured = {
         tools: new Map,
@@ -7519,7 +7597,6 @@ function intercom(pi, options = {}) {
         shortcuts: new Map,
         eventHandlers: new Map
       };
-      let replayCtx = null;
       let cleaned = false;
       const cleanupCandidate = async () => {
         const shutdown = lease.shutdown;
@@ -7531,7 +7608,9 @@ function intercom(pi, options = {}) {
         try {
           await dispatchHandlers(captured, "session_shutdown", event, cleanupCtx);
         } catch (cleanupError) {
-          console.error("Intercom failed to clean rejected lazy candidate:", cleanupError);
+          const prefix = "Intercom failed to clean rejected lazy candidate:";
+          const detail = diagnosticDetail(cleanupError);
+          reportDiagnostic(shutdown?.diagnosticRoute ?? diagnosticRoute, `${prefix} ${detail}`, cleanupError, "error", prefix);
         }
       };
       try {
@@ -7543,6 +7622,11 @@ function intercom(pi, options = {}) {
           sessionSnapshot = { event: createSyntheticSessionStartEvent(), ctx, generation: ++lifecycleGeneration, lease };
         }
         await ensureSessionStartReplayed(captured, lease, (replayContext) => {
+          const owner = getExtensionContextOwner(replayContext);
+          if (owner !== diagnosticOwner) {
+            diagnosticRoute = captureDiagnosticRoute(replayContext);
+            diagnosticOwner = owner;
+          }
           replayCtx = replayContext;
         });
         assertLease(lease);
@@ -7561,8 +7645,8 @@ function intercom(pi, options = {}) {
       if (heavyAttempt?.promise === promise)
         heavyAttempt = null;
       if (!isRecoverableIntercomDisconnect(error)) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`Intercom heavy initialization failed; a later call will retry: ${message}`, error);
+        const message = diagnosticDetail(error);
+        reportDiagnostic(diagnosticRoute, `Intercom heavy initialization failed; a later call will retry: ${message}`, error, "warning");
       }
     });
     return promise;
@@ -7673,6 +7757,7 @@ function intercom(pi, options = {}) {
     }
     const generation = ++lifecycleGeneration;
     sessionSnapshot = { event, ctx, generation, lease };
+    shutdownDiagnosticRoute = undefined;
     cancelWarmUpRetry();
     if (ctx.orchestrationContext?.kind === "workflow-stage" && ctx.orchestrationContext.pendingStageDelivery !== undefined) {
       const pendingStageDelivery = ctx.orchestrationContext.pendingStageDelivery;
@@ -7690,7 +7775,9 @@ function intercom(pi, options = {}) {
   pi.on("session_shutdown", async (event, ctx) => {
     const lease = activeLease;
     const generation = ++lifecycleGeneration;
-    retireLifecycleLease(lease, { event, ctx, generation });
+    const diagnosticRoute = captureDiagnosticRoute(ctx);
+    retireLifecycleLease(lease, { event, ctx, generation, diagnosticRoute });
+    shutdownDiagnosticRoute = diagnosticRoute;
     cancelWarmUpRetry();
     const retiredHeavy = loadedHeavy?.heavy ?? null;
     const retiredAttempt = heavyAttempt?.lease === lease ? heavyAttempt.promise : null;
@@ -7811,13 +7898,15 @@ function intercom(pi, options = {}) {
       return;
     payload.handled = true;
     const forwarded = { ...payload, handled: false, completion: undefined };
-    payload.completion = loadHeavy(latestLifecycleContext()).then(async (handle) => {
+    const ctx = latestLifecycleContext();
+    const diagnosticRoute = ctx ? captureDiagnosticRoute(ctx) : shutdownDiagnosticRoute ?? "console";
+    payload.completion = loadHeavy(ctx).then(async (handle) => {
       handle.assertCurrent();
       await dispatchEventHandlers(handle.heavy, PENDING_STAGE_UNDELIVERABLE_EVENT2, forwarded);
       handle.assertCurrent();
       return forwarded.handled === true && forwarded.completion !== undefined ? await forwarded.completion : false;
     }).catch((error) => {
-      reportRelayFailure(PENDING_STAGE_UNDELIVERABLE_EVENT2, error);
+      reportRelayFailure(diagnosticRoute, PENDING_STAGE_UNDELIVERABLE_EVENT2, error);
       return false;
     });
   });
@@ -7827,7 +7916,9 @@ function intercom(pi, options = {}) {
     PENDING_STAGE_ROUTE_EVENT2
   ]) {
     pi.events.on(eventName, (payload) => {
-      const completion = loadHeavy(latestLifecycleContext()).then(async (handle) => {
+      const ctx = latestLifecycleContext();
+      const diagnosticRoute = ctx ? captureDiagnosticRoute(ctx) : shutdownDiagnosticRoute ?? "console";
+      const completion = loadHeavy(ctx).then(async (handle) => {
         handle.assertCurrent();
         await dispatchEventHandlers(handle.heavy, eventName, payload);
         handle.assertCurrent();
@@ -7842,7 +7933,7 @@ function intercom(pi, options = {}) {
       }
       completion.catch((error) => {
         rejectLazyResultRelay(pi, eventName, payload, error);
-        reportRelayFailure(eventName, error);
+        reportRelayFailure(diagnosticRoute, eventName, error);
       });
     });
   }

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.19-alpha.3",
+  "version": "0.9.19-alpha.5",
   "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.19-alpha.3",
+  "version": "0.9.19-alpha.5",
   "private": true,
   "description": "Atomic extension that adapts MCP (Model Context Protocol) servers into the coding agent. Fork of: https://github.com/nicobailon/pi-mcp-adapter",
   "contributors": [

package/dist/builtin/subagents/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [0.9.19-alpha.5] - 2026-09-11
+
+### Changed
+
+- The bundled debugger now uses GPT-6 Astra at `medium`, with Astra/Fable 5.1/Fable 5 fallbacks at `medium` and Sol at `high`. Its complete fallback order, other model efforts, and all other bundled agent configurations remain unchanged.
+
+## [0.9.19-alpha.4] - 2026-09-10
+
+### Breaking Changes
+
+- Renamed the terminal subagent control action from `interrupt` to `kill`. Replace `subagent({ action: "interrupt", id })` with `subagent({ action: "kill", id })`, including calls using `runId`. The old action is rejected, not aliased. Killed children cannot be resumed; launch a fresh child with explicit context for follow-up work. Command results and status report killed, while parent cancellation and lower-level host/native interruption retain their existing semantics.
+
+### Fixed
+
+- Preserved an explicit kill when parent cancellation arrives during execution-capacity waiting, without allowing a late kill to replace an earlier parent cancellation.
+- Kept grouped Intercom cancellation status consistent when a killed child has parent-cancelled siblings, while retaining each child's outcome.
+- Intercom `send` and `ask` interrupt a working foreground or background child immediately: its current model call or cancellable tool is cancelled and the message is handled in the same child execution without relaunch. Messages admitted during startup, consumed input preflight, overlapping SDK interrupt turns, or final settlement still join the original task rather than creating competing work or disappearing ahead of the result; explicit user abort and owner cancellation remain terminal.
+
 ## [0.9.19-alpha.3] - 2026-09-09
 
 ### Changed

package/dist/builtin/subagents/README.md

@@ -125,7 +125,7 @@ There is no generic `reviewer` or `planner` agent; pick the specialist whose ang
 
 ## Changing a builtin agent's model
 
-Builtin agents inherit your current Pi default model by default. This keeps new installs from depending on a provider you may not have configured. If you want a role to use a specific model, set an override instead of copying the bundled agent file.
+Builtin agents declare role-specific models and ordered fallbacks. The debugger starts with `openai-codex/gpt-6-astra:medium`, with Astra/Fable fallbacks at `medium` and Sol/Opus fallbacks at `high`. See the [bundled defaults](../coding-agent/docs/subagents.md#bundled-agents) for the other roles. If you want a role to use a specific model, set an override instead of copying the bundled agent file.
 
 For one run, pass `model` on the `subagent` call:
 
@@ -134,7 +134,7 @@ subagent({ agent: "codebase-analyzer", task: "Review this diff", model: "anthrop
 ```
 
 
-For a persistent override, edit settings. This example pins the codebase-analyzer everywhere, adds a backup model for provider failures, and keeps the other builtins on your normal default model:
+For a persistent override, edit settings. This example pins the codebase-analyzer everywhere, adds a backup model for provider failures, and keeps the other builtins on their configured defaults:
 
 ```json
 {
@@ -181,7 +181,7 @@ subagent({ agent: "codebase-analyzer", task: "Trace authentication.", wait: { ki
 subagent({ agent: "codebase-analyzer", task: "Trace authentication.", wait: { kind: "foreground", budgetMs: 30000 } })
 subagent({ action: "wait", id: taskId, budgetMs: 1000 })
 subagent({ action: "status", id: taskId })
-subagent({ action: "interrupt", id: taskId })
+subagent({ action: "kill", id: taskId })
 ```
 
 In owner-bound sessions, omitted `wait` means background. Explicit foreground waits use the owner's agent observation budget, normally 30 seconds, unless overridden. Expiry releases the caller, not the execution. Wait or inspect the returned task ID instead of launching a duplicate. Existing SDK callers without an owner retain their original execution path.
@@ -200,7 +200,7 @@ clarify → gather context → worker → fresh reviewers → worker
 
 Packaged `worker` defaults to forked context when a launch omits `context`; every other builtin runs fresh. Pass `context: "fresh"` when you intentionally want a fresh `worker` run.
 
-Child-safety boundaries are enforced at runtime by typed admission policy. In-process child sessions load bundled extensions through normal discovery. The `subagent` tool may therefore be registered when the child's active tool selection permits it, including the default no-allowlist case; an explicit allowlist may omit it. Tool presence does not grant fanout: fanout is authorized only when the resolved builtin `tools` list includes `subagent`. Typed admission policy lets a non-fanout child use only `list`, `get`, and `status`; delegation and `interrupt` receive the fanout refusal. A management-restricted child is also refused `create`, `update`, and `delete`. The bundled `pi-subagents` skill remains parent-only and is stripped from child prompts, including fanout-authorized children. No admitted child may delegate or control another child: launches and `interrupt` are refused for every child regardless of its fanout authorization. Children receive boundary instructions that they are not the parent orchestrator and must complete their assigned task directly. Forked child context filtering also removes parent-only subagent artifacts (including old hidden orchestration-instruction messages, slash/status/control messages, and prior parent `subagent` tool-call/tool-result history) while preserving ordinary prose and unrelated tool calls/results.
+Child-safety boundaries are enforced at runtime by typed admission policy. In-process child sessions load bundled extensions through normal discovery. The `subagent` tool may therefore be registered when the child's active tool selection permits it, including the default no-allowlist case; an explicit allowlist may omit it. Tool presence does not grant fanout: fanout is authorized only when the resolved builtin `tools` list includes `subagent`. Typed admission policy lets a non-fanout child use only `list`, `get`, and `status`; delegation and `kill` receive the fanout refusal. A management-restricted child is also refused `create`, `update`, and `delete`. The bundled `pi-subagents` skill remains parent-only and is stripped from child prompts, including fanout-authorized children. No admitted child may delegate or control another child: launches and `kill` are refused for every child regardless of its fanout authorization. Children receive boundary instructions that they are not the parent orchestrator and must complete their assigned task directly. Forked child context filtering also removes parent-only subagent artifacts (including old hidden orchestration-instruction messages, slash/status/control messages, and prior parent `subagent` tool-call/tool-result history) while preserving ordinary prose and unrelated tool calls/results.
 
 
 
@@ -230,13 +230,13 @@ The child can use one dedicated coordination tool:
 
 Child-side routine completion handoffs are still not expected. In parallel runs, blocking `contact_supervisor` decisions/interviews and parent-targeted `intercom.ask` wait only in the requesting child. The supervisor replies through Intercom to the exact question; the same child continues with its original context and run identity. Sends and progress updates return without a reply.
 
-An exact-child probe/commit handshake may release parallel foreground observations, including queued slots, so the parent can respond. It does not end any execution or spend a running concurrency slot. Active siblings keep working, queued siblings start once capacity becomes available, and worktrees remain until their owners finish. Do not relaunch children to answer an ask. Targeted interruption, explicit batch cancellation, and owner closure remain separate controls.
+An exact-child probe/commit handshake may release parallel foreground observations, including queued slots, so the parent can respond. It does not end any execution or spend a running concurrency slot. Active siblings keep working, queued siblings start once capacity becomes available, and worktrees remain until their owners finish. Do not relaunch children to answer an ask. Targeted kill, explicit batch cancellation, and owner closure remain separate controls.
 
 Single-child launches retain their existing terminal parent-ask handoff: the exact live child ends before broker send or waiter admission and the parent receives the verbatim question, ordered attachments, identity, and `[TASK_CONTEXT]` for a fresh child. The bridge still obtains each child's capability during admission; the child connects only when it uses Intercom.
 
 Parent-side Atomic sends grouped completion results through Intercom: one grouped message per foreground parent `subagent` run and one per detached child completion while its owning session remains live. When a workflow stage completes, Atomic cancels its still-running detached children and suppresses their late findings and completion notifications instead of forwarding them to the parent/main chat. Intercom-confirmed delivery returns a compact receipt with artifact/session paths; without that confirmation, the normal full output is preserved. Grouped messages include child Intercom targets and full child summaries.
 
-If a child appears stalled, needs-attention notices can show up in the parent session with useful next actions, such as checking `subagent({ action: "status" })`, interrupting the run, or nudging the child.
+If a child appears stalled, needs-attention notices can show up in the parent session with useful next actions, such as checking `subagent({ action: "status" })`, killing the run, or nudging the child.
 
 If messages do not show up, check the bridge from the intercom side with `intercom({ action: "status" })`.
 
@@ -263,7 +263,7 @@ Agent locations, lowest to highest priority:
 
 Project discovery also reads legacy `.agents/**/*.md` and `.pi/agents/**/*.md` files. Nested subdirectories are discovered recursively. If primary Atomic and legacy paths define the same parsed runtime agent name, the primary `.atomic/agents/` definition wins. Use `agentScope: "user" | "project" | "both"` to control discovery; `both` is the default and project definitions win runtime-name collisions.
 
-Builtin agents load at the lowest priority, so a user or project agent with the same name overrides them. They do not pin a provider model; they inherit your current Atomic default model unless you set `subagents.agentOverrides.<name>.model`. `worker` is the implementation agent for normal tasks and approved orchestrator handoffs.
+Builtin agents load at the lowest priority, so a user or project agent with the same name overrides them. Their declared models and fallback chains apply unless you set an override such as `subagents.agentOverrides.<name>.model`. `worker` is the implementation agent for normal tasks and approved orchestrator handoffs.
 
 The `codebase-online-researcher` builtin uses `web_search`, `fetch_content`, and `get_search_content`; those require [pi-web-access](https://github.com/nicobailon/pi-web-access):
 
@@ -434,7 +434,7 @@ What the bundled skill covers:
 - **Role-agent prompting guidance**: compact contract prompts instead of long scripts, what to include in role-specific meta prompts, and retrieval budgets for researchers
 - **Safety boundaries**: child agents must not run subagents, must not invent intercom targets, and must escalate unapproved decisions
 - **Intercom conventions**: when to ask vs send, and how parent-side result delivery works with `pi-intercom`
-- **Control signals**: attention signals, soft interrupts, and status
+- **Control signals**: attention signals, terminal kills, and status
 
 If you are writing an agent that orchestrates subagents, the bundled skill helps it behave correctly without guessing the patterns. If you are a human user, you do not need to read it directly; the README and prompt shortcuts encode the same workflows in user-facing form.
 
@@ -524,11 +524,11 @@ Agent definitions are not loaded into context by default. Management actions let
 |-------|------|---------|-------------|
 | `agent` | string | - | Agent name for single mode, or target for management actions. |
 | `task` | string | - | Task string for single mode. |
-| `action` | string | - | `list`, `get`, `create`, `update`, `delete`, `status`, `wait`, or `interrupt`. |
+| `action` | string | - | `list`, `get`, `create`, `update`, `delete`, `status`, `wait`, or `kill`. |
 | `config` | object/string | - | Agent config for create/update. |
 | `wait` | object | background in owner-bound sessions | `{ kind: "background" }` yields after admission; `{ kind: "foreground", budgetMs?: number }` waits before automatically yielding. |
 | `budgetMs` | number | owner wait policy | Observation budget for `action: "wait"`; not a child execution deadline. |
-| `id` | string | - | Task ID returned by an owner-bound launch for `wait`, `status`, or `interrupt`. |
+| `id` | string | - | Task ID returned by an owner-bound launch for `wait`, `status`, or `kill`. |
 | `output` | `string \| false` | agent default | Override single-agent output file. |
 | `outputMode` | `"inline" \| "file-only"` | `inline` | Return saved output inline or as a concise saved-file reference. `file-only` requires an `output` path. |
 | `reads` | `string[] \| false` | - | Single-agent files to read before execution, or `false` to disable. Relative paths resolve against the effective child `cwd`; absolute paths pass through. |
@@ -557,10 +557,10 @@ Status and control actions:
 ```ts
 subagent({ action: "status" })
 subagent({ action: "status", id: "<run-id>" })
-subagent({ action: "interrupt", id: "<run-id>" })
+subagent({ action: "kill", id: "<run-id>" })
 ```
 
-Completed, interrupted, and single-child terminal-handoff children cannot be revived by a prior run ID; 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. Explicit 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.
+Completed, killed, interrupted, and single-child terminal-handoff children cannot be revived by a prior run ID; 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: "interrupt"` to `action: "kill"`; the old action is rejected. Kill is terminal and cannot be resumed. Workflow controls use `pause`; host interrupt APIs are unchanged.
 
 ## Worktree isolation
 
@@ -681,7 +681,7 @@ Foreground runs persist their session and user-facing artifacts beside the paren
   run-history.jsonl
 ```
 
-Task-ID status, wait, and interrupt resolve the same owner as launch. Run-ID status uses the existing Rust subagent registry. Owner-bound completion delivery uses persisted intent and acknowledgement records in session history; no second PID registry or execution is created for the UI.
+Task-ID status, wait, and kill resolve the same owner as launch. Run-ID status uses the existing Rust subagent registry. Owner-bound completion delivery uses persisted intent and acknowledgement records in session history; no second PID registry or execution is created for the UI.
 
 ## Completion and output
 
@@ -716,7 +716,7 @@ This is disabled by default. Session data may contain source code, paths, enviro
 
 ## Delegation boundary
 
-Delegation is exactly one level deep, and nothing configures it. A top-level session — main chat or a workflow stage — may call `subagent`. A session that was itself admitted as a subagent child may not: every launch and `interrupt` it attempts is refused with guidance to complete its assigned task directly. The observing actions `list`, `get`, and `status` stay available to a child. Child sessions retain bundled workflow definitions as resources but do not load the workflows extension or expose its `workflow` tool; orchestration stays owned by the parent session.
+Delegation is exactly one level deep, and nothing configures it. A top-level session, main chat or a workflow stage, may call `subagent`. A session that was itself admitted as a subagent child may not: every launch and `kill` it attempts is refused with guidance to complete its assigned task directly. The observing actions `list`, `get`, and `status` stay available to a child. Child sessions retain bundled workflow definitions as resources but do not load the workflows extension or expose its `workflow` tool; orchestration stays owned by the parent session.
 
 There is no configuration option, agent frontmatter field, or tool parameter for the delegation level. The rule is enforced twice: the subagent executor refuses a child before any run starts, and the Rust `SubagentControl` admission door refuses a child deeper than the single permitted level. Admitted depth is typed admission state and is not inherited through an environment variable.
 
@@ -773,7 +773,7 @@ The main runtime files are:
 |------|---------|
 | `src/extension/index.ts` | Extension registration, tool registration, message/render wiring. |
 | `src/agents/agents.ts` | Agent discovery and frontmatter parsing. |
-| `src/runs/foreground/subagent-executor.ts` | Main execution routing for single, parallel, management, status, and interrupt actions. |
+| `src/runs/foreground/subagent-executor.ts` | Main execution routing for single, parallel, management, status, and kill actions. |
 | `src/runs/foreground/execution.ts` | Core foreground `runSync` handling. |
 | `src/runs/foreground/notify.ts` | Completion-notification delivery for a detached Intercom child. |
 | `src/runs/foreground/completion-notification.ts` | Local completion acknowledgement and ordering barrier for detached children. |

package/dist/builtin/subagents/agents/debugger.md

@@ -2,8 +2,8 @@
 name: debugger
 description: Debug and fix errors, test failures, and unexpected behavior. Use PROACTIVELY when encountering issues, analyzing stack traces, or investigating system problems.
 tools: read, edit, write, search, find, ls, bash, web_search, fetch_content, get_search_content, intercom, contact_supervisor, todo
-model: openai-codex/gpt-6-astra:xhigh
-fallbackModels: github-copilot/gpt-6-astra:xhigh, openai/gpt-6-astra:xhigh, anthropic/claude-fable-5-1:high, github-copilot/claude-fable-5-1:high, anthropic/claude-opus-5:high, github-copilot/claude-opus-5:high, anthropic/claude-fable-5:high, github-copilot/claude-fable-5:high, openai-codex/gpt-5.6-sol:xhigh, github-copilot/gpt-5.6-sol:xhigh, openai/gpt-5.6-sol:xhigh, kimi-coding/k3:max, moonshotai/kimi-k3:max, moonshotai-cn/kimi-k3:max, openai-codex/gpt-5.5:xhigh, github-copilot/gpt-5.5:xhigh, openai/gpt-5.5:xhigh, anthropic/claude-opus-4-8:high, github-copilot/claude-opus-4.8:high, xai/grok-4.6:xhigh, github-copilot/grok-4.6:xhigh, zai/glm-5.3:high, zai-coding-cn/glm-5.3:high, zai/glm-5.3-flash:high, zai-coding-cn/glm-5.3-flash:high, baseten/zai-org/GLM-5.3:high, baseten/zai-org/GLM-5.3-Flash:high, openrouter/openai/gpt-6-astra:xhigh, openrouter/anthropic/claude-fable-5-1:high, openrouter/anthropic/claude-opus-5:high, openrouter/anthropic/claude-fable-5:high, openrouter/openai/gpt-5.6-sol:xhigh, openrouter/moonshotai/kimi-k3:max, openrouter/sakana/fugu-ultra:high, openrouter/openai/gpt-5.5:xhigh, openrouter/anthropic/claude-opus-4-8:high, openrouter/x-ai/grok-4.6:xhigh, openrouter/z-ai/glm-5.3:high, openrouter/z-ai/glm-5.3-flash:high
+model: openai-codex/gpt-6-astra:medium
+fallbackModels: github-copilot/gpt-6-astra:medium, openai/gpt-6-astra:medium, anthropic/claude-fable-5-1:medium, github-copilot/claude-fable-5-1:medium, anthropic/claude-opus-5:high, github-copilot/claude-opus-5:high, anthropic/claude-fable-5:medium, github-copilot/claude-fable-5:medium, openai-codex/gpt-5.6-sol:high, github-copilot/gpt-5.6-sol:high, openai/gpt-5.6-sol:high, kimi-coding/k3:max, moonshotai/kimi-k3:max, moonshotai-cn/kimi-k3:max, openai-codex/gpt-5.5:xhigh, github-copilot/gpt-5.5:xhigh, openai/gpt-5.5:xhigh, anthropic/claude-opus-4-8:high, github-copilot/claude-opus-4.8:high, xai/grok-4.6:xhigh, github-copilot/grok-4.6:xhigh, zai/glm-5.3:high, zai-coding-cn/glm-5.3:high, zai/glm-5.3-flash:high, zai-coding-cn/glm-5.3-flash:high, baseten/zai-org/GLM-5.3:high, baseten/zai-org/GLM-5.3-Flash:high, openrouter/openai/gpt-6-astra:medium, openrouter/anthropic/claude-fable-5-1:medium, openrouter/anthropic/claude-opus-5:high, openrouter/anthropic/claude-fable-5:medium, openrouter/openai/gpt-5.6-sol:high, openrouter/moonshotai/kimi-k3:max, openrouter/sakana/fugu-ultra:high, openrouter/openai/gpt-5.5:xhigh, openrouter/anthropic/claude-opus-4-8:high, openrouter/x-ai/grok-4.6:xhigh, openrouter/z-ai/glm-5.3:high, openrouter/z-ai/glm-5.3-flash:high
 skills: tdd, playwright-cli, tmux
 ---
 

package/dist/builtin/subagents/package.json

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