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

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

@@ -523,6 +523,7 @@ var init_client = __esm(() => {
     _supervisorSessionId = null;
     _messageSource;
     pendingSends = new PendingSendRegistry;
+    pendingReplyTargets = new Map;
     pendingGroupLists = new Map;
     pendingLists = new Map;
     pendingPresence = new Map;
@@ -730,6 +731,16 @@ var init_client = __esm(() => {
           this.emit("_registration_failed", new Error(brokerMessage.reason));
           break;
         }
+        case "question_target": {
+          const { messageId, attemptId, sessionId } = brokerMessage;
+          if (typeof messageId !== "string" || typeof attemptId !== "string" || typeof sessionId !== "string") {
+            throw new Error("Invalid question_target message");
+          }
+          const pending = this.pendingReplyTargets.get(attemptId);
+          if (pending?.messageId === messageId)
+            pending.bind(sessionId);
+          break;
+        }
         case "sessions": {
           const { requestId, sessions, workflowStages, workflowFutureStages } = brokerMessage;
           if (typeof requestId !== "string" || !Array.isArray(sessions) || !sessions.every(isSessionInfo) || workflowStages !== undefined && !isWorkflowStageRosterEntries(workflowStages) || workflowFutureStages !== undefined && !isWorkflowFutureStageRosterEntries(workflowFutureStages)) {
@@ -1246,12 +1257,16 @@ var init_client = __esm(() => {
         source: this._messageSource,
         content: { text: options.text, attachments: options.attachments }
       };
+      if (options.onReplyTarget !== undefined) {
+        this.pendingReplyTargets.set(acquired.attempt.attemptId, { messageId, bind: options.onReplyTarget });
+      }
       try {
         writeMessage(socket, {
           type,
           to,
           ...options.logicalTarget === undefined ? {} : { logicalTarget: options.logicalTarget },
           ...options.requirePendingReply === undefined ? {} : { requirePendingReply: options.requirePendingReply },
+          ...options.onReplyTarget === undefined ? {} : { resolveReplyTarget: true },
           message,
           attemptId: acquired.attempt.attemptId,
           ...extra
@@ -1259,6 +1274,10 @@ var init_client = __esm(() => {
       } catch (error) {
         this.pendingSends.reject(acquired.attempt, toError(error));
       }
+      const clearReplyTarget = () => {
+        this.pendingReplyTargets.delete(acquired.attempt.attemptId);
+      };
+      acquired.attempt.promise.then(clearReplyTarget, clearReplyTarget);
       return acquired.attempt.promise;
     }
     updatePresence(updates) {
@@ -1799,6 +1818,10 @@ class ReplyWaiterRegistry {
       ok: true,
       wait: {
         promise,
+        bindSender: (sender) => {
+          if (this.waiters.get(replyTo) === record)
+            record.from = sender;
+        },
         cancel: (error) => record.reject(error)
       }
     };
@@ -1966,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;
@@ -2414,7 +2442,8 @@ function formatSessionListRow(session, currentCwd, isSelf) {
   const name = session.name || "Unnamed session";
   const normalizedGroup = normalizeGroup(session.group);
   const groupTag = normalizedGroup !== DEFAULT_GROUP ? `group: ${normalizedGroup}` : undefined;
-  const tags = [isSelf ? "self" : session.cwd === currentCwd ? "same cwd" : undefined, session.status, groupTag].filter((tag) => Boolean(tag));
+  const capabilityTag = session.replyCapability === undefined ? undefined : `replyCapability: ${session.replyCapability}`;
+  const tags = [isSelf ? "self" : session.cwd === currentCwd ? "same cwd" : undefined, session.status, capabilityTag, groupTag].filter((tag) => Boolean(tag));
   const suffix = tags.length ? ` [${tags.join(", ")}]` : "";
   return `• ${name} (${session.id}) — ${session.cwd} (${session.model})${suffix}`;
 }
@@ -3755,7 +3784,8 @@ ${message}${attachmentText}`);
                 text: message ?? "",
                 attachments,
                 replyTo,
-                expectsReply: true
+                expectsReply: true,
+                ...parseWorkflowStageTarget(to)?.kind === "path" ? { onReplyTarget: wait.bindSender } : {}
               });
               if (sendResult.queued === true) {
                 retryIdentities.release(retryIdentity);
@@ -4487,7 +4517,10 @@ var init_overlay = __esm(() => {
 function registerIntercomLifecycle(pi, deps) {
   const activeReplyTracker = () => typeof deps.replyTracker === "function" ? deps.replyTracker() : deps.replyTracker;
   let hasActiveSession = false;
+  let unbindStageClose;
   async function cleanupRuntime(reason) {
+    unbindStageClose?.();
+    unbindStageClose = undefined;
     deps.setRuntimeStarted(false);
     deps.setShuttingDown(true);
     deps.setDisposed(true);
@@ -4538,6 +4571,12 @@ function registerIntercomLifecycle(pi, deps) {
     deps.setSessionStartedAt(Date.now());
     deps.setAgentRunning(false);
     deps.activeTools.clear();
+    const stage = ctx.orchestrationContext;
+    const closeSignal = stage?.kind === "workflow-stage" ? stage.messageAdmission?.boundary?.closeSignal : undefined;
+    closeSignal?.addEventListener("abort", deps.syncPresenceStatus, { once: true });
+    unbindStageClose = () => closeSignal?.removeEventListener("abort", deps.syncPresenceStatus);
+    if (closeSignal?.aborted)
+      deps.syncPresenceStatus();
   });
   pi.on("session_shutdown", async () => {
     if (!hasActiveSession)
@@ -4545,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", () => {
@@ -5640,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 = {
@@ -5648,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));
   };
 }
@@ -6000,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 () => {
@@ -6019,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;
@@ -6078,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
@@ -6263,7 +6326,8 @@ function piIntercomExtension(pi, testOverrides = {}) {
   }
   function currentStatus() {
     const activeToolName = activeTools.values().next().value;
-    const lifecycleStatus = activeToolName ? `tool:${activeToolName}` : agentRunning ? "thinking" : "idle";
+    const stage = getLiveContext()?.orchestrationContext;
+    const lifecycleStatus = stage?.kind === "workflow-stage" && stage.messageAdmission?.isOpen() === false ? `closed · reply: ${stage.lateMessageRouter === undefined ? "unavailable" : "post-mortem only"}` : activeToolName ? `tool:${activeToolName}` : agentRunning ? "thinking" : "idle";
     return config.status ? `${lifecycleStatus} · ${config.status}` : lifecycleStatus;
   }
   function resolveSessionHomeGroup() {
@@ -6411,7 +6475,12 @@ function piIntercomExtension(pi, testOverrides = {}) {
     const stageAdmission = liveContext.orchestrationContext?.kind === "workflow-stage" ? liveContext.orchestrationContext.messageAdmission : undefined;
     const stageClosed = stageAdmission?.isOpen() === false;
     if (stageClosed) {
-      routeClosedWorkflowStageMessage(entry, inboundDeliveries, replyTracker, replyWaiters.pending(), () => sendIncomingMessage(entry, isDeliveryFeedback(message) ? "prelude" : "trigger", messageGeneration, false), () => client, () => Boolean(getLiveContext(liveContext, messageGeneration)), (runId) => stageAdmission.boundary.ownsSubagentRun(runId));
+      routeClosedWorkflowStageMessage(entry, inboundDeliveries, replyTracker, replyWaiters.pending(), () => {
+        if (message.expectsReply === true && liveContext.orchestrationContext?.lateMessageRouter === undefined) {
+          throw new Error("Workflow stage is closed and cannot reply because post-mortem routing is unavailable. Contact a live stage or start new work with explicit context.");
+        }
+        return sendIncomingMessage(entry, isDeliveryFeedback(message) ? "prelude" : "trigger", messageGeneration, false);
+      }, () => client, () => Boolean(getLiveContext(liveContext, messageGeneration)), (runId) => stageAdmission.boundary.ownsSubagentRun(runId));
       return;
     }
     const admission = inboundDeliveries.admit(from, message);
@@ -6439,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 () => {
@@ -6459,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()) {
@@ -6502,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();
@@ -7078,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();
@@ -7095,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();
@@ -7361,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 = {}) {
@@ -7372,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++);
@@ -7455,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");
@@ -7471,6 +7588,7 @@ function intercom(pi, options = {}) {
       return handle;
     }
     let promise;
+    let replayCtx = null;
     promise = (async () => {
       const captured = {
         tools: new Map,
@@ -7479,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;
@@ -7491,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 {
@@ -7503,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);
@@ -7521,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;
@@ -7633,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;
@@ -7650,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;
@@ -7771,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;
     });
   });
@@ -7787,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();
@@ -7802,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.2",
+  "version": "0.9.19-alpha.4",
   "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/types.ts

@@ -124,7 +124,7 @@ export type ClientMessage =
 	| { type: "join_group"; requestId: string; group: string }
 	| { type: "leave_group"; requestId: string; group?: string }
   | { type: "authorize_supervisor"; requestId: string; childName: string; capability?: string }
-  | { type: "send" | "supervisor_send"; to: string; logicalTarget?: string; requirePendingReply?: true; message: Message; attemptId?: string }
+  | { type: "send" | "supervisor_send"; to: string; logicalTarget?: string; requirePendingReply?: true; resolveReplyTarget?: true; message: Message; attemptId?: string }
 	| {
 			type: "send_pending_stage_notification";
 			runId: string;
@@ -168,6 +168,7 @@ export type ClientMessage =
 export type BrokerMessage =
   | { type: "registered"; sessionId: string; supervisorSessionId?: string }
   | { type: "registration_failed"; reason: string }
+  | { type: "question_target"; messageId: string; attemptId: string; sessionId: string }
  | { type: "sessions"; requestId: string; sessions: SessionInfo[]; workflowStages?: WorkflowStageRosterEntry[]; workflowFutureStages?: WorkflowFutureStageRosterEntry[] }
 	| { type: "groups"; requestId: string; groups: GroupSummary[] }
 	| { type: "membership_ack"; requestId: string; groups: string[] }

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.19-alpha.2",
+  "version": "0.9.19-alpha.4",
   "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.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
+
+- Reduced default top-level parallel subagent concurrency from 4 to 3. Explicit configuration and per-call overrides remain honored; the separate per-parent native turn cap remains 4.
+
 ## [0.9.19-alpha.2] - 2026-09-08
 
 ### Added

package/dist/builtin/subagents/README.md

@@ -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" })`.
 
@@ -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. |
@@ -536,7 +536,7 @@ Agent definitions are not loaded into context by default. Management actions let
 | `skill` | `string \| string[] \| false` | agent default | Override skills or disable all. |
 | `model` | string | agent default | Override model. |
 | `tasks` | array | - | Top-level parallel tasks. Supports `agent`, `task`, `cwd`, `count`, `output`, `outputMode`, `reads`, `progress`, `skill`, and `model`. |
-| `concurrency` | number | config or `4` | Top-level parallel concurrency. |
+| `concurrency` | number | config or `3` | Top-level parallel concurrency. |
 | `worktree` | boolean | false | Create isolated git worktrees for parallel tasks. |
 | `context` | `fresh \| fork` | agent default or `fresh` | `fork` creates real branched sessions from the parent leaf. Packaged `worker` defaults to `fork`; every other builtin runs fresh. |
 | `agentScope` | `user \| project \| both` | `both` | Agent discovery scope. Project wins on collisions. |
@@ -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
 
@@ -603,7 +603,7 @@ Subagent configuration controls discovery, parallel limits, session storage, con
 }
 ```
 
-`maxTasks` defaults to `50`; `concurrency` defaults to `4`. `maxTasks` can set a lower per-call task limit but cannot exceed the hard maximum of `50`. Per-call `concurrency` takes precedence.
+`maxTasks` defaults to `50`; `concurrency` defaults to `3`. `maxTasks` can set a lower per-call task limit but cannot exceed the hard maximum of `50`. Per-call `concurrency` takes precedence.
 
 ### `defaultSessionDir`
 
@@ -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. |