@bastani/atomic 0.5.18 → 0.5.19

package/src/sdk/runtime/executor.test.ts

@@ -1,10 +1,17 @@
-import { test, expect, describe } from "bun:test";
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, writeFileSync, chmodSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
   renderMessagesToText,
   hasContent,
   escBash,
   escPwsh,
   watchCopilotSessionForHIL,
+  watchCopilotSessionForElicitation,
+  shouldOverrideCopilotCliPath,
+  discoverCopilotBinary,
+  applyContainerEnvDefaults,
   type CopilotHILSessionSurface,
 } from "./executor.ts";
 import type { SavedMessage } from "../types.ts";
@@ -524,3 +531,287 @@ describe("watchCopilotSessionForHIL", () => {
     expect(session.handlerCount("tool.execution_complete")).toBe(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// watchCopilotSessionForElicitation — HIL detection via elicitation events
+// ---------------------------------------------------------------------------
+
+describe("watchCopilotSessionForElicitation", () => {
+  test("fires onHIL(true) on elicitation.requested event", () => {
+    const session = makeMockCopilotSession();
+    const calls: boolean[] = [];
+    const unsubscribe = watchCopilotSessionForElicitation(session, (w) =>
+      calls.push(w),
+    );
+
+    session.dispatch("elicitation.requested", { requestId: "req-1" });
+    expect(calls).toEqual([true]);
+
+    unsubscribe();
+  });
+
+  test("fires onHIL(false) on elicitation.completed with matching requestId", () => {
+    const session = makeMockCopilotSession();
+    const calls: boolean[] = [];
+    const unsubscribe = watchCopilotSessionForElicitation(session, (w) =>
+      calls.push(w),
+    );
+
+    session.dispatch("elicitation.requested", { requestId: "req-1" });
+    expect(calls).toEqual([true]);
+
+    session.dispatch("elicitation.completed", { requestId: "req-1" });
+    expect(calls).toEqual([true, false]);
+
+    unsubscribe();
+  });
+
+  test("only fires onHIL(true) once and onHIL(false) only after last overlapping request completes", () => {
+    const session = makeMockCopilotSession();
+    const calls: boolean[] = [];
+    const unsubscribe = watchCopilotSessionForElicitation(session, (w) =>
+      calls.push(w),
+    );
+
+    session.dispatch("elicitation.requested", { requestId: "req-a" });
+    session.dispatch("elicitation.requested", { requestId: "req-b" });
+    // onHIL(true) fires exactly once on the first request
+    expect(calls).toEqual([true]);
+
+    session.dispatch("elicitation.completed", { requestId: "req-a" });
+    // req-b still active — must not fire onHIL(false) yet
+    expect(calls).toEqual([true]);
+
+    session.dispatch("elicitation.completed", { requestId: "req-b" });
+    expect(calls).toEqual([true, false]);
+
+    unsubscribe();
+  });
+
+  test("ignores elicitation.completed for an unknown requestId", () => {
+    const session = makeMockCopilotSession();
+    const calls: boolean[] = [];
+    const unsubscribe = watchCopilotSessionForElicitation(session, (w) =>
+      calls.push(w),
+    );
+
+    session.dispatch("elicitation.completed", { requestId: "req-unknown" });
+    expect(calls).toEqual([]);
+
+    unsubscribe();
+  });
+
+  test("ignores elicitation.requested payload without a requestId", () => {
+    const session = makeMockCopilotSession();
+    const calls: boolean[] = [];
+    const unsubscribe = watchCopilotSessionForElicitation(session, (w) =>
+      calls.push(w),
+    );
+
+    session.dispatch("elicitation.requested", {});
+    expect(calls).toEqual([]);
+
+    unsubscribe();
+  });
+
+  test("unsubscribe removes both elicitation listeners and subsequent events are not received", () => {
+    const session = makeMockCopilotSession();
+    const calls: boolean[] = [];
+    const unsubscribe = watchCopilotSessionForElicitation(session, (w) =>
+      calls.push(w),
+    );
+
+    expect(session.handlerCount("elicitation.requested")).toBe(1);
+    expect(session.handlerCount("elicitation.completed")).toBe(1);
+
+    unsubscribe();
+
+    expect(session.handlerCount("elicitation.requested")).toBe(0);
+    expect(session.handlerCount("elicitation.completed")).toBe(0);
+
+    // Events fired after unsubscribe must not reach the original handler
+    session.dispatch("elicitation.requested", { requestId: "req-post" });
+    session.dispatch("elicitation.completed", { requestId: "req-post" });
+    expect(calls).toEqual([]);
+  });
+
+  test("MCP-initiated elicitation (non-empty elicitationSource) triggers onHIL(true) and onHIL(false) same as agent-initiated", () => {
+    const session = makeMockCopilotSession();
+    const calls: boolean[] = [];
+    const unsubscribe = watchCopilotSessionForElicitation(session, (w) =>
+      calls.push(w),
+    );
+
+    // Simulate MCP-initiated elicitation with a non-empty elicitationSource
+    session.dispatch("elicitation.requested", {
+      requestId: "req-mcp-1",
+      elicitationSource: "mcp-server://my-tool",
+      message: "Please provide your API key",
+    });
+    expect(calls).toEqual([true]);
+
+    session.dispatch("elicitation.completed", {
+      requestId: "req-mcp-1",
+      action: "accept",
+    });
+    expect(calls).toEqual([true, false]);
+
+    unsubscribe();
+  });
+
+  test("calling unsubscribe twice does not throw", () => {
+    const session = makeMockCopilotSession();
+    const unsubscribe = watchCopilotSessionForElicitation(session, () => {});
+
+    unsubscribe();
+    // Second call must be safe — no throw, no error
+    expect(() => unsubscribe()).not.toThrow();
+  });
+
+  test("ask_user watcher and elicitation watcher on same session track HIL independently", () => {
+    const session = makeMockCopilotSession();
+    const hilCalls: boolean[] = [];
+    const elicitationCalls: boolean[] = [];
+
+    const unsubHIL = watchCopilotSessionForHIL(session, (w) =>
+      hilCalls.push(w),
+    );
+    const unsubElicitation = watchCopilotSessionForElicitation(session, (w) =>
+      elicitationCalls.push(w),
+    );
+
+    // Fire an ask_user event — only the HIL watcher should see it
+    session.dispatch("tool.execution_start", {
+      toolName: "ask_user",
+      toolCallId: "tc-concurrent",
+    });
+    expect(hilCalls).toEqual([true]);
+    expect(elicitationCalls).toEqual([]);
+
+    // Fire an elicitation event — only the elicitation watcher should see it
+    session.dispatch("elicitation.requested", {
+      requestId: "req-concurrent",
+    });
+    expect(hilCalls).toEqual([true]);
+    expect(elicitationCalls).toEqual([true]);
+
+    // Complete the ask_user — only HIL watcher fires false
+    session.dispatch("tool.execution_complete", { toolCallId: "tc-concurrent" });
+    expect(hilCalls).toEqual([true, false]);
+    expect(elicitationCalls).toEqual([true]);
+
+    // Complete the elicitation — only elicitation watcher fires false
+    session.dispatch("elicitation.completed", { requestId: "req-concurrent" });
+    expect(hilCalls).toEqual([true, false]);
+    expect(elicitationCalls).toEqual([true, false]);
+
+    unsubHIL();
+    unsubElicitation();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Copilot CLI path discovery (Bun-without-node containers)
+// ---------------------------------------------------------------------------
+
+describe("discoverCopilotBinary / shouldOverrideCopilotCliPath", () => {
+  let sandbox: string;
+  let savedPath: string | undefined;
+  let savedCliPath: string | undefined;
+
+  beforeEach(() => {
+    sandbox = mkdtempSync(join(tmpdir(), "atomic-cli-probe-"));
+    savedPath = process.env.PATH;
+    savedCliPath = process.env.COPILOT_CLI_PATH;
+    delete process.env.COPILOT_CLI_PATH;
+  });
+
+  afterEach(() => {
+    if (savedPath === undefined) delete process.env.PATH;
+    else process.env.PATH = savedPath;
+    if (savedCliPath === undefined) delete process.env.COPILOT_CLI_PATH;
+    else process.env.COPILOT_CLI_PATH = savedCliPath;
+    rmSync(sandbox, { recursive: true, force: true });
+  });
+
+  function putExe(dir: string, name: string, contents = "#!/bin/sh\necho $0"): string {
+    const p = join(dir, name);
+    writeFileSync(p, contents);
+    chmodSync(p, 0o755);
+    return p;
+  }
+
+  test("finds an executable 'copilot' on PATH", () => {
+    const bin = putExe(sandbox, "copilot");
+    process.env.PATH = sandbox;
+    expect(discoverCopilotBinary()).toBe(bin);
+  });
+
+  test("returns undefined when no copilot on PATH", () => {
+    process.env.PATH = sandbox;
+    expect(discoverCopilotBinary()).toBeUndefined();
+  });
+
+  test("returns undefined when PATH is unset", () => {
+    delete process.env.PATH;
+    expect(discoverCopilotBinary()).toBeUndefined();
+  });
+
+  test("returns undefined when PATH is empty", () => {
+    process.env.PATH = "";
+    expect(discoverCopilotBinary()).toBeUndefined();
+  });
+
+  test("skips non-executable files named 'copilot' on Unix", () => {
+    if (process.platform === "win32") return;
+    const p = join(sandbox, "copilot");
+    writeFileSync(p, "not executable");
+    chmodSync(p, 0o644);
+    process.env.PATH = sandbox;
+    expect(discoverCopilotBinary()).toBeUndefined();
+  });
+
+  test("shouldOverrideCopilotCliPath: false when COPILOT_CLI_PATH is user-set", () => {
+    putExe(sandbox, "copilot");
+    process.env.PATH = sandbox;
+    process.env.COPILOT_CLI_PATH = "/somewhere/else/copilot";
+    expect(shouldOverrideCopilotCliPath()).toBe(false);
+  });
+
+  test("shouldOverrideCopilotCliPath: false when node is also on PATH (SDK default works)", () => {
+    putExe(sandbox, "copilot");
+    putExe(sandbox, "node");
+    process.env.PATH = sandbox;
+    expect(shouldOverrideCopilotCliPath()).toBe(false);
+  });
+
+  test("shouldOverrideCopilotCliPath: true when bun + copilot but no node", () => {
+    putExe(sandbox, "copilot");
+    // Sandboxing PATH to a dir without `node` is what makes this test
+    // deterministic regardless of the host's installed toolchain.
+    process.env.PATH = sandbox;
+    // We're running this test under Bun, so process.versions.bun is set
+    expect(!!process.versions.bun).toBe(true);
+    expect(shouldOverrideCopilotCliPath()).toBe(true);
+  });
+
+  test("shouldOverrideCopilotCliPath: false when PATH is unset", () => {
+    delete process.env.PATH;
+    expect(shouldOverrideCopilotCliPath()).toBe(false);
+  });
+
+  test("applyContainerEnvDefaults sets COPILOT_CLI_PATH when override is needed", () => {
+    const bin = putExe(sandbox, "copilot");
+    process.env.PATH = sandbox;
+    applyContainerEnvDefaults();
+    expect(process.env.COPILOT_CLI_PATH).toBe(bin);
+  });
+
+  test("applyContainerEnvDefaults does NOT overwrite user-set COPILOT_CLI_PATH", () => {
+    putExe(sandbox, "copilot");
+    process.env.PATH = sandbox;
+    process.env.COPILOT_CLI_PATH = "/custom/copilot";
+    applyContainerEnvDefaults();
+    expect(process.env.COPILOT_CLI_PATH).toBe("/custom/copilot");
+  });
+});

package/src/sdk/runtime/executor.ts

@@ -17,6 +17,7 @@
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { writeFile } from "node:fs/promises";
+import { statSync, accessSync, constants as fsConstants } from "node:fs";
 import type {
   WorkflowDefinition,
   WorkflowContext,
@@ -55,6 +56,7 @@ import {
 import { OrchestratorPanel } from "./panel.tsx";
 import { GraphFrontierTracker } from "./graph-inference.ts";
 import { errorMessage } from "../errors.ts";
+import { createPainter } from "../../theme/colors.ts";
 
 /** Maximum time (ms) to wait for an agent's server to become reachable. */
 const SERVER_WAIT_TIMEOUT_MS = 60_000;
@@ -130,6 +132,13 @@ export interface WorkflowRunOptions {
   workflowFile: string;
   /** Project root (defaults to cwd) */
   projectRoot?: string;
+  /**
+   * When true, create the tmux session and return immediately instead
+   * of attaching. The orchestrator keeps running in the background on
+   * the atomic tmux socket; users can attach later with
+   * `atomic workflow session connect <name>`.
+   */
+  detach?: boolean;
 }
 
 interface SessionResult {
@@ -182,6 +191,117 @@ async function getRandomPort(): Promise<number> {
   );
 }
 
+/**
+ * Resolve a non-JS Copilot CLI binary on PATH.
+ *
+ * Under Bun, `@github/copilot-sdk` spawns its bundled JS entry via `node`
+ * (see `getNodeExecPath` in the SDK). If `node` isn't installed — common in
+ * minimal containers — the spawn fails silently with ENOENT and the SDK's
+ * write to the child's stdin surfaces as "Cannot call write after a stream
+ * was destroyed" from vscode-jsonrpc. Pointing the SDK at a standalone
+ * `copilot` binary (the npm-installed ELF executable) sidesteps the
+ * node-vs-bun problem because the SDK execs it directly when the path does
+ * not end in `.js`.
+ *
+ * Returns undefined if no suitable binary is found.
+ */
+export function discoverCopilotBinary(): string | undefined {
+  const pathVar = process.env.PATH;
+  if (!pathVar) return undefined;
+  // Windows: only `copilot.exe` is probed. Bun's global install writes a
+  // real `.exe` shim, so this covers the Bun-container scenario this guard
+  // exists for. Pre-existing npm-installed shims (`copilot.cmd`/`.ps1`)
+  // aren't handled — the entire override is gated on `process.versions.bun`.
+  const exe = process.platform === "win32" ? "copilot.exe" : "copilot";
+  const sep = process.platform === "win32" ? ";" : ":";
+  for (const dir of pathVar.split(sep)) {
+    if (!dir) continue;
+    const candidate = join(dir, exe);
+    if (!isExecutableFile(candidate)) continue;
+    return candidate;
+  }
+  return undefined;
+}
+
+/**
+ * True when we need to override the SDK's default CLI path — i.e. running
+ * under Bun, the user hasn't set COPILOT_CLI_PATH, and `node` is not
+ * available to execute the SDK's bundled JS entry.
+ *
+ * Pure predicate on the current env; safe to call repeatedly.
+ */
+export function shouldOverrideCopilotCliPath(): boolean {
+  if (!process.versions.bun) return false;
+  if (process.env.COPILOT_CLI_PATH) return false;
+  if (isNodeOnPath()) return false;
+  return discoverCopilotBinary() !== undefined;
+}
+
+function isExecutableFile(path: string): boolean {
+  try {
+    if (!statSync(path).isFile()) return false;
+    if (process.platform === "win32") return true;
+    accessSync(path, fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isNodeOnPath(): boolean {
+  const pathVar = process.env.PATH;
+  if (!pathVar) return false;
+  const exe = process.platform === "win32" ? "node.exe" : "node";
+  const sep = process.platform === "win32" ? ";" : ":";
+  for (const dir of pathVar.split(sep)) {
+    if (!dir) continue;
+    if (isExecutableFile(join(dir, exe))) return true;
+  }
+  return false;
+}
+
+/**
+ * Set safe env defaults for the orchestrator process before any SDK is
+ * loaded. Idempotent — subsequent calls no-op once `COPILOT_CLI_PATH`
+ * is set. Call as early as possible so headless Copilot subprocesses
+ * inherit the resolved env.
+ */
+export function applyContainerEnvDefaults(): void {
+  if (!process.versions.bun) return;
+  if (process.env.COPILOT_CLI_PATH) return;
+  if (isNodeOnPath()) return;
+  const bin = discoverCopilotBinary();
+  if (bin) process.env.COPILOT_CLI_PATH = bin;
+}
+
+/** Percent of the agent window's vertical space allocated to the React footer pane. */
+const FOOTER_PANE_PERCENT = 5;
+
+/**
+ * Split the agent window so the top pane runs the agent CLI and the bottom
+ * pane runs the React footer (via `atomic _footer`). Allocating a percentage
+ * of the vertical layout — rather than an absolute cell count — lets tmux
+ * enforce its minimum-pane-size constraints and keeps the split readable on
+ * both tall and short terminals.
+ *
+ * Resolves the CLI entrypoint relative to this file (executor.ts lives at
+ * src/sdk/runtime/, so ../../cli.ts is the CLI). `process.argv[1]` points
+ * to executor-entry.ts here — a separate process that has no `_footer`
+ * subcommand — so we can't use it.
+ */
+function spawnAttachedFooter(windowName: string, paneId: string): void {
+  const runtime = process.execPath;
+  if (!runtime) return;
+  const cliPath = join(import.meta.dir, "..", "..", "cli.ts");
+  const cmd = `"${escBash(runtime)}" "${escBash(cliPath)}" _footer --name "${escBash(windowName)}"`;
+  tmux.tmuxRun([
+    "split-window",
+    "-t", paneId,
+    "-v", "-l", `${FOOTER_PANE_PERCENT}%`, "-d",
+    cmd,
+  ]);
+}
+
 function buildPaneCommand(
   agent: AgentType,
   port: number,
@@ -340,6 +460,7 @@ export async function executeWorkflow(
     inputs = {},
     workflowFile,
     projectRoot = process.cwd(),
+    detach = false,
   } = options;
 
   const workflowRunId = generateId();
@@ -395,6 +516,14 @@ export async function executeWorkflow(
   tmux.createSession(tmuxSessionName, shellCmd, "orchestrator");
   tmux.setSessionEnv(tmuxSessionName, "ATOMIC_AGENT", agent);
 
+  if (detach) {
+    // Session is already running detached on the atomic socket (tmux
+    // new-session -d). Print connection hints and return so the caller
+    // can exit cleanly without blocking on the orchestrator.
+    printDetachedBanner(tmuxSessionName);
+    return;
+  }
+
   if (tmux.isInsideAtomicSocket()) {
     // Already on the atomic server — just switch to the new session.
     tmux.switchClient(tmuxSessionName);
@@ -408,6 +537,25 @@ export async function executeWorkflow(
   }
 }
 
+/**
+ * Print a short banner telling the user the workflow is running in the
+ * background and how to attach to it. Written to stdout so scripts can
+ * capture the session name with a simple redirect.
+ */
+function printDetachedBanner(tmuxSessionName: string): void {
+  const paint = createPainter();
+  process.stdout.write(
+    "\n" +
+      "  " + paint("success", "✓") + " " + paint("text", "workflow started in background", { bold: true }) + "\n" +
+      "  " + paint("dim", "session: ") + paint("accent", tmuxSessionName) + "\n" +
+      "\n" +
+      "  " + paint("dim", "attach: ") + paint("accent", `atomic workflow session connect ${tmuxSessionName}`) + "\n" +
+      "  " + paint("dim", "list:   ") + paint("accent", "atomic workflow session list") + "\n" +
+      "  " + paint("dim", "kill:   ") + paint("accent", `atomic workflow session kill ${tmuxSessionName}`) + "\n" +
+      "\n",
+  );
+}
+
 /**
  * Small buffer (ms) subtracted from `Date.now()` when recording the Claude
  * session start timestamp.  Protects against fast sequential runs where
@@ -566,6 +714,16 @@ export interface OpenCodeHILEvent {
  * Events for other sessions are silently ignored.  The function returns when
  * the stream is exhausted (i.e. the server closes the connection).
  *
+ * NOTE: OpenCode does not emit any bus event for MCP-server-initiated
+ * elicitation requests — its MCP client never registers an
+ * `ElicitRequestSchema` handler, so such requests are auto-rejected by the
+ * MCP SDK at the protocol layer before reaching any OpenCode-level code.
+ * As a result, the workflow UI **cannot** mark an OpenCode session as
+ * "awaiting input" for MCP elicitation; this is an upstream limitation that
+ * Atomic cannot work around.  If a future OpenCode release surfaces MCP
+ * elicitation as a bus event, extend the switch below (or add a sibling
+ * watcher) to map it onto `onHIL`.
+ *
  * Exported for unit testing.
  */
 export async function watchOpencodeStreamForHIL(
@@ -651,6 +809,50 @@ export function watchCopilotSessionForHIL(
   };
 }
 
+/**
+ * Subscribe to a Copilot session's elicitation events to track HIL state for
+ * `session.ui.elicitation()`, `session.ui.select()`, `session.ui.input()`, and
+ * MCP-server-initiated elicitation requests:
+ *
+ *   - `elicitation.requested`  → `onHIL(true)`  (set transitions empty→non-empty)
+ *   - `elicitation.completed`  → `onHIL(false)` (set transitions non-empty→empty)
+ *
+ * Overlapping elicitation requests are tracked by `requestId` so
+ * `onHIL(false)` only fires after the last in-flight request completes.
+ *
+ * Returns an unsubscribe function that removes both listeners.
+ *
+ * Exported for unit testing.
+ */
+export function watchCopilotSessionForElicitation(
+  session: CopilotHILSessionSurface,
+  onHIL: (waiting: boolean) => void,
+): () => void {
+  const active = new Set<string>();
+  const unsubRequested = session.on("elicitation.requested", (event) => {
+    const data = event.data as { requestId?: string } | undefined;
+    if (data?.requestId) {
+      const wasEmpty = active.size === 0;
+      active.add(data.requestId);
+      if (wasEmpty) onHIL(true);
+    }
+  });
+  const unsubCompleted = session.on("elicitation.completed", (event) => {
+    const data = event.data as { requestId?: string } | undefined;
+    if (
+      data?.requestId &&
+      active.delete(data.requestId) &&
+      active.size === 0
+    ) {
+      onHIL(false);
+    }
+  });
+  return () => {
+    unsubRequested();
+    unsubCompleted();
+  };
+}
+
 // ============================================================================
 // Shared transcript / message readers
 // ============================================================================
@@ -744,6 +946,7 @@ async function initProviderClientAndSession<A extends AgentType>(
   serverUrl: string,
   paneId: string,
   sessionId: string,
+  sessionDir: string,
   clientOpts: StageClientOptions<A>,
   sessionOpts: StageSessionOptions<A>,
   headless = false,
@@ -812,7 +1015,7 @@ async function initProviderClientAndSession<A extends AgentType>(
       }
       const claudeClientOpts = clientOpts as StageClientOptions<"claude">;
       const claudeSessionOpts = sessionOpts as StageSessionOptions<"claude">;
-      const client = new ClaudeClientWrapper(paneId, claudeClientOpts);
+      const client = new ClaudeClientWrapper(paneId, claudeClientOpts, sessionDir);
       await client.start();
       const session = new ClaudeSessionWrapper(paneId, sessionId, claudeSessionOpts, onHIL);
       return { client, session } as Result;
@@ -973,6 +1176,8 @@ function createSessionRunner(
         );
         shared.activeRegistry.set(name, { name, paneId, done: donePromise });
 
+        spawnAttachedFooter(name, paneId);
+
         serverUrl = await waitForServer(shared.agent, port, paneId);
 
         shared.panel.addSession(name, graphParents);
@@ -1093,6 +1298,7 @@ function createSessionRunner(
         serverUrl,
         paneId,
         sessionId,
+        sessionDir,
         clientOpts,
         sessionOpts,
         isHeadless,
@@ -1114,6 +1320,7 @@ function createSessionRunner(
       // Unsubscribe fn for the Copilot HIL event listeners; invoked in the
       // `finally` block so the handlers are removed when the stage ends.
       let hilUnsubscribe: (() => void) | undefined;
+      let copilotElicitationUnsubscribe: (() => void) | undefined;
 
       if (shared.agent === "copilot") {
         const copilotSession = providerSession as ProviderSession<"copilot">;
@@ -1127,6 +1334,19 @@ function createSessionRunner(
         // is registered, so we can detect HIL via the SDK's event stream and
         // still let the CLI render its native tmux-pane dialog.
         hilUnsubscribe = watchCopilotSessionForHIL(copilotSession, onHIL);
+
+        // Copilot elicitation HIL detection via native SDK events.
+        //
+        // `elicitation.requested` / `elicitation.completed` fire when the
+        // agent calls `session.ui.elicitation()`, `session.ui.select()`,
+        // `session.ui.input()`, or an MCP server issues an elicitation
+        // request.  These events are distinct from the `ask_user` tool and
+        // require a separate watcher so the UI can show the "waiting for
+        // response" indicator in all HIL scenarios.
+        copilotElicitationUnsubscribe = watchCopilotSessionForElicitation(
+          copilotSession,
+          onHIL,
+        );
       }
 
       // ── 12b. OpenCode: SSE event stream for HIL detection ──
@@ -1204,6 +1424,7 @@ function createSessionRunner(
       } finally {
         // ── 14a. Stop background HIL watcher (if any) ──
         hilUnsubscribe?.();
+        copilotElicitationUnsubscribe?.();
 
         // ── 14b. Auto-cleanup provider resources ──
         await cleanupProvider(

package/src/sdk/runtime/tmux.conf

@@ -29,10 +29,6 @@ set -g status-right-length 60
 set -g status-style "bg=#1e1e2e,fg=#cdd6f4"
 set -g status-right-style "fg=#6c7086"
 
-# Pane splitting
-bind - split-window -v -c "#{pane_current_path}"
-bind | split-window -h -c "#{pane_current_path}"
-
 # Pane resizing
 bind -r l resize-pane -R 5
 bind -r h resize-pane -L 5
@@ -71,3 +67,38 @@ bind-key -T copy-mode-vi Escape if-shell -F "#{selection_present}" "send-keys -X
 bind -T copy-mode-vi MouseDrag1Pane    select-pane \; send-keys -X begin-selection \; send-keys -X scroll-exit-off
 bind -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel
 bind -T copy-mode-vi MouseDown1Pane    send-keys -X clear-selection \; select-pane
+
+# ── Workflow protection: unbind destructive defaults ──────────────
+# Atomic manages the tmux session lifecycle programmatically. Users should
+# interact with agents and navigate via Ctrl+G / Ctrl+\ / the graph panel.
+# The prefix key (C-b) is kept only for copy-mode entry (C-b [).
+#
+# Note: In practice, C-b is largely unreachable inside Atomic sessions because
+# the agent TUIs (Claude Code, OpenCode, Copilot CLI) run in raw/alternate
+# screen mode and capture keyboard input — including Ctrl+b — before tmux ever
+# sees it. This makes all prefix-based bindings effectively inaccessible during
+# normal agent interaction. The unbinds below are a defense-in-depth measure
+# for the edge case where a user exits an agent back to a bare shell prompt.
+#
+# Bindings intentionally kept (non-destructive or low-risk):
+#   C-b [   copy-mode entry (keyboard fallback for mouse scroll)
+#   C-b :   command prompt (requires typing a full command — low accidental risk)
+#   C-b d   detach (non-destructive; just disconnects the client)
+#   C-b c   new window (non-destructive; doesn't affect existing windows)
+#   C-b -   custom split vertical   (replaces default C-b ")
+#   C-b |   custom split horizontal (replaces default C-b %)
+
+# Prevent window/pane destruction
+unbind &          # kill-window
+unbind x          # kill-pane
+
+# Prevent renaming
+unbind ,          # rename-window
+unbind '$'        # rename-session
+
+# Prevent automatic window renaming (complements allow-rename off above)
+setw -g automatic-rename off
+
+# Pane splitting
+bind - split-window -v -c "#{pane_current_path}"
+bind | split-window -h -c "#{pane_current_path}"