@bastani/atomic 0.9.15 → 0.9.16-alpha.1

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [0.9.16-alpha.1] - 2026-08-23
+
+### Fixed
+
+- Foreground child decisions, structured interviews, and `intercom.ask` calls resolved to their launching parent now pause the retained child and return the question plus ordered attachments through the parent `subagent` call instead of deadlocking behind Intercom reply delivery. Real typed foreground children receive exact broker authorization for `contact_supervisor`, including successful non-blocking progress delivery. Bare run-ID resume preserves each paused child's session, cwd, Intercom group, execution settings, canonical index, worktree, and dirty changes while rebuilding control and detach callbacks; a sibling completed at the ask boundary stays terminal without blocking paused siblings. Queued work remains unlaunched and unauthorized, worktree diff capture and cleanup wait for terminal resume, and completed children remain non-resumable ([#2589](https://github.com/bastani-inc/atomic/issues/2589)).
+- Coalesced same-turn sibling `subagent` execution calls into one indexed parallel run instead of rejecting every call after the first. Live result, progress, control, and artifact updates and final results stay route-local without sibling data, while the TUI redraws the shared run as one aggregate parallel widget. Solitary, sequential, management, and true-overlap behavior remains unchanged ([#2588](https://github.com/bastani-inc/atomic/issues/2588)).
+
 ## [0.9.15] - 2026-08-21
 
 Cumulative release of the `0.9.15-alpha.1` prerelease. The summary below covers the user-visible outcome of that work; the per-change detail remains in the prerelease section below.

package/dist/builtin/intercom/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.9.16-alpha.1] - 2026-08-23
+
+### Breaking Changes
+
+- Parent-targeted blocking asks no longer pause a child for `subagent` resume. They end the child and return a fresh-subagent `[TASK_CONTEXT]` handoff; migrate supervisors to launch a new child with the answer ([#2604](https://github.com/bastani-inc/atomic/issues/2604)).
+
+### Changed
+
+- `contact_supervisor` decisions/interviews and child-to-parent `intercom.ask` now preserve the original question, ordered duplicate attachments, and agent identity in the fresh-start handoff before broker send or reply-waiter admission ([#2604](https://github.com/bastani-inc/atomic/issues/2604)).
+
 ## [0.9.13] - 2026-08-13
 
 Cumulative release of the `0.9.13-alpha.1` – `0.9.13-alpha.3` prereleases. The summary below covers the user-visible outcome of that work; the per-change detail remains in the prerelease sections below.

package/dist/builtin/intercom/README.md

@@ -134,7 +134,7 @@ When a blocking `intercom.ask` targets a workflow stage that has already complet
 
 When a blocking ask reaches a sibling workflow stage during an active model/tool turn, the target reserves it synchronously in the open stage generation before any asynchronous foreground-owner detach handshake. Queue insertion waits inside that reservation, and stage finalization drains it before publishing the terminal snapshot. This prevents a structured-output or other terminal tool call from overtaking a mid-turn ask. If destination-side admission genuinely cannot complete, the asker receives an exact-thread actionable error instead of consuming the full 10-minute timeout.
 
-For delegated children, queued messages and terminal lifecycle notices are ordered per child. Intercom claims the terminal child’s pre-terminal ordinary entries in FIFO order and atomically admits that prelude together with the paused, completed, or failed notice. A process-local companion bridge covers lazily loaded extensions whose event buses are distinct, while exact terminal-identity deduplication prevents double admission even when the successful terminal dispatch has no queued prelude. Failed dispatches remain retryable, and pause/resume/completion identities remain distinct. Other children’s entries remain independently queued, messages are not discarded, terminal admission does not wait for a separate model turn, and correlated ask replies still bypass unrelated queued sends.
+For delegated children, queued messages and terminal lifecycle notices are ordered per child. Intercom claims the terminal child's pre-terminal ordinary entries in FIFO order and atomically admits that prelude together with the interrupted, completed, or failed notice. A process-local companion bridge covers lazily loaded extensions whose event buses are distinct, while exact terminal-identity deduplication prevents double admission even when the successful terminal dispatch has no queued prelude. Failed dispatches remain retryable, and each terminal child identity is admitted only once. Other children's entries remain independently queued, messages are not discarded, terminal admission does not wait for a separate model turn, and correlated ask replies still bypass unrelated queued sends.
 
 ## Workflow: Planner-Worker Coordination
 
@@ -244,21 +244,21 @@ This workflow uses Atomic's in-process subagent admission. When the runtime admi
 
 `contact_supervisor` is registered from the typed admission record. The record binds the supervisor target, canonical child identity, child index, session name, and broker-issued capability to the child session; these values are not inherited from environment variables. If the parent does not grant supervisor coordination, the session falls back to the regular `intercom` tool.
 
-The child identity remains stable across foreground continuation, interruption, and cold resume. Intercom detach uses the same in-process continuation as foreground coordination, so the terminal envelope retains one canonical path.
+Parent-targeted decisions, interviews, and `intercom.ask` make the current child terminal for continuation. The parent receives the original question, ordered attachments, agent identity, and a dynamic `[TASK_CONTEXT]` handoff for a fresh child with a new run identity. Ordinary Intercom detach for sends, progress updates, and non-parent asks remains separate.
 
 ### Three Reasons
 
 | Reason | Behavior | Use When |
 |--------|----------|----------|
-| `need_decision` | Sends an ask and blocks until the supervisor replies (10-minute timeout) | The subagent is blocked, uncertain, needs approval, or faces a product/API/scope decision |
-| `interview_request` | Sends structured questions and blocks until the supervisor replies | The subagent needs multiple machine-readable answers from the supervisor in one exchange |
+| `need_decision` | In a claimed foreground run, ends the child and returns a fresh-child handoff; otherwise uses the normal ask fallback | The subagent is blocked, uncertain, needs approval, or faces a product/API/scope decision |
+| `interview_request` | In a claimed foreground run, ends the child and returns structured questions in a fresh-child handoff | The subagent needs multiple machine-readable answers from the supervisor in one exchange |
 | `progress_update` | Fire-and-forget update to the supervisor | Meaningful progress or unexpected discoveries that change the plan |
 
-Do not use `contact_supervisor` for routine completion handoffs. Return the final subagent result normally through `pi-subagents`.
+Do not use `contact_supervisor` for routine completion handoffs. Return the final subagent result normally.
 
 Cross-group delivery uses a dedicated broker protocol. Ordinary raw `send` frames always remain group-isolated and are rejected if they include a forged `channel: "supervisor"` marker. A child can cross groups only after its broker-issued capability has bound its registered socket to the exact supervisor. The broker adds the `supervisor` channel marker to validated inbound traffic so parent relays can distinguish it. Replies cross back only when `replyTo` matches a recorded supervisor message in the exact reverse direction; fabricated thread IDs do not bypass isolation.
 
-During a foreground subagent run, Atomic probes for an exact live foreground owner before delivery. The matching child reserves the request, accepts a generation-scoped detach commit, and acknowledges it before asks, sends, decisions, interviews, and progress updates enter the parent's model-visible steering queue. A busy workflow stage first reserves the message in its AgentSession generation boundary, then waits inside that admission for the same detach handshake before model-visible queue insertion. This prevents terminal stage close from overtaking the handshake while still preventing the active subagent tool from blocking the child request that would release it; unclaimed traffic and a still-current receiver whose owner disappears before commit fall back to ordinary queue insertion. One accepted commit releases foreground supervision for every active member of a parallel group while retaining each in-process session and eventual result. Blocking calls remain alive until the parent sends the exact threaded reply; fire-and-forget calls create no reply waiter. Background and unmatched traffic for ordinary sessions keeps queued-until-idle behavior, and generation cancellation/replacement invalidates stale handshakes.
+During a foreground subagent run, parent-targeted decisions, interviews, and asks are claimed before broker delivery or reply-waiter admission. The current child ends and its parent tool call receives the fresh-start handoff. Parallel claims interrupt active siblings, prevent queued tasks from launching, and retain no sibling set for later bare-run-ID continuation. Sends, progress updates, and asks to other peers retain the exact-child probe/commit detach path and ordinary Intercom delivery behavior.
 
 ### Example: Blocked Subagent Asks for Guidance
 
@@ -267,7 +267,7 @@ contact_supervisor({
   reason: "need_decision",
   message: "The auth service returns 403 instead of 401 for expired tokens. Should I treat 403 as a re-auth trigger or a hard failure?"
 })
-// → Reply from supervisor: Treat 403 as re-auth trigger. Update the token refresh logic.
+// → Parent receives a [TASK_CONTEXT] handoff and launches a fresh child with the answer.
 ```
 
 ### Example: Structured Supervisor Interview
@@ -284,7 +284,7 @@ contact_supervisor({
     ]
   }
 })
-// → Reply from supervisor: { "responses": [{ "id": "api", "value": "Stable API" }, ...] }
+// → Parent includes the structured supervisor answer in a fresh child's task.
 ```
 
 ### Example: Progress Update

package/dist/builtin/intercom/contact-supervisor-tool.ts

@@ -4,6 +4,7 @@ import { Type } from "typebox";
 import { Text } from "@earendil-works/pi-tui";
 import type { IntercomClient } from "./broker/client.js";
 import type { ReplyWait, ReplyWaitAdmission } from "./reply-waiter.ts";
+import { requestParentAskHandoff } from "./parent-ask-handoff.js";
 import { renderContactSupervisorResult } from "./result-renderers.js";
 import {
   type ChildOrchestratorMetadata,
@@ -42,18 +43,18 @@ export function registerContactSupervisorTool(pi: ExtensionAPI, deps: ContactSup
     pi.registerTool({
       name: "contact_supervisor",
       label: "Contact Supervisor",
-      description: "Subagent-only tool for contacting the supervisor agent that delegated this task. Use need_decision when blocked, uncertain, needing approval, or facing a product/API/scope decision before continuing; this waits for the supervisor's reply. Use interview_request when multiple structured questions need supervisor answers; this also waits for a reply. Use progress_update only for meaningful progress or unexpected discoveries that change the plan; this does not wait for a reply. Do not use for routine completion handoffs.",
-      promptSnippet: "Subagent-only: contact the supervisor for decisions, structured interviews, or meaningful plan-changing updates. Do not use for routine completion handoffs.",
+      description: "Subagent-only tool for contacting the supervisor agent that delegated this task. In a live foreground child, need_decision and interview_request end the child and return a fresh-subagent handoff to the supervisor; fallback Intercom delivery waits for a reply when no foreground owner claims the request. progress_update is fire-and-forget. Do not use for routine completion handoffs.",
+      promptSnippet: "Subagent-only: yield decisions or structured interviews to the supervisor for a fresh-child follow-up, or send meaningful plan-changing progress updates.",
       promptGuidelines: [
-        "Use contact_supervisor with reason='need_decision' when a subagent is blocked, uncertain, needs approval, or faces a product/API/scope decision before continuing.",
-        "Use contact_supervisor with reason='interview_request' when the child needs multiple structured answers from the supervisor in one blocking exchange.",
+        "Use contact_supervisor with reason='need_decision' when a subagent is blocked, uncertain, needs approval, or faces a product/API/scope decision. A claimed foreground request ends this child; do not wait for a reply.",
+        "Use contact_supervisor with reason='interview_request' when the child needs multiple structured answers. A claimed foreground request ends this child; the supervisor starts a fresh child with the answers.",
         "Use contact_supervisor with reason='progress_update' only for meaningful progress or unexpected discoveries that change the plan.",
         "Do not use contact_supervisor for routine completion handoffs; return the final subagent result normally.",
       ],
       parameters: Type.Object({
         reason: Type.String({
           enum: ["need_decision", "progress_update", "interview_request"],
-          description: "Contact reason: 'need_decision' waits for a reply; 'interview_request' sends structured questions and waits for a reply; 'progress_update' sends a non-blocking update",
+          description: "Contact reason: 'need_decision' and 'interview_request' yield a live foreground child for a fresh follow-up; 'progress_update' sends a non-blocking update",
         }),
         message: Type.Optional(Type.String({
           description: "Decision request, optional interview note, or meaningful progress update for the supervisor",
@@ -79,7 +80,7 @@ export function registerContactSupervisorTool(pi: ExtensionAPI, deps: ContactSup
             details: { error: true },
           };
         }
-        if ((reason === "need_decision" || reason === "progress_update") && typeof params.message !== "string") {
+        if (reason === "progress_update" && typeof params.message !== "string") {
           return {
             content: [{ type: "text", text: `Missing 'message' parameter for reason '${reason}'.` }],
             isError: true,
@@ -97,36 +98,71 @@ export function registerContactSupervisorTool(pi: ExtensionAPI, deps: ContactSup
           };
         }
         const supervisorInterview = interviewValidation?.ok === true ? interviewValidation.interview : undefined;
+		const metadata = getMetadata();
+		if (reason === "need_decision" && typeof params.message !== "string" && !metadata) {
+			return {
+				content: [{ type: "text", text: `Missing 'message' parameter for reason '${reason}'.` }],
+				isError: true,
+				details: { error: true },
+			};
+		}
 
-        let connectedClient: IntercomClient;
-        try {
-          connectedClient = await ensureConnected("tool");
-        } catch (error) {
-          return {
-            content: [{ type: "text", text: `Intercom not connected: ${getErrorMessage(error)}` }],
-            isError: true,
-            details: { error: true },
-          };
-        }
+		if (!metadata) {
+			return {
+				content: [{ type: "text", text: "Supervisor contact is unavailable for this session" }],
+				isError: true,
+				details: { error: true },
+			};
+		}
+		if (signal?.aborted) {
+			return {
+				content: [{ type: "text", text: "Cancelled" }],
+				isError: true,
+				details: { error: true },
+			};
+		}
+		if (
+			reason !== "progress_update" &&
+			requestParentAskHandoff(pi.events, metadata, {
+				kind: reason === "interview_request" ? "interview" : "decision",
+				question: typeof params.message === "string" ? params.message : "",
+				...(supervisorInterview ? { interview: supervisorInterview } : {}),
+			})
+		) {
+			return {
+				content: [{ type: "text", text: "Parent ask claimed; this child is ending for a fresh subagent start." }],
+				isError: false,
+				details: { yielded: true },
+			};
+		}
 
-        syncPresenceIdentity(ctx.sessionManager.getSessionId());
+		if (reason === "need_decision" && typeof params.message !== "string") {
+			return {
+				content: [{ type: "text", text: `Missing 'message' parameter for reason '${reason}'.` }],
+				isError: true,
+				details: { error: true },
+			};
+		}
+		let connectedClient: IntercomClient;
+		try {
+			connectedClient = await ensureConnected("tool");
+		} catch (error) {
+			return {
+				content: [{ type: "text", text: `Intercom not connected: ${getErrorMessage(error)}` }],
+				isError: true,
+				details: { error: true },
+			};
+		}
 
-        if (signal?.aborted) {
-          return {
-            content: [{ type: "text", text: "Cancelled" }],
-            isError: true,
-            details: { error: true },
-          };
-        }
+		syncPresenceIdentity(ctx.sessionManager.getSessionId());
 
-        const metadata = getMetadata();
-        if (!metadata) {
-          return {
-            content: [{ type: "text", text: "Supervisor contact is unavailable for this session" }],
-            isError: true,
-            details: { error: true },
-          };
-        }
+		if (signal?.aborted) {
+			return {
+				content: [{ type: "text", text: "Cancelled" }],
+				isError: true,
+				details: { error: true },
+			};
+		}
         let sendTo: string;
         if (connectedClient.supervisorSessionId || metadata.supervisor) {
           sendTo = connectedClient.supervisorSessionId ?? metadata.supervisor!.supervisorSessionId;

package/dist/builtin/intercom/index-heavy.ts

@@ -518,6 +518,7 @@ export default function piIntercomExtension(pi: ExtensionAPI, testOverrides: Int
     hasReplyWaiter: () => replyWaiters.has(),
   });
   registerIntercomTool(pi, {
+    childOrchestratorMetadata: currentChildOrchestratorMetadata,
     ensureConnected,
     syncPresenceIdentity,
     beginReplyWait: (from, replyTo, signal) => replyWaiters.begin(from, replyTo, signal),

package/dist/builtin/intercom/index.ts

@@ -230,22 +230,28 @@ export default function intercom(pi: ExtensionAPI, options: LightweightIntercomO
 		return promise;
 	}
   let typedContactSupervisorRegistered = hasSubagentIntercomEnv();
+  const activateTypedContactSupervisor = (): void => {
+    const activeTools = pi.getActiveTools();
+    if (!activeTools.includes("contact_supervisor")) pi.setActiveTools([...activeTools, "contact_supervisor"]);
+  };
   const registerTypedContactSupervisor = (): void => {
-    if (typedContactSupervisorRegistered) return;
-    typedContactSupervisorRegistered = true;
-    pi.registerTool({
-      name: "contact_supervisor",
-      label: "Contact Supervisor",
-      description: "Subagent-only tool for contacting the supervisor agent that delegated this task.",
-      promptSnippet: "Subagent-only: contact the supervisor for decisions, interviews, or meaningful updates.",
-      parameters: Type.Object({
-        reason: Type.String({ enum: ["need_decision", "progress_update", "interview_request"] }),
-        message: Type.Optional(Type.String()),
-        interview: Type.Optional(Type.Unknown()),
-      }),
-      execute: (...args) => executeHeavyTool(loadHeavy, "contact_supervisor", args),
-      renderResult: (...args) => renderHeavyToolResult(loadedHeavy?.heavy ?? null, "contact_supervisor", args),
-    });
+    if (!typedContactSupervisorRegistered) {
+      typedContactSupervisorRegistered = true;
+      pi.registerTool({
+        name: "contact_supervisor",
+        label: "Contact Supervisor",
+        description: "Subagent-only tool for contacting the supervisor agent that delegated this task.",
+        promptSnippet: "Subagent-only: contact the supervisor for decisions, interviews, or meaningful updates.",
+        parameters: Type.Object({
+          reason: Type.String({ enum: ["need_decision", "progress_update", "interview_request"] }),
+          message: Type.Optional(Type.String()),
+          interview: Type.Optional(Type.Unknown()),
+        }),
+        execute: (...args) => executeHeavyTool(loadHeavy, "contact_supervisor", args),
+        renderResult: (...args) => renderHeavyToolResult(loadedHeavy?.heavy ?? null, "contact_supervisor", args),
+      });
+    }
+    activateTypedContactSupervisor();
   };
   pi.on("session_start", async (event, ctx) => {
     const typedIdentity = ctx.subagentPolicy?.intercom;

package/dist/builtin/intercom/intercom-tool.ts

@@ -3,9 +3,11 @@ import { randomUUID } from "crypto";
 import { Type } from "typebox";
 import { Text } from "@earendil-works/pi-tui";
 import type { IntercomClient } from "./broker/client.js";
+import { requestParentAskHandoff } from "./parent-ask-handoff.js";
 import type { ReplyWait, ReplyWaitAdmission } from "./reply-waiter.ts";
 import { renderIntercomResult } from "./result-renderers.js";
 import {
+  type ChildOrchestratorMetadata,
   formatAttachments,
   formatSessionListRow,
   getErrorMessage,
@@ -17,6 +19,7 @@ import { resolveSessionTargetId } from "./session-target.js";
 import { normalizeGroup, validateRuntimeGroup } from "./group.js";
 
 interface IntercomToolDeps {
+  childOrchestratorMetadata?: ChildOrchestratorMetadata | null | (() => ChildOrchestratorMetadata | null);
   ensureConnected(reason: "tool"): Promise<IntercomClient>;
   syncPresenceIdentity(sessionId: string): void;
   resolveSessionTarget?(activeClient: IntercomClient, nameOrId: string): Promise<string | null>;
@@ -36,8 +39,11 @@ interface IntercomToolDeps {
 }
 
 export function registerIntercomTool(pi: ExtensionAPI, deps: IntercomToolDeps): void {
-  const { ensureConnected, syncPresenceIdentity, beginReplyWait, hasReplyWaiter } = deps;
+  const { childOrchestratorMetadata, ensureConnected, syncPresenceIdentity, beginReplyWait, hasReplyWaiter } = deps;
   const resolveTarget = deps.resolveSessionTarget ?? resolveSessionTargetId;
+  const getMetadata = typeof childOrchestratorMetadata === "function"
+    ? childOrchestratorMetadata
+    : () => childOrchestratorMetadata ?? null;
   const activeReplyTracker = (): ReplyTracker =>
     typeof deps.replyTracker === "function" ? deps.replyTracker() : deps.replyTracker;
   pi.registerTool({
@@ -306,7 +312,7 @@ does not grant cross-group access: contact_supervisor is the only cross-group pa
         }
 
         case "ask": {
-          if (!to || !message) {
+          if (!to) {
             return {
               content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
               isError: true,
@@ -314,14 +320,6 @@ does not grant cross-group access: contact_supervisor is the only cross-group pa
             };
           }
 
-          if (hasReplyWaiter()) {
-            return {
-              content: [{ type: "text", text: "Already waiting for a reply" }],
-              isError: true,
-              details: { error: true },
-            };
-          }
-
           if (_signal?.aborted) {
             return {
               content: [{ type: "text", text: "Cancelled" }],
@@ -332,6 +330,36 @@ does not grant cross-group access: contact_supervisor is the only cross-group pa
           let wait: ReplyWait | null = null;
 
           try {
+            const metadata = getMetadata();
+            const currentSupervisorId = connectedClient.supervisorSessionId ?? undefined;
+            const metadataSupervisorId = metadata?.supervisor?.supervisorSessionId;
+            const directParentTarget = Boolean(
+              metadata &&
+              (to === metadata.orchestratorTarget ||
+                to === currentSupervisorId ||
+                to === metadataSupervisorId),
+            );
+            const claimParentAsk = (resolvedTargetId: string): boolean =>
+              Boolean(
+                metadata &&
+                requestParentAskHandoff(pi.events, metadata, {
+                  kind: "intercom",
+                  question: typeof message === "string" ? message : "",
+                  attachments,
+                  resolvedTargetId,
+                }),
+              );
+            if (
+              directParentTarget &&
+              claimParentAsk(currentSupervisorId ?? metadataSupervisorId ?? to)
+            ) {
+              return {
+                content: [{ type: "text", text: "Parent ask claimed; this child is ending for a fresh subagent start." }],
+                isError: false,
+                details: { yielded: true },
+              };
+            }
+
             const sendTo = await resolveTarget(connectedClient, to) ?? to;
             if (_signal?.aborted) {
               return {
@@ -347,6 +375,34 @@ does not grant cross-group access: contact_supervisor is the only cross-group pa
                 details: { error: true },
               };
             }
+            if (metadata && !directParentTarget) {
+              const authoritativeParent = [currentSupervisorId, metadataSupervisorId].find(
+                (candidate) => candidate === sendTo,
+              );
+              const resolvedParent =
+                authoritativeParent ?? await resolveTarget(connectedClient, metadata.orchestratorTarget);
+              if (resolvedParent !== null && resolvedParent === sendTo && claimParentAsk(sendTo)) {
+                return {
+                  content: [{ type: "text", text: "Parent ask claimed; this child is ending for a fresh subagent start." }],
+                  isError: false,
+                  details: { yielded: true },
+                };
+              }
+            }
+            if (!message) {
+              return {
+                content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
+                isError: true,
+                details: { error: true },
+              };
+            }
+            if (hasReplyWaiter()) {
+              return {
+                content: [{ type: "text", text: "Already waiting for a reply" }],
+                isError: true,
+                details: { error: true },
+              };
+            }
             const questionId = randomUUID();
             const admission = beginReplyWait(sendTo, questionId, _signal);
             if (!admission.ok) {

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.15",
+  "version": "0.9.16-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/intercom/parent-ask-handoff.ts

@@ -0,0 +1,72 @@
+import { isStaleExtensionContextError, type ExtensionAPI } from "@bastani/atomic";
+import type {
+  ChildOrchestratorMetadata,
+  SupervisorInterviewRequest,
+} from "./intercom-utils.js";
+import type { Attachment } from "./types.js";
+
+export const PARENT_ASK_HANDOFF_REQUEST_EVENT = "subagent:parent-ask-handoff-request";
+
+const PROCESS_PARENT_ASK_CLAIMS = Symbol.for("atomic/subagents/parent-ask-claims@1");
+
+type ProcessParentAskClaimHandler = (payload: unknown) => void;
+
+interface ProcessParentAskClaimRegistry {
+  handlers: Set<ProcessParentAskClaimHandler>;
+}
+
+function processClaimRegistry(): ProcessParentAskClaimRegistry | undefined {
+  const slots = globalThis as typeof globalThis & Record<symbol, ProcessParentAskClaimRegistry | undefined>;
+  return slots[PROCESS_PARENT_ASK_CLAIMS];
+}
+
+export type ParentAskKind = "decision" | "interview" | "intercom";
+
+export interface ParentAskHandoffRequest {
+  runId: string;
+  index: number;
+  agent: string;
+  childIntercomTarget: string;
+  orchestratorTarget: string;
+  kind: ParentAskKind;
+  question: string;
+  attachments?: Attachment[];
+  interview?: SupervisorInterviewRequest;
+  resolvedTargetId?: string;
+  taskContext?: string;
+  claimed: boolean;
+}
+
+export function requestParentAskHandoff(
+  events: ExtensionAPI["events"] | undefined,
+  metadata: ChildOrchestratorMetadata,
+  input: Pick<ParentAskHandoffRequest, "kind" | "question" | "attachments" | "interview" | "resolvedTargetId">,
+): boolean {
+  const index = Number(metadata.index);
+  if (!events || !Number.isInteger(index) || index < 0 || !metadata.sessionName) return false;
+  const request: ParentAskHandoffRequest = {
+    runId: metadata.runId,
+    index,
+    agent: metadata.agent,
+    childIntercomTarget: metadata.sessionName,
+    orchestratorTarget: metadata.orchestratorTarget,
+    kind: input.kind,
+    question: input.question,
+    ...(input.attachments ? { attachments: input.attachments } : {}),
+    ...(input.interview ? { interview: input.interview } : {}),
+    ...(input.resolvedTargetId ? { resolvedTargetId: input.resolvedTargetId } : {}),
+    claimed: false,
+  };
+  try {
+    events.emit(PARENT_ASK_HANDOFF_REQUEST_EVENT, request);
+  } catch (error) {
+    if (!isStaleExtensionContextError(error)) throw error;
+  }
+  if (!request.claimed) {
+    for (const handler of [...(processClaimRegistry()?.handlers ?? [])]) {
+      handler(request);
+      if (request.claimed) break;
+    }
+  }
+  return request.claimed;
+}

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.15",
+  "version": "0.9.16-alpha.1",
   "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,19 @@
 
 ## [Unreleased]
 
+## [0.9.16-alpha.1] - 2026-08-23
+
+### Breaking Changes
+
+- Removed the public `subagent({ action: "resume" })` action and its `index`/`message` inputs. Completed, interrupted, and parent-question children are terminal; migrate follow-ups to a fresh `subagent({ agent, task })` launch with explicit `[TASK_CONTEXT]` and expect a new run identity ([#2604](https://github.com/bastani-inc/atomic/issues/2604)).
+
+### Changed
+
+- Parent-targeted `contact_supervisor` and Intercom asks now end the child and return the verbatim question, ordered attachments, agent identity, and a dynamic fresh-child handoff. Parallel asks no longer retain sibling sets for bare-run-ID continuation ([#2604](https://github.com/bastani-inc/atomic/issues/2604)).
+
+### Fixed
+- Coalesced same-turn sibling `subagent` execution calls into one indexed parallel run instead of rejecting every call after the first. Live result, progress, control, and artifact updates and final results stay route-local without sibling data, while the TUI redraws the shared run as one aggregate parallel widget. Solitary, sequential, management, and true-overlap behavior remains unchanged ([#2588](https://github.com/bastani-inc/atomic/issues/2588)).
+
 ## [0.9.15] - 2026-08-21
 
 Cumulative release of the `0.9.15-alpha.1` prerelease. The summary below covers the user-visible outcome of that work; the per-change detail remains in the prerelease section below.