@bastani/atomic 0.9.6 → 0.9.7

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## [Unreleased]
 
+## [0.9.7] - 2026-07-12
+
+### Added
+
+- Added a shared convergence contract to the bundled `goal` and `ralph` workflows: implementation starts from an observable acceptance/contract matrix derived from the literal objective/acceptance criteria (with explicit state/transition/invariant modeling for stateful work), reviewers independently derive adversarial checks from the literal contract before relying on worker receipts or worker-authored tests, reproduced findings require durable regression evidence before they count as resolved, and each review round persists a deduplicated cross-reviewer `consolidated_findings` batch that the next worker turn repairs together instead of one finding per turn. Literal-contract scope controls are preserved throughout, so nothing beyond the user's requirements is forced.
+- Added a "Choosing an Execution Shape" section to `docs/workflows.md`: an agent-facing decision ladder covering inline work, inline subagent delegation, direct one-off `task`/`tasks`/`chain` shapes, named/builtin workflows, custom TypeScript workflows, and composed/nested workflows; a six-dimension scoring rubric (structure, verifiability, iteration, risk, duration, isolation) with hard-signal overrides; a "Task queues and software factories" playbook for fire-and-forget requests like "address all open issues" (enumerate and dependency-classify first, fan out independent items as separate per-item workflow runs in bounded waves with per-item worktrees/PRs, compose dependent items into one parent graph that nests proven children, and mix both for clustered queues); and a "Prompting the choice" guide listing the user prompt levers (naming the shape, acceptance criteria, loop wording, evidence requests, scope boundaries, and queue policy) that steer the agent's execution-shape decision.
+- Added a "Context-Mode-Aware Prompt Text" section to `docs/workflows.md` documenting that stage prompts must not describe their own context mode, fresh stages must not reference invisible context (prior conversation, sibling stages, graph topology), and forked continuation prompts should send only the delta with a pointer back to guidance already established in the forked history.
+
+### Changed
+
+- Accelerated PR/main CI by running platform-independent validation once on Linux while retaining installed-package Node integration and release-archive smoke coverage on Linux and Windows, and by reusing caller-installed dependencies and package builds during binary assembly. Test suites now have one bounded, observable flake-recovery attempt with preserved logs, environment/resource diagnostics, CI annotations, and no retries for deterministic workflow/release/package/publish gates. Release publication no longer reruns the full PR suite: a protected-default-branch integrity gate proves the release commit is generated from a parent already integrated into `main`, contains exactly the expected version and shrinkwrap material, and pins that immutable SHA across release jobs before preserving all release-specific metadata, docs, native, binary, package, and npm provenance checks.
+- Changed bundled `goal` completion to evidence closure rather than reviewer agreement alone: reviewer quorum can only complete the run when no objective-relevant blocking finding from any reviewer in the current round remains unresolved, unresolved findings are recorded in the inspectable reducer decision reason, and the bounded loop still stops at `max_turns` as `needs_human`. Severity labels alone no longer dismiss objective-relevant findings in Goal or Ralph: `required_by_objective` findings block at any priority (P3 included), while `consistent_with_objective` P3 nice-to-haves stay non-blocking.
+
+### Fixed
+
+- Fixed retryable-failure classification across main-chat retry/fallback, workflow stage fallback, and subagent fallback to treat provider usage-limit exhaustion (for example `Codex error: The usage limit has been reached`, plus `usage_limit_reached`/`insufficient_quota`-style codes) as a retryable quota/rate-limit failure, so configured `fallbackModels` advance to the next candidate provider/model instead of dead-ending the turn, stage, or run. Provider messages that flatten the token into free text (for example `usage_limit_reached` or `usage-limit`, matched with space/underscore/hyphen/joined separators) classify the same as the structured codes across all three paths. Nested cause/diagnostic and session-shaped error payloads classify the same way; cancellations, safety refusals, task/tool failures, and unrelated errors remain non-retryable.
+
+## [0.9.7-alpha.1] - 2026-07-12
+
+### Added
+
+- Added a shared convergence contract to the bundled `goal` and `ralph` workflows: implementation starts from an observable acceptance/contract matrix derived from the literal objective/acceptance criteria (with explicit state/transition/invariant modeling for stateful work), reviewers independently derive adversarial checks from the literal contract before relying on worker receipts or worker-authored tests, reproduced findings require durable regression evidence before they count as resolved, and each review round persists a deduplicated cross-reviewer `consolidated_findings` batch that the next worker turn repairs together instead of one finding per turn. Literal-contract scope controls are preserved throughout, so nothing beyond the user's requirements is forced.
+- Added a "Choosing an Execution Shape" section to `docs/workflows.md`: an agent-facing decision ladder covering inline work, inline subagent delegation, direct one-off `task`/`tasks`/`chain` shapes, named/builtin workflows, custom TypeScript workflows, and composed/nested workflows; a six-dimension scoring rubric (structure, verifiability, iteration, risk, duration, isolation) with hard-signal overrides; a "Task queues and software factories" playbook for fire-and-forget requests like "address all open issues" (enumerate and dependency-classify first, fan out independent items as separate per-item workflow runs in bounded waves with per-item worktrees/PRs, compose dependent items into one parent graph that nests proven children, and mix both for clustered queues); and a "Prompting the choice" guide listing the user prompt levers (naming the shape, acceptance criteria, loop wording, evidence requests, scope boundaries, and queue policy) that steer the agent's execution-shape decision.
+- Added a "Context-Mode-Aware Prompt Text" section to `docs/workflows.md` documenting that stage prompts must not describe their own context mode, fresh stages must not reference invisible context (prior conversation, sibling stages, graph topology), and forked continuation prompts should send only the delta with a pointer back to guidance already established in the forked history.
+
+### Changed
+
+- Changed bundled `goal` completion to evidence closure rather than reviewer agreement alone: reviewer quorum can only complete the run when no objective-relevant blocking finding from any reviewer in the current round remains unresolved, unresolved findings are recorded in the inspectable reducer decision reason, and the bounded loop still stops at `max_turns` as `needs_human`. Severity labels alone no longer dismiss objective-relevant findings in Goal or Ralph: `required_by_objective` findings block at any priority (P3 included), while `consistent_with_objective` P3 nice-to-haves stay non-blocking.
+
+### Fixed
+
+- Fixed retryable-failure classification across main-chat retry/fallback, workflow stage fallback, and subagent fallback to treat provider usage-limit exhaustion (for example `Codex error: The usage limit has been reached`, plus `usage_limit_reached`/`insufficient_quota`-style codes) as a retryable quota/rate-limit failure, so configured `fallbackModels` advance to the next candidate provider/model instead of dead-ending the turn, stage, or run. Provider messages that flatten the token into free text (for example `usage_limit_reached` or `usage-limit`, matched with space/underscore/hyphen/joined separators) classify the same as the structured codes across all three paths. Nested cause/diagnostic and session-shaped error payloads classify the same way; cancellations, safety refusals, task/tool failures, and unrelated errors remain non-retryable.
+
 ## [0.9.6] - 2026-07-12
 
 ### Changed

package/dist/builtin/cursor/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.9.7] - 2026-07-12
+
+### Changed
+
+- Published the stable Atomic 0.9.7 release for the Cursor provider package; no functional Cursor provider changes were made after 0.9.6.
+
+## [0.9.7-alpha.1] - 2026-07-12
+
+### Changed
+
+- Published a synchronized Atomic 0.9.7-alpha.1 prerelease for the Cursor provider package; no functional Cursor provider changes were made after 0.9.6.
+
 ## [0.9.6] - 2026-07-12
 
 ### Changed

package/dist/builtin/cursor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/cursor",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "private": true,
   "description": "Experimental first-party Atomic extension for Cursor OAuth, model discovery, and streaming provider registration.",
   "contributors": [
@@ -40,7 +40,7 @@
     }
   },
   "dependencies": {
-    "@bastani/atomic-natives": "0.9.6",
+    "@bastani/atomic-natives": "0.9.7",
     "@bufbuild/protobuf": "^2.12.1",
     "@earendil-works/pi-ai": "^0.80.6"
   }

package/dist/builtin/intercom/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.9.7] - 2026-07-12
+
+### Fixed
+
+- Made blocking reply waits race-safe under concurrent tool calls. Waiter admission is now an atomic synchronous check-and-reserve shared by `intercom` `ask` and `contact_supervisor`: when several blocking requests race (parallel tool calls in one turn, same-tool or cross-tool), exactly one wins the reservation and every other call returns a normal structured "Already waiting for a reply" tool error. Previously the loser received an already-rejected promise that could sit unhandled while the winner's question was still being sent, crashing the whole agent process with an unhandled `Error: Already waiting for a reply` rejection.
+- Scoped blocking-ask cleanup to the owning call: cancellation, send failures, and delivery errors now settle only that call's own reply waiter instead of rejecting whichever waiter happened to be pending, so a losing or failing concurrent request can no longer tear down another call's in-flight ask. The reply-wait timeout also rejects only its own waiter, threaded replies still resolve the exact winning request, and session shutdown/replacement and broker disconnects continue to reject the currently pending waiter.
+- Made the pending reply-wait promise unhandled-rejection-proof: rejections that fire between the owner's awaits (for example a delivery failure racing dispatch) are pre-handled, so blocking coordination can never terminate the process.
+- Initialized the lazy Intercom runtime from the most recent turn/tool/model lifecycle context when a subagent result or control relay arrives in a session that never emitted `session_start` to extensions (for example non-interactive in-process child sessions). Such sessions now deliver self-addressed subagent result announcements locally instead of failing every relay.
+- Stopped recording misleading `intercom_result_error`/`intercom_control_error` "Intercom shutting down" entries when a relay fires while the runtime is uninitialized and the target is not the local session. The relay now acknowledges the message as undelivered (callers fall back to inline results) without attempting a broker connection that can only fail.
+
+## [0.9.7-alpha.1] - 2026-07-12
+
+### Fixed
+
+- Made blocking reply waits race-safe under concurrent tool calls. Waiter admission is now an atomic synchronous check-and-reserve shared by `intercom` `ask` and `contact_supervisor`: when several blocking requests race (parallel tool calls in one turn, same-tool or cross-tool), exactly one wins the reservation and every other call returns a normal structured "Already waiting for a reply" tool error. Previously the loser received an already-rejected promise that could sit unhandled while the winner's question was still being sent, crashing the whole agent process with an unhandled `Error: Already waiting for a reply` rejection.
+- Scoped blocking-ask cleanup to the owning call: cancellation, send failures, and delivery errors now settle only that call's own reply waiter instead of rejecting whichever waiter happened to be pending, so a losing or failing concurrent request can no longer tear down another call's in-flight ask. The reply-wait timeout also rejects only its own waiter, threaded replies still resolve the exact winning request, and session shutdown/replacement and broker disconnects continue to reject the currently pending waiter.
+- Made the pending reply-wait promise unhandled-rejection-proof: rejections that fire between the owner's awaits (for example a delivery failure racing dispatch) are pre-handled, so blocking coordination can never terminate the process.
+- Initialized the lazy Intercom runtime from the most recent turn/tool/model lifecycle context when a subagent result or control relay arrives in a session that never emitted `session_start` to extensions (for example non-interactive in-process child sessions). Such sessions now deliver self-addressed subagent result announcements locally instead of failing every relay.
+- Stopped recording misleading `intercom_result_error`/`intercom_control_error` "Intercom shutting down" entries when a relay fires while the runtime is uninitialized and the target is not the local session. The relay now acknowledges the message as undelivered (callers fall back to inline results) without attempting a broker connection that can only fail.
+
 ## [0.9.6] - 2026-07-12
 
 ### Changed

package/dist/builtin/intercom/README.md

@@ -344,7 +344,7 @@ Only registered in sessions where `pi-subagents` supplied the required child bri
 
 **`send`** — Sends a message to the specified session. By default it sends immediately, including in interactive sessions. Set `confirmSend: true` in config if you want a confirmation dialog for non-reply sends. Replies that include `replyTo` skip confirmation. Returns delivery confirmation.
 
-**`ask`** — Sends a message and waits for the recipient to reply (10-minute timeout). The reply is returned as the tool result. No confirmation dialog. Only one pending `ask` is allowed per session at a time. Use this when the agent needs the answer to continue working.
+**`ask`** — Sends a message and waits for the recipient to reply (10-minute timeout). The reply is returned as the tool result. No confirmation dialog. Only one pending `ask` is allowed per session at a time; if several blocking requests race (parallel `ask` calls, or `ask` alongside `contact_supervisor`), one wins the reservation and each other call returns a normal "Already waiting for a reply" tool error without disturbing the pending ask. Use this when the agent needs the answer to continue working.
 
 **`reply`** — Replies to the current intercom-triggered message if there is one. Otherwise it falls back to the single unresolved inbound ask. If multiple asks are pending, pass `to` or inspect them with `pending` first. Under the hood this is still a normal `send` with the exact `replyTo` value.
 

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

@@ -3,7 +3,7 @@ import { randomUUID } from "crypto";
 import { Type } from "typebox";
 import { Text } from "@earendil-works/pi-tui";
 import type { IntercomClient } from "./broker/client.ts";
-import type { Message } from "./types.ts";
+import type { ReplyWait, ReplyWaitAdmission } from "./reply-waiter.ts";
 import { renderContactSupervisorResult } from "./result-renderers.js";
 import {
   type ChildOrchestratorMetadata,
@@ -23,13 +23,18 @@ interface ContactSupervisorDeps {
   ensureConnected(reason: "tool"): Promise<IntercomClient>;
   syncPresenceIdentity(sessionId: string): void;
   resolveSessionTarget(activeClient: IntercomClient, nameOrId: string): Promise<string | null>;
-  waitForReply(from: string, replyTo: string, signal?: AbortSignal): Promise<Message>;
+  /**
+   * Atomically reserve the single reply-waiter slot. Returns a structured
+   * refusal when another blocking ask already holds it, so concurrent calls
+   * never observe a rejected promise.
+   */
+  beginReplyWait(from: string, replyTo: string, signal?: AbortSignal): ReplyWaitAdmission;
+  /** Advisory fast-path check; beginReplyWait is the authoritative reservation. */
   hasReplyWaiter(): boolean;
-  rejectReplyWaiter(error: Error): void;
 }
 
 export function registerContactSupervisorTool(pi: ExtensionAPI, deps: ContactSupervisorDeps): void {
-  const { childOrchestratorMetadata, ensureConnected, syncPresenceIdentity, resolveSessionTarget, waitForReply, hasReplyWaiter, rejectReplyWaiter } = deps;
+  const { childOrchestratorMetadata, ensureConnected, syncPresenceIdentity, resolveSessionTarget, beginReplyWait, hasReplyWaiter } = deps;
   if (childOrchestratorMetadata) {
     pi.registerTool({
       name: "contact_supervisor",
@@ -180,24 +185,18 @@ export function registerContactSupervisorTool(pi: ExtensionAPI, deps: ContactSup
           };
         }
 
-        let replyPromise: Promise<Message> | null = null;
+        let wait: ReplyWait | null = null;
         try {
           const questionId = randomUUID();
-          replyPromise = waitForReply(sendTo, questionId, signal);
-          replyPromise.catch(() => undefined);
-          if (signal?.aborted) {
-            rejectReplyWaiter(new Error("Cancelled"));
-            try {
-              await replyPromise;
-            } catch {
-              // The waiter was intentionally rejected above; the tool result reports cancellation.
-            }
+          const admission = beginReplyWait(sendTo, questionId, signal);
+          if (!admission.ok) {
             return {
-              content: [{ type: "text", text: "Cancelled" }],
+              content: [{ type: "text", text: admission.reason === "busy" ? "Already waiting for a reply" : "Cancelled" }],
               isError: true,
               details: { error: true },
             };
           }
+          wait = admission.wait;
           const requestText = reason === "interview_request"
             ? formatChildOrchestratorMessage("interview", metadata, formatSupervisorInterviewRequest(supervisorInterview!, typeof params.message === "string" ? params.message : undefined))
             : formatChildOrchestratorMessage("ask", metadata, params.message as string);
@@ -208,14 +207,7 @@ export function registerContactSupervisorTool(pi: ExtensionAPI, deps: ContactSup
           });
           if (!sendResult.delivered) {
             const errorText = sendResult.reason ?? "Session may not exist or has disconnected.";
-            rejectReplyWaiter(new Error(`Message to "${metadata.orchestratorTarget}" was not delivered: ${errorText}`));
-            if (replyPromise) {
-              try {
-                await replyPromise;
-              } catch {
-                // The waiter was already rejected above. Keep the delivery failure as the only error here.
-              }
-            }
+            wait.cancel(new Error(`Message to "${metadata.orchestratorTarget}" was not delivered: ${errorText}`));
             return {
               content: [{ type: "text", text: `Message to "${metadata.orchestratorTarget}" was not delivered: ${errorText}` }],
               isError: true,
@@ -233,7 +225,7 @@ export function registerContactSupervisorTool(pi: ExtensionAPI, deps: ContactSup
             timestamp: Date.now(),
             subagent: { runId: metadata.runId, agent: metadata.agent, index: metadata.index },
           });
-          const replyMessage = await replyPromise;
+          const replyMessage = await wait.promise;
           const replyText = replyMessage.content.text;
           const replyAttachments = replyMessage.content.attachments?.length
             ? formatAttachments(replyMessage.content.attachments)
@@ -256,14 +248,9 @@ export function registerContactSupervisorTool(pi: ExtensionAPI, deps: ContactSup
               : {},
           };
         } catch (error) {
-          rejectReplyWaiter(toError(error));
-          if (replyPromise) {
-            try {
-              await replyPromise;
-            } catch {
-              // The waiter is cleanup-only on this path. The real failure is the one from the outer catch.
-            }
-          }
+          // Settle only this call's own waiter; a concurrent call's
+          // reservation must never be torn down from this failure path.
+          wait?.cancel(toError(error));
           return {
             content: [{ type: "text", text: `Failed: ${getErrorMessage(error)}` }],
             isError: true,

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

@@ -6,6 +6,7 @@ import { InlineMessageComponent } from "./ui/inline-message.js";
 import { loadConfig, type IntercomConfig } from "./config.js";
 import type { SessionInfo, Message } from "./types.js";
 import { ReplyTracker } from "./reply-tracker.js";
+import { ReplyWaiterSlot } from "./reply-waiter.js";
 import { registerContactSupervisorTool } from "./contact-supervisor-tool.js";
 import { registerIntercomTool } from "./intercom-tool.js";
 import { registerIntercomOverlay } from "./overlay.js";
@@ -45,54 +46,12 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
   let agentRunning = false;
   const activeTools = new Map<string, string>();
   const replyTracker = new ReplyTracker();
+  const replyWaiters = new ReplyWaiterSlot();
   const foregroundDetachHandoff = new ForegroundDetachHandoff(pi);
   const pendingIdleMessages: InboundMessageEntry[] = [];
   let inboundFlushTimer: NodeJS.Timeout | null = null;
-  let replyWaiter: {
-    from: string;
-    replyTo: string;
-    resolve: (message: Message) => void;
-    reject: (error: Error) => void;
-  } | null = null;
-  function waitForReply(from: string, replyTo: string, signal?: AbortSignal): Promise<Message> {
-    if (replyWaiter) {
-      return Promise.reject(new Error("Already waiting for a reply"));
-    }
-    if (signal?.aborted) {
-      return Promise.reject(new Error("Cancelled"));
-    }
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        rejectReplyWaiter(new Error(`No reply from "${from}" within 10 minutes`));
-      }, 10 * 60 * 1000);
-      const cleanup = () => {
-        clearTimeout(timeout);
-        signal?.removeEventListener("abort", onAbort);
-        if (replyWaiter?.replyTo === replyTo) {
-          replyWaiter = null;
-        }
-      };
-      const onAbort = () => {
-        cleanup();
-        reject(new Error("Cancelled"));
-      };
-      signal?.addEventListener("abort", onAbort, { once: true });
-      replyWaiter = {
-        from,
-        replyTo,
-        resolve: (message) => {
-          cleanup();
-          resolve(message);
-        },
-        reject: (error) => {
-          cleanup();
-          reject(error);
-        },
-      };
-    });
-  }
   function rejectReplyWaiter(error: Error): void {
-    replyWaiter?.reject(error);
+    replyWaiters.rejectCurrent(error);
   }
   function clearReconnectTimer(): void {
     if (reconnectTimer) clearTimeout(reconnectTimer);
@@ -239,7 +198,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     if (!liveContext) {
       return;
     }
-    if (routeIncomingReply(replyWaiter, from, message)) return;
+    if (routeIncomingReply(replyWaiters.current(), from, message)) return;
     const attachmentText = message.content.attachments?.length
       ? formatAttachments(message.content.attachments)
       : "";
@@ -450,19 +409,17 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     ensureConnected,
     syncPresenceIdentity,
     resolveSessionTarget,
-    waitForReply,
-    hasReplyWaiter: () => Boolean(replyWaiter),
-    rejectReplyWaiter,
+    beginReplyWait: (from, replyTo, signal) => replyWaiters.begin(from, replyTo, signal),
+    hasReplyWaiter: () => replyWaiters.has(),
   });
   registerIntercomTool(pi, {
     ensureConnected,
     syncPresenceIdentity,
     resolveSessionTarget,
-    waitForReply,
+    beginReplyWait: (from, replyTo, signal) => replyWaiters.begin(from, replyTo, signal),
     confirmSend: config.confirmSend,
     replyTracker,
-    hasReplyWaiter: () => Boolean(replyWaiter),
-    rejectReplyWaiter,
+    hasReplyWaiter: () => replyWaiters.has(),
   });
   registerIntercomOverlay(pi, {
     runtimeGeneration: () => runtimeGeneration,

package/dist/builtin/intercom/index.ts

@@ -294,9 +294,21 @@ export default function intercom(pi: ExtensionAPI, options: LightweightIntercomO
 			handle.assertCurrent();
 		},
 	});
+	function latestLifecycleContext(): ExtensionContext | undefined {
+		// Sessions that never emit `session_start` to extensions (for example
+		// non-interactive in-process child sessions) still emit turn/tool/model
+		// lifecycle events. Fall back to the most recent lifecycle context so a
+		// relay-triggered heavy load can replay a synthetic `session_start` and
+		// initialize the runtime instead of relaying against a disposed one.
+		return sessionSnapshot?.ctx
+			?? activeLifecycle.turnStart?.ctx
+			?? activeLifecycle.agentStart?.ctx
+			?? [...activeLifecycle.activeTools.values()].at(-1)?.ctx
+			?? activeLifecycle.modelSelect?.ctx;
+	}
 	for (const eventName of [SUBAGENT_CONTROL_INTERCOM_EVENT, SUBAGENT_RESULT_INTERCOM_EVENT] as const) {
 		pi.events.on(eventName, (payload) => {
-			void loadHeavy().then(async (handle) => {
+			void loadHeavy(latestLifecycleContext()).then(async (handle) => {
 				handle.assertCurrent();
 				await dispatchEventHandlers(handle.heavy, eventName, payload);
 				handle.assertCurrent();

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

@@ -3,7 +3,7 @@ import { randomUUID } from "crypto";
 import { Type } from "typebox";
 import { Text } from "@earendil-works/pi-tui";
 import type { IntercomClient } from "./broker/client.ts";
-import type { Message } from "./types.ts";
+import type { ReplyWait, ReplyWaitAdmission } from "./reply-waiter.ts";
 import { renderIntercomResult } from "./result-renderers.js";
 import {
   formatAttachments,
@@ -19,14 +19,19 @@ interface IntercomToolDeps {
   syncPresenceIdentity(sessionId: string): void;
   resolveSessionTarget(activeClient: IntercomClient, nameOrId: string): Promise<string | null>;
   confirmSend: boolean;
-  waitForReply(from: string, replyTo: string, signal?: AbortSignal): Promise<Message>;
+  /**
+   * Atomically reserve the single reply-waiter slot. Returns a structured
+   * refusal when another blocking ask already holds it, so concurrent calls
+   * never observe a rejected promise.
+   */
+  beginReplyWait(from: string, replyTo: string, signal?: AbortSignal): ReplyWaitAdmission;
   replyTracker: ReplyTracker;
+  /** Advisory fast-path check; beginReplyWait is the authoritative reservation. */
   hasReplyWaiter(): boolean;
-  rejectReplyWaiter(error: Error): void;
 }
 
 export function registerIntercomTool(pi: ExtensionAPI, deps: IntercomToolDeps): void {
-  const { ensureConnected, syncPresenceIdentity, resolveSessionTarget, waitForReply, replyTracker, hasReplyWaiter, rejectReplyWaiter } = deps;
+  const { ensureConnected, syncPresenceIdentity, resolveSessionTarget, beginReplyWait, replyTracker, hasReplyWaiter } = deps;
   pi.registerTool({
     name: "intercom",
     label: "Intercom",
@@ -206,7 +211,7 @@ Usage:
               details: { error: true },
             };
           }
-          let replyPromise: Promise<Message> | null = null;
+          let wait: ReplyWait | null = null;
 
           try {
             const sendTo = await resolveSessionTarget(connectedClient, to) ?? to;
@@ -225,7 +230,15 @@ Usage:
               };
             }
             const questionId = randomUUID();
-            replyPromise = waitForReply(sendTo, questionId, _signal);
+            const admission = beginReplyWait(sendTo, questionId, _signal);
+            if (!admission.ok) {
+              return {
+                content: [{ type: "text", text: admission.reason === "busy" ? "Already waiting for a reply" : "Cancelled" }],
+                isError: true,
+                details: { error: true },
+              };
+            }
+            wait = admission.wait;
             const sendResult = await connectedClient.send(sendTo, {
               messageId: questionId,
               text: message,
@@ -236,14 +249,7 @@ Usage:
 
             if (!sendResult.delivered) {
               const errorText = sendResult.reason ?? "Session may not exist or has disconnected.";
-              rejectReplyWaiter(new Error(`Message to "${to}" was not delivered: ${errorText}`));
-              if (replyPromise) {
-                try {
-                  await replyPromise;
-                } catch {
-                  // The waiter was already rejected above. Keep the delivery failure as the only error here.
-                }
-              }
+              wait.cancel(new Error(`Message to "${to}" was not delivered: ${errorText}`));
               return {
                 content: [{ type: "text", text: `Message to "${to}" was not delivered: ${errorText}` }],
                 isError: true,
@@ -256,7 +262,7 @@ Usage:
               messageId: sendResult.id,
               timestamp: Date.now(),
             });
-            const replyMessage = await replyPromise;
+            const replyMessage = await wait.promise;
             const replyText = replyMessage.content.text;
             const replyAttachments = replyMessage.content.attachments?.length
               ? formatAttachments(replyMessage.content.attachments)
@@ -273,14 +279,9 @@ Usage:
               details: {},
             };
           } catch (error) {
-            rejectReplyWaiter(toError(error));
-            if (replyPromise) {
-              try {
-                await replyPromise;
-              } catch {
-                // The waiter is cleanup-only on this path. The real failure is the one from the outer catch.
-              }
-            }
+            // Settle only this call's own waiter; a concurrent call's
+            // reservation must never be torn down from this failure path.
+            wait?.cancel(toError(error));
             return {
               content: [{ type: "text", text: `Failed: ${getErrorMessage(error)}` }],
               isError: true,

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "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/reply-waiter.ts

@@ -0,0 +1,115 @@
+import type { Message } from "./types.js";
+
+export interface ReplyWaiterRecord {
+  from: string;
+  replyTo: string;
+  resolve(message: Message): void;
+  reject(error: Error): void;
+}
+
+/** Handle owned by the tool call that won waiter admission. */
+export interface ReplyWait {
+  /**
+   * Resolves with the correlated reply, or rejects on timeout, cancellation,
+   * send failure, or disconnect. The rejection is pre-handled internally, so
+   * the promise can safely sit unawaited between other awaits (for example
+   * while the question is still being sent) without ever becoming an
+   * unhandled rejection.
+   */
+  promise: Promise<Message>;
+  /** Rejects only this waiter. No-op once it settled or was replaced. */
+  cancel(error: Error): void;
+}
+
+export type ReplyWaitAdmission =
+  | { ok: true; wait: ReplyWait }
+  | { ok: false; reason: "busy" | "cancelled" };
+
+export const DEFAULT_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
+
+/**
+ * Single-slot reply waiter with atomic admission.
+ *
+ * Admission is a synchronous check-and-reserve: when two blocking asks race
+ * (parallel tool calls, cross-tool intercom/contact_supervisor concurrency),
+ * the first reservation wins and every concurrent loser receives a structured
+ * `{ ok: false, reason: "busy" }` refusal instead of a rejected promise.
+ * Cancellation and failure paths settle only their own waiter, so a losing or
+ * failing call can never tear down a reservation owned by another call.
+ */
+export class ReplyWaiterSlot {
+  private waiter: ReplyWaiterRecord | null = null;
+
+  constructor(private readonly timeoutMs: number = DEFAULT_REPLY_TIMEOUT_MS) {}
+
+  /** The currently pending waiter, used for inbound reply correlation. */
+  current(): ReplyWaiterRecord | null {
+    return this.waiter;
+  }
+
+  has(): boolean {
+    return this.waiter !== null;
+  }
+
+  /**
+   * Rejects whichever waiter is currently pending. Reserved for slot-wide
+   * teardown (session shutdown/replacement, broker disconnect); individual
+   * tool calls must use their own `ReplyWait.cancel` instead.
+   */
+  rejectCurrent(error: Error): void {
+    this.waiter?.reject(error);
+  }
+
+  begin(from: string, replyTo: string, signal?: AbortSignal): ReplyWaitAdmission {
+    if (this.waiter) {
+      return { ok: false, reason: "busy" };
+    }
+    if (signal?.aborted) {
+      return { ok: false, reason: "cancelled" };
+    }
+    let record!: ReplyWaiterRecord;
+    const promise = new Promise<Message>((resolve, reject) => {
+      let settled = false;
+      const timeout = setTimeout(() => {
+        record.reject(new Error(`No reply from "${from}" within ${Math.round(this.timeoutMs / 60_000)} minutes`));
+      }, this.timeoutMs);
+      const onAbort = () => {
+        record.reject(new Error("Cancelled"));
+      };
+      const cleanup = () => {
+        settled = true;
+        clearTimeout(timeout);
+        signal?.removeEventListener("abort", onAbort);
+        if (this.waiter === record) {
+          this.waiter = null;
+        }
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      record = {
+        from,
+        replyTo,
+        resolve: (message) => {
+          if (settled) return;
+          cleanup();
+          resolve(message);
+        },
+        reject: (error) => {
+          if (settled) return;
+          cleanup();
+          reject(error);
+        },
+      };
+      this.waiter = record;
+    });
+    // Pre-attach a handler so a rejection that fires while the owner is
+    // between awaits can never crash the process as an unhandled rejection.
+    promise.catch(() => undefined);
+    return {
+      ok: true,
+      wait: {
+        promise,
+        cancel: (error) => record.reject(error),
+      },
+    };
+  }
+}

package/dist/builtin/intercom/skills/intercom/SKILL.md

@@ -305,6 +305,11 @@ If neither `cmux` nor `tmux` is available, skip this path and use normal `interc
 - **10-minute timeout**: If no reply comes within 10 minutes, the ask fails
 - **One at a time**: Cannot have multiple pending asks from the same session
 - **Cannot self-target**: A session cannot ask itself
+- **Concurrency-safe**: If several blocking requests (multiple `ask` calls, or
+  `ask` plus `contact_supervisor`) race in the same session — for example from
+  parallel tool calls — exactly one wins the reservation. Every other call gets
+  a normal `"Already waiting for a reply"` tool error and can retry or fall
+  back to `send`; the losing calls never disturb the winning ask.
 
 ```typescript
 // Check if already waiting before asking
@@ -381,11 +386,13 @@ Use `/name` so others can target you easily:
 
 **"Already waiting for a reply"**
 ```typescript
-// You can only have one pending ask at a time
+// You can only have one pending ask at a time. Concurrent blocking requests
+// (parallel asks, or ask + contact_supervisor) return this error safely; the
+// winning request keeps waiting for its reply.
 // Option 1: Use send instead
 intercom({ action: "send", to: "planner", message: "..." });
 
-// Option 2: Wait for current ask to complete first
+// Option 2: Wait for the current ask to complete, then retry
 ```
 
 **"Cannot message the current session"**

package/dist/builtin/intercom/subagent-relay.ts

@@ -105,7 +105,8 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
 
     const relayGeneration = deps.runtimeGeneration();
     void (async () => {
-      const relayStillLive = () => !deps.runtimeStarted() || Boolean(getLiveContext(deps.runtimeContext(), relayGeneration));
+      const runtimeLive = () => Boolean(getLiveContext(deps.runtimeContext(), relayGeneration));
+      const relayStillLive = () => !deps.runtimeStarted() || runtimeLive();
       if (!relayStillLive()) {
         acknowledgeResult(options, parsed.requestId, false);
         return;
@@ -114,6 +115,15 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
         deliverLocal(parsed, options);
         return;
       }
+      if (!deps.runtimeStarted()) {
+        // The runtime never initialized for this session (no session_start
+        // reached the extension and no lifecycle context was available), so a
+        // broker connection attempt can only fail. Acknowledge the message as
+        // undelivered without recording a misleading connection error entry;
+        // callers treat an undelivered ack as their inline-result fallback.
+        acknowledgeResult(options, parsed.requestId, false, new Error("Intercom runtime not initialized"));
+        return;
+      }
 
       let activeClient: IntercomClient;
       let target: string;

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.7] - 2026-07-12
+
+### Changed
+
+- Published the stable Atomic 0.9.7 release for the MCP extension; no functional MCP changes were made after 0.9.6.
+
+## [0.9.7-alpha.1] - 2026-07-12
+
+### Changed
+
+- Published a synchronized Atomic 0.9.7-alpha.1 prerelease for the MCP extension; no functional MCP changes were made after 0.9.6.
+
 ## [0.9.6] - 2026-07-12
 
 ### Changed