@bastani/atomic 0.9.5-alpha.7 → 0.9.5-alpha.8

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [0.9.5-alpha.8] - 2026-07-08
+
+### Added
+
+- Added main-chat `fallbackModels` support for retryable provider/model failures ([#1418](https://github.com/bastani-inc/atomic/issues/1418)). Users can configure an ordered fallback chain in settings or SDK session options with per-candidate reasoning suffixes such as `:high` and `:xhigh`; normal same-model retry remains first when enabled, fallback switches are recorded as session model changes, and the UI reports fallback progress.
+
+### Fixed
+
+- Fixed provider context-window overflow recovery so an exhausted overflow auto-compaction attempt emits an explicit unresolved-overflow signal instead of silently leaving callers to retry the same model, and planner calls that themselves overflow now degrade through the deterministic overflow-eviction ladder rather than throwing before non-model reduction can run. Planner overflow is now recognized whether it is returned as an assistant error message or thrown by the provider stream before `agent.prompt()` completes, so overflow recovery skips the critical planner retry and goes directly to deterministic non-model reduction in both forms.
+- Fixed overflow auto-compaction retry reliability so `AgentSession.prompt()` now waits for the `willRetry: true` post-compaction continuation before resolving. Late unresolved-overflow signals from that continuation are observed by workflow callers before they can mark the original prompt successful.
+- Fixed normal interactive TTY startup so typing before the prompt box is fully mounted is captured instead of being invisibly blocked by deferred resource initialization. Atomic now starts a short-lived raw input buffer only on the existing deferred-startup fast path, keeps it active until the TUI input handler is mounted, replays draft text into the editor, queues only ordinary Enter-submitted prompts for the prompt loop, and preserves command-like early submissions such as `/settings` or `!pwd` as standalone editor submissions so normal command routing handles them after mount. Once a command-like startup submission is captured, later captured submissions wait behind it and replay in original input order after that command is routed, preventing a later ordinary prompt from leapfrogging the earlier command without merging commands and following prompts into one draft. The capture now restores terminal raw mode across early startup exits/signals and ignores split escape sequences so partial arrow-key/protocol bytes never become draft text. Trust prompts, explicit resource flags, metadata commands, non-TTY modes, and explicit provider/model selection stay on the synchronous startup path.
+- Fixed the bundled intercom extension to keep broker runtime files under the active Atomic agent directory, including custom `ATOMIC_CODING_AGENT_DIR` values and the legacy `PI_CODING_AGENT_DIR` alias, while documenting the `~/.atomic/agent/intercom/` primary path and `~/.pi/agent/intercom/` fallback. The default pi-compatible `npx --no-install tsx` broker sentinel is now hardened to launch through the current runtime (`process.execPath`): Node-based installs use a resolved `tsx` CLI with a bundled `jiti` fallback, Bun source-checkout runs use the current Bun executable directly, and standalone Atomic Bun binaries use a narrow internal split-launcher broker handoff, so default startup does not depend on `npx`, `tsx`, or `bun` being on `PATH`; explicit custom broker configs remain supported.
+- Fixed GitHub Copilot Claude/Anthropic Messages streams that cleanly report a terminal stop reason but omit the required `message_stop` SSE event. Atomic now adds that single terminal event only for closed, non-error Copilot `/v1/messages` event streams before provider parsing, including complete final SSE frames that reach EOF without a trailing blank-line separator and GitHub Enterprise/GHE tenant routing hosts such as `copilot-api.<enterprise>.ghe.com`, while leaving malformed, truncated, already well-formed, non-Copilot, look-alike host, non-SSE, Gemini, and OpenAI-style streams to the normal parser/retry behavior.
+- Fixed bundled workflow durable resume hydration so replayed parallel reviewer fanout preserves branch structure and completed workflow stages restore persisted summaries, durations, session/model metadata, and checkpoint contents in status and graph views.
+
 ## [0.9.5-alpha.7] - 2026-07-07
 
 ### Changed
@@ -619,8 +634,8 @@
 - Fixed provider auth-status reporting for explicit `$ENV_VAR` config values, preserved uppercase literal credentials during config-value migrations (including legacy `~/.pi/agent` roots), preserved `models.json` JSONC comments/formatting during migration, and accepted the upstream `supportsDeveloperRole` flag for custom OpenAI Responses models.
 - Fixed RPC client requests to reject promptly when the child agent process exits or its stdio fails, completed the RPC-mode output/backpressure and `excludeFromContext` bash-command port, and preserved steering/follow-up queue modes across extension-triggered RPC session reloads.
 - Fixed SDK provider stream options so HTTP idle timeouts and WebSocket connect timeouts from settings are forwarded to provider streams while preserving per-request overrides.
-- Fixed interactive startup input handling so prompts submitted before the main input loop is installed are queued instead of dropped, and fixed signal-triggered shutdown ordering so extension `session_shutdown` cleanup runs before terminal restore writes.
-- Fixed the initial `--resume` session picker and all-sessions pane to honor a custom `--session-dir`.
+- Fixed interactive startup input handling so prompts submitted before the main input loop is installed are queued instead of dropped, captured command-like and ordinary startup submissions replay in original input order without later prompts leapfrogging earlier commands, prompts typed behind an active startup command stay behind that command even while a prior prompt is streaming, and pre-session selectors or confirmations such as `--resume` and cross-project `--session` no longer leak typed text into chat input.
+- Fixed the initial `--resume` session picker and all-sessions pane to honor a custom `--session-dir`, and fixed signal-triggered shutdown ordering so extension `session_shutdown` cleanup runs before terminal restore writes.
 - Fixed plain metadata commands (`--version`, `--help`, `--list-models`) to keep their output on stdout for scripts/completions while keeping auto-install/startup chatter off stdout.
 - Fixed OAuth login dialog prompt/manual input rendering so submitted values remain stable, auth storage writes to consistently use `0600` file mode, and self-update command generation to bypass package-manager minimum-release-age delays.
 - Fixed changelog link normalization to produce Atomic repository/tag-pinned links from local package links and legacy pi-mono URLs, wired into startup and `/changelog` output.

package/dist/builtin/cursor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/cursor",
-  "version": "0.9.5-alpha.7",
+  "version": "0.9.5-alpha.8",
   "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.5-alpha.7",
+    "@bastani/atomic-natives": "0.9.5-alpha.8",
     "@bufbuild/protobuf": "^2.12.1",
     "@earendil-works/pi-ai": "^0.80.3"
   }

package/dist/builtin/intercom/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.9.5-alpha.8] - 2026-07-08
+
+### Added
+
+- Added preferred `atomic` package manifest metadata alongside the legacy `pi` manifest metadata so Atomic package discovery uses Atomic-branded metadata without breaking pi-compatible installs.
+
+### Changed
+
+- Updated intercom documentation to describe Atomic's `~/.atomic/agent/intercom/` primary config/runtime path and legacy `~/.pi/agent/intercom/` fallback.
+- Updated the registered intercom tool description and prompt snippet to use Atomic/Pi-neutral local agent session wording instead of hard-coding Pi-branded session names in model-visible text.
+
+### Fixed
+
+- Fixed Atomic intercom broker runtime paths to derive from the active Atomic agent directory, so `ATOMIC_CODING_AGENT_DIR` moves the broker socket, PID, spawn lock, and Windows launcher together while the legacy `PI_CODING_AGENT_DIR` alias remains supported.
+- Fixed raw TypeScript intercom imports to use the bundled `@earendil-works/pi-tui` package name, matching Atomic's runtime dependency while preserving the public intercom API.
+- Hardened default intercom broker startup so the pi-compatible `npx --no-install tsx` sentinel launches through the current runtime (`process.execPath`): Node-based installs use a resolved `tsx` CLI with a bundled `jiti` fallback, Bun source-checkout runs use the current Bun executable directly, and standalone Atomic Bun binaries re-enter the split launcher through a narrow internal broker handoff instead of treating the Atomic executable as a generic Bun interpreter; explicit custom `brokerCommand`/`brokerArgs` configs remain pass-through overrides.
+
 ## [0.9.4] - 2026-07-03
 
 ### Changed

package/dist/builtin/intercom/README.md

@@ -2,9 +2,9 @@
   <img src="banner.png" alt="pi-intercom" width="1100">
 </p>
 
-# Pi Intercom
+# Pi / Atomic Intercom
 
-Direct 1:1 messaging between pi sessions on the same machine. Send context, findings, or requests from one session to another — whether you're driving the conversation or letting agents coordinate.
+Direct 1:1 messaging between Atomic or pi sessions on the same machine. Send context, findings, or requests from one session to another — whether you're driving the conversation or letting agents coordinate.
 
 ```text
 User flow: ALT+M or run /intercom to pick a session and send a message
@@ -12,51 +12,53 @@ User flow: ALT+M or run /intercom to pick a session and send a message
 
 ## Why
 
-Sometimes you're running multiple pi sessions — one researching, one executing, one reviewing. Pi-intercom lets you:
+Sometimes you're running multiple Atomic/pi sessions — one researching, one executing, one reviewing. Intercom lets you:
 
 - **User-driven orchestration** — Send context or findings from your research session to your execution session
 - **Agent collaboration** — An agent can reach out to another session when it needs help or wants to share results
-- **Session awareness** — See what other pi sessions are running and their current status
+- **Session awareness** — See what other Atomic/pi sessions are running and their current status
 
-Unlike pi-messenger (a shared chat room for multi-agent swarms), pi-intercom is for targeted 1:1 communication where you pick the recipient.
+Unlike pi-messenger (a shared chat room for multi-agent swarms), intercom is for targeted 1:1 communication where you pick the recipient.
 
-Pi-intercom also integrates well with [pi-subagents](https://github.com/nicobailon/pi-subagents): delegated child agents get a child-only `contact_supervisor` tool when `pi-subagents` supplies bridge metadata. Use `reason: "need_decision"` for blocking clarification, `reason: "interview_request"` for multiple structured supervisor answers, and `reason: "progress_update"` for meaningful plan-changing updates. Normal sessions only see the regular `intercom` tool.
+Intercom also integrates with delegated subagents: child agents get a child-only `contact_supervisor` tool when subagent bridge metadata is present. Atomic-prefixed bridge environment variables are supported, and legacy `PI_*` bridge metadata remains compatible. Use `reason: "need_decision"` for blocking clarification, `reason: "interview_request"` for multiple structured supervisor answers, and `reason: "progress_update"` for meaningful plan-changing updates. Normal sessions only see the regular `intercom` tool.
 
 ## In One Minute
 
-Each pi session that has `pi-intercom` loaded and enabled connects to a tiny local broker over a local IPC transport. The broker keeps track of connected sessions and routes direct messages to the one you target by name or session ID. The extension gives you both a tool (`intercom`) and a small overlay UI (`/intercom` or `ALT+M`). Incoming messages are rendered inline inside the recipient session, can trigger a turn immediately, and are also stored in Pi session history as extension entries.
+Each Atomic/pi session that has intercom loaded and enabled connects to a tiny local broker over a local IPC transport. The broker keeps track of connected sessions and routes direct messages to the one you target by name or session ID. The extension gives you both a tool (`intercom`) and a small overlay UI (`/intercom` or `ALT+M`). Incoming messages are rendered inline inside the recipient session, can trigger a turn immediately, and are also stored in session history as extension entries.
 
 ## Install
 
+Atomic bundles `@bastani/intercom` as a first-party extension; no separate install is needed for normal Atomic sessions. For legacy pi installations of the upstream package:
+
 ```bash
 pi install npm:pi-intercom
 ```
 
-Then restart Pi. The extension auto-connects to the broker on startup and registers the bundled `pi-intercom` skill for common coordination patterns.
+Then restart Atomic or Pi. The extension auto-connects to the broker on startup and registers the bundled `intercom` skill for common coordination patterns.
 
 **Recommended:** Add this snippet to your project's `AGENTS.md` to help agents understand when to coordinate across sessions:
 
 ```xml
-<pi-intercom>
-Coordinate with other local pi sessions on related codebases. Use `/skill:pi-intercom` for patterns.
+<intercom>
+Coordinate with other local Atomic/pi sessions on related codebases. Use `/skill:intercom` for patterns.
 
 **When:** Same codebase (parallel work), reference codebase (consulting patterns), related repos (shared libraries).
 
 **Not when:** Unrelated codebases, trivial questions, or when you can proceed independently.
 
 **Principle:** Prefer `send` for notifications; `ask` only when blocked waiting for input.
-</pi-intercom>
+</intercom>
 ```
 
 A session becomes intercom-connected when all of these are true:
-- the `pi-intercom` extension is installed and loaded in that session
-- `enabled` is not set to `false` in `~/.pi/agent/intercom/config.json`
+- the intercom extension is installed/bundled and loaded in that session
+- `enabled` is not set to `false` in `~/.atomic/agent/intercom/config.json` (Atomic) or the legacy `~/.pi/agent/intercom/config.json` fallback
 - the session has started or reloaded after the extension was installed
 - the local broker is running or can be auto-started
 
 The session list only shows intercom-connected sessions, not every open Pi process on the machine.
 
-If a session is unnamed, pi-intercom now exposes a runtime-only fallback alias like `subagent-chat-1a2b3c4d` so other sessions can still target it. That alias is not persisted as the Pi session title, so `pi --resume` can keep showing the transcript snippet instead of a generic `session-...` name.
+If a session is unnamed, intercom exposes a runtime-only fallback alias like `subagent-chat-1a2b3c4d` so other sessions can still target it. That alias is not persisted as the session title, so resume pickers can keep showing the transcript snippet instead of a generic `session-...` name.
 
 ## Quick Start
 
@@ -359,7 +361,7 @@ Only registered in sessions where `pi-subagents` supplied the required child bri
 
 ## Config
 
-Create `~/.pi/agent/intercom/config.json`:
+Create `~/.atomic/agent/intercom/config.json` for Atomic. Legacy pi-compatible installs and fallbacks continue to read `~/.pi/agent/intercom/config.json` when the Atomic config is absent:
 
 ```json
 {
@@ -372,16 +374,18 @@ Create `~/.pi/agent/intercom/config.json`:
 }
 ```
 
+The default `npx --no-install tsx` pair is a compatibility sentinel: intercom recognizes it and starts the broker through the current Atomic/Pi runtime (`process.execPath`). Node-based installs use that runtime with a resolved `tsx` CLI, falling back to Atomic's bundled `jiti` loader when `tsx` is unavailable; Bun source-checkout runs use the current Bun executable directly; standalone Atomic Bun binaries re-enter the split launcher through a narrow internal broker handoff. Default startup therefore does not rely on `npx`, `tsx`, or `bun` being on `PATH`.
+
 | Setting | Default | Description |
 |---------|---------|-------------|
-| `brokerCommand` | `"npx"` | Command used to start the local broker process |
+| `brokerCommand` | `"npx"` | Command used to start the local broker process; the default sentinel is hardened internally to avoid PATH lookup |
 | `brokerArgs` | `["--no-install", "tsx"]` | Arguments passed to `brokerCommand` before the broker script path |
 | `confirmSend` | false | Show a confirmation dialog before non-reply sends from an interactive session with UI |
 | `enabled` | true | Enable/disable intercom entirely |
 | `replyHint` | true | Include reply instruction in incoming messages |
 | `status` | — | Optional custom status suffix shown after the automatic lifecycle status, for example `thinking · researching` |
 
-For example, if you have Bun installed and want it to start the broker directly, use:
+Existing pi-compatible configs that set a custom broker command still work. For example, if you intentionally want to use Bun from `PATH`, configure it explicitly:
 
 ```json
 {
@@ -390,13 +394,13 @@ For example, if you have Bun installed and want it to start the broker directly,
 }
 ```
 
-Pi-intercom publishes live session status automatically. Sessions register as `idle`, switch to `thinking` while the agent is running, show `tool:<name>` during tool execution, and return to `idle` on agent completion. If `status` is set in config, it is appended as context instead of replacing the lifecycle status.
+Intercom publishes live session status automatically. Sessions register as `idle`, switch to `thinking` while the agent is running, show `tool:<name>` during tool execution, and return to `idle` on agent completion. If `status` is set in config, it is appended as context instead of replacing the lifecycle status.
 
 ## How It Works
 
 ```mermaid
 graph TB
-    subgraph A["Pi Session A"]
+    subgraph A["Atomic/Pi Session A"]
         A1[Intercom Client]
         A2[intercom tool]
         A3[UI overlays]
@@ -407,7 +411,7 @@ graph TB
         B2[Message Router]
     end
 
-    subgraph B["Pi Session B"]
+    subgraph B["Atomic/Pi Session B"]
         B3[Intercom Client]
         B4[intercom tool]
         B5[UI overlays]
@@ -424,10 +428,12 @@ Messages use length-prefixed JSON over a local socket/pipe transport (4-byte len
 
 Async extension work (startup, inbound flushes, reconnects, overlays, and relays) no-ops if the session shuts down or reloads before it settles.
 
-Runtime files live at `~/.pi/agent/intercom/`:
+Runtime files live under the active agent directory. Atomic defaults to `~/.atomic/agent/intercom/`; setting `ATOMIC_CODING_AGENT_DIR` moves the broker socket, PID, spawn lock, Windows launcher, and config below that directory. The legacy `PI_CODING_AGENT_DIR` alias remains supported when the Atomic variable is unset. Legacy pi-compatible defaults use `~/.pi/agent/intercom/`.
+
 - `broker.sock` — Unix domain socket for communication (macOS/Linux only; Windows uses a named pipe instead)
 - `broker-launch.vbs` — Windows helper script used to launch the broker without a console window
 - `broker.pid` — Broker process ID
+- `broker.spawn.lock` — Short-lived lock used to avoid duplicate auto-spawns
 - `config.json` — User configuration
 
 ## Design Decisions

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

@@ -1,16 +1,13 @@
 import net from "net";
 import { writeFileSync, unlinkSync, mkdirSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
 import { randomUUID } from "crypto";
-import { CONFIG_DIR_NAME } from "@bastani/atomic";
 import { writeMessage, createMessageReader } from "./framing.js";
-import { getBrokerSocketPath } from "./paths.js";
+import { getBrokerPidPath, getBrokerSocketPath, getIntercomDirPath } from "./paths.js";
 import type { SessionInfo, Message, Attachment, BrokerMessage } from "../types.js";
 
-const INTERCOM_DIR = join(homedir(), CONFIG_DIR_NAME, "agent", "intercom");
+const INTERCOM_DIR = getIntercomDirPath();
 const SOCKET_PATH = getBrokerSocketPath();
-const PID_PATH = join(INTERCOM_DIR, "broker.pid");
+const PID_PATH = getBrokerPidPath();
 
 interface ConnectedSession {
   socket: net.Socket;

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

@@ -1,6 +1,31 @@
-import { join } from "path";
 import { homedir } from "os";
-import { CONFIG_DIR_NAME } from "@bastani/atomic";
+import { join } from "path";
+
+function getHomeDir(): string {
+  if (process.platform === "win32") {
+    if (process.env.USERPROFILE) return process.env.USERPROFILE;
+    if (process.env.HOMEDRIVE && process.env.HOMEPATH) return `${process.env.HOMEDRIVE}${process.env.HOMEPATH}`;
+    if (process.env.HOME) return process.env.HOME;
+    return homedir();
+  }
+  return process.env.HOME || process.env.USERPROFILE || homedir();
+}
+
+function expandTildePath(path: string): string {
+  if (path === "~") return getHomeDir();
+  if (path.startsWith("~/") || (process.platform === "win32" && path.startsWith("~\\"))) {
+    return join(getHomeDir(), path.slice(2));
+  }
+  return path;
+}
+
+function getAgentDir(): string {
+  const atomicAgentDir = process.env.ATOMIC_CODING_AGENT_DIR;
+  if (atomicAgentDir) return expandTildePath(atomicAgentDir);
+  const piAgentDir = process.env.PI_CODING_AGENT_DIR;
+  if (piAgentDir) return expandTildePath(piAgentDir);
+  return join(getHomeDir(), ".atomic", "agent");
+}
 
 function sanitizePipeSegment(value: string): string {
   return value
@@ -9,13 +34,25 @@ function sanitizePipeSegment(value: string): string {
     .toLowerCase() || "default";
 }
 
+export function getIntercomDirPath(agentDir: string = getAgentDir()): string {
+  return join(agentDir, "intercom");
+}
+
+export function getBrokerPidPath(agentDir: string = getAgentDir()): string {
+  return join(getIntercomDirPath(agentDir), "broker.pid");
+}
+
+export function getBrokerSpawnLockPath(agentDir: string = getAgentDir()): string {
+  return join(getIntercomDirPath(agentDir), "broker.spawn.lock");
+}
+
 export function getBrokerSocketPath(
   platform: NodeJS.Platform = process.platform,
-  homeDir: string = homedir(),
+  agentDir: string = getAgentDir(),
 ): string {
   if (platform === "win32") {
-    return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(homeDir)}`;
+    return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
   }
 
-  return join(homeDir, CONFIG_DIR_NAME, "agent", "intercom", "broker.sock");
+  return join(getIntercomDirPath(agentDir), "broker.sock");
 }

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

@@ -2,16 +2,25 @@ import { spawn } from "child_process";
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-import { homedir } from "os";
+import { createRequire } from "module";
 import net from "net";
-import { CONFIG_DIR_NAME } from "@bastani/atomic";
-import { getBrokerSocketPath } from "./paths.js";
-
-const INTERCOM_DIR = join(homedir(), CONFIG_DIR_NAME, "agent", "intercom");
+import { isBunBinary } from "@bastani/atomic";
+import {
+  getBrokerPidPath,
+  getBrokerSocketPath,
+  getBrokerSpawnLockPath,
+  getIntercomDirPath,
+} from "./paths.js";
+
+const INTERCOM_DIR = getIntercomDirPath();
 const EXTENSION_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
 const BROKER_SOCKET = getBrokerSocketPath();
-const BROKER_PID = join(INTERCOM_DIR, "broker.pid");
-const BROKER_SPAWN_LOCK = join(INTERCOM_DIR, "broker.spawn.lock");
+const BROKER_PID = getBrokerPidPath();
+const BROKER_SPAWN_LOCK = getBrokerSpawnLockPath();
+
+type BrokerRuntime = "node" | "bun-source" | "bun-binary";
+
+export const INTERNAL_INTERCOM_BROKER_ARG = "--atomic-internal-intercom-broker";
 
 type BrokerLaunchSpec =
   | {
@@ -31,8 +40,55 @@ function sleep(ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+function getCurrentBrokerRuntime(): BrokerRuntime {
+  if (!process.versions.bun) return "node";
+  return isBunBinary ? "bun-binary" : "bun-source";
+}
+
+function requireFromExtensionDir(extensionDir: string): NodeJS.Require {
+  return createRequire(join(extensionDir, "package.json"));
+}
+
+function resolveTsxCliPath(extensionDir: string): string | null {
+  try {
+    const tsxMain = requireFromExtensionDir(extensionDir).resolve("tsx");
+    return join(dirname(tsxMain), "cli.mjs");
+  } catch {
+    const bundledTsx = join(extensionDir, "node_modules", "tsx", "dist", "cli.mjs");
+    return existsSync(bundledTsx) ? bundledTsx : null;
+  }
+}
+
 export function getTsxCliPath(extensionDir: string = EXTENSION_DIR): string {
-  return join(extensionDir, "node_modules", "tsx", "dist", "cli.mjs");
+  return resolveTsxCliPath(extensionDir) ?? join(extensionDir, "node_modules", "tsx", "dist", "cli.mjs");
+}
+
+export function getJitiCliPath(extensionDir: string = EXTENSION_DIR): string {
+  try {
+    const jitiPackage = requireFromExtensionDir(extensionDir).resolve("jiti/package.json");
+    return join(dirname(jitiPackage), "lib", "jiti-cli.mjs");
+  } catch {
+    return join(extensionDir, "node_modules", "jiti", "lib", "jiti-cli.mjs");
+  }
+}
+
+function getDefaultBrokerRunnerPath(extensionDir: string): string {
+  return resolveTsxCliPath(extensionDir) ?? getJitiCliPath(extensionDir);
+}
+
+function getDefaultBrokerCommandParts(
+  brokerPath: string,
+  extensionDir: string,
+  runtimePath: string,
+  runtime: BrokerRuntime,
+): { command: string; args: string[] } {
+  if (runtime === "bun-source") {
+    return { command: runtimePath, args: [brokerPath] };
+  }
+  if (runtime === "bun-binary") {
+    return { command: runtimePath, args: [INTERNAL_INTERCOM_BROKER_ARG, brokerPath] };
+  }
+  return { command: runtimePath, args: [getDefaultBrokerRunnerPath(extensionDir), brokerPath] };
 }
 
 function quoteWindowsArg(value: string): string {
@@ -56,9 +112,11 @@ export function getWindowsBrokerCommandLine(
   nodePath: string = process.execPath,
   brokerCommand = "npx",
   brokerArgs: string[] = ["--no-install", "tsx"],
+  runtime: BrokerRuntime = getCurrentBrokerRuntime(),
 ): string {
   if (usesDefaultBrokerCommand(brokerCommand, brokerArgs)) {
-    return [quoteWindowsArg(nodePath), quoteWindowsArg(getTsxCliPath(extensionDir)), quoteWindowsArg(brokerPath)].join(" ");
+    const launch = getDefaultBrokerCommandParts(brokerPath, extensionDir, nodePath, runtime);
+    return [quoteWindowsArg(launch.command), ...launch.args.map(quoteWindowsArg)].join(" ");
   }
 
   return [quoteWindowsArg(brokerCommand), ...brokerArgs.map(quoteWindowsArg), quoteWindowsArg(brokerPath)].join(" ");
@@ -90,6 +148,7 @@ export function getBrokerLaunchSpec(
   platform: NodeJS.Platform = process.platform,
   intercomDir: string = INTERCOM_DIR,
   nodePath: string = process.execPath,
+  runtime: BrokerRuntime = getCurrentBrokerRuntime(),
 ): BrokerLaunchSpec {
   if (platform === "win32") {
     const launcherPath = getWindowsHiddenLauncherPath(intercomDir);
@@ -98,7 +157,16 @@ export function getBrokerLaunchSpec(
       command: "wscript.exe",
       args: [launcherPath],
       launcherPath,
-      launcherCommandLine: getWindowsBrokerCommandLine(brokerPath, extensionDir, nodePath, brokerCommand, brokerArgs),
+      launcherCommandLine: getWindowsBrokerCommandLine(brokerPath, extensionDir, nodePath, brokerCommand, brokerArgs, runtime),
+    };
+  }
+
+  if (usesDefaultBrokerCommand(brokerCommand, brokerArgs)) {
+    const launch = getDefaultBrokerCommandParts(brokerPath, extensionDir, nodePath, runtime);
+    return {
+      kind: "direct",
+      command: launch.command,
+      args: launch.args,
     };
   }
 

package/dist/builtin/intercom/config.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "fs";
 import { getAgentConfigPaths } from "@bastani/atomic";
 
 export interface IntercomConfig {
-  /** Broker command used to spawn the broker process (e.g. "npx" or "bun") */
+  /** Broker command used to spawn the broker process (e.g. "npx", "bun", or "node") */
   brokerCommand: string;
 
   /** Arguments passed to the broker command before the broker script path */
@@ -24,9 +24,12 @@ export interface IntercomConfig {
 const CONFIG_PATHS = getAgentConfigPaths("intercom", "config.json");
 const CONFIG_PATH = CONFIG_PATHS.find((path) => existsSync(path)) ?? CONFIG_PATHS[0]!;
 
+export const DEFAULT_BROKER_COMMAND = "npx";
+export const DEFAULT_BROKER_ARGS = ["--no-install", "tsx"] as const;
+
 const defaults: IntercomConfig = {
-  brokerCommand: "npx",
-  brokerArgs: ["--no-install", "tsx"],
+  brokerCommand: DEFAULT_BROKER_COMMAND,
+  brokerArgs: [...DEFAULT_BROKER_ARGS],
   confirmSend: false,
   enabled: true,
   replyHint: true,

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

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@bastani/atomic";
 import { randomUUID } from "crypto";
 import { Type } from "typebox";
-import { Text } from "@mariozechner/pi-tui";
+import { Text } from "@earendil-works/pi-tui";
 import type { IntercomClient } from "./broker/client.ts";
 import type { Message } from "./types.ts";
 import { renderContactSupervisorResult } from "./result-renderers.js";
@@ -249,9 +249,11 @@ export function registerContactSupervisorTool(pi: ExtensionAPI, deps: ContactSup
           return {
             content: [{ type: "text", text: `**Reply from supervisor:**\n${replyText}${replyAttachments}` }],
             isError: false,
-            ...(structuredReply
-              ? { details: structuredReply.value !== undefined ? { structuredReply: structuredReply.value } : { structuredReplyParseError: structuredReply.error } }
-              : {}),
+            details: structuredReply
+              ? structuredReply.value !== undefined
+                ? { structuredReply: structuredReply.value }
+                : { structuredReplyParseError: structuredReply.error }
+              : {},
           };
         } catch (error) {
           rejectReplyWaiter(toError(error));

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

@@ -393,7 +393,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
         }
         throw toError(error);
       } finally {
-        if (reconnectPromise === nextReconnectPromise) {
+        if (reconnectPromiseGeneration === generationAtStart) {
           reconnectPromise = null;
           reconnectPromiseGeneration = null;
         }