claude-threads 1.21.0 → 1.21.2

package/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.21.2] - 2026-08-07
+
+### Added
+- **Decision bridge: plan approvals and question answers now flow through one surface.** On modern Claude CLIs (verified 2.1.223), `ExitPlanMode` and `AskUserQuestion` block on the MCP permission prompt — making it the authoritative gate — while the rich UI (plan post with 👍/👎, question posts with option reactions) lives in the main bot. Users saw two competing prompts, and reacting only on the bot's UI let the MCP prompt time out into a plan denial. The bot now opens a per-session local socket (a named pipe on Windows); the MCP server forwards plan/question permission requests over it and waits (default 1h, `DECISION_BRIDGE_TIMEOUT_MS`), and the user's reaction on the bot's existing UI resolves them: plans as allow/deny, question answers riding back in the permission response's `updatedInput.answers` — the CLI then tells Claude "Your questions have been answered" / "User has approved your plan" itself (both verified against the real CLI end-to-end, including through the real built `mcp-server.js`). The stdin sends (`'approved'`/answer JSON) are suppressed when a bridge request consumed the decision, and remain as the fallback for older CLIs that don't route these tools through the permission prompt. The bridge degrades gracefully everywhere: creation failure, connect failure, or timeout falls back to the previous behavior (generic prompt for plans, auto-allow for questions). The bridge is session-scoped — it survives `!cd`/`!permissions` respawns and closes with the session; pending decisions are denied on session end or fresh-CLI restart so the MCP child is never stranded. A manual real-CLI verification script ships in `tests/e2e-real-cli/decision-bridge-e2e.ts` (not run in CI — needs live credentials).
+- **Decision-bridge hardening (from two adversarial review rounds over this change).** `!approve`/`!yes` resolves a pending bridge request instead of sending a stdin message that would queue behind the blocked permission call (previously it converted an approval into an hour-long hang). The bridge server aborts the bot-side pending when the requesting MCP client disconnects (timeout, cancelled tool call, dead child), so a stale pending can never swallow the user's later reaction — it falls back to stdin instead. Claude respawns deny pending decisions unconditionally (the MCP child always dies, resume or not; previously only fresh-session respawns did). The bridge socket lives in a fresh `0700` directory (other local users can't connect regardless of umask) with a short path (safe against macOS's 104-byte `sun_path` truncation), and is closed on every teardown path including start/resume failures. multiSelect questions bypass the bridge (single-select answer format is the only one verified against the real CLI) and take the legacy path. Operator knob `DECISION_BRIDGE_TIMEOUT_MS` is now actually forwarded to the MCP child.
+- **The CLI is spawned with `MCP_TOOL_TIMEOUT=3600000` when a decision bridge is configured.** Delayed-decision testing against the real CLI (2.1.223) showed it abandons a pending MCP permission call after ~2 minutes — one retry, then an error — silently capping how long a plan approval or question answer could wait, regardless of the bridge's 1-hour window. With the flag set, decisions held for 150 seconds complete end-to-end (verified empirically); 1 hour matches the bridge's `DECISION_BRIDGE_TIMEOUT_MS` default, and setting `MCP_TOOL_TIMEOUT` in the bot's own env overrides it, like the other forwarded tuning flags. Should the CLI still give up (older CLI, operator override), the bridge's disconnect-abort clears the bot-side pending state so the user's late reaction falls back to the stdin flow instead of being swallowed.
+
+## [1.21.1] - 2026-08-07
+
+### Fixed
+- **A respawning session can no longer be torn down by its own dying Claude process.** Two stacked races made `!cd` / `!permissions` / worktree respawns flaky (seen as the recurring `!cd should restart Claude CLI` failure on main's Integration Tests): a last event flushed by the dying process ran `resetSessionActivity`, which unconditionally flipped the session's `restarting` state back to `active` — so when the old process's exit landed, `handleExit` mistook it for the current process dying and did a full session teardown mid-restart. `resetSessionActivity` now leaves `restarting`/`cancelling` states alone, `handleExit` ignores exits from a CLI instance that is no longer the session's current one (the exit event can be delivered after the respawn already swapped in the new instance), and a successful respawn transitions to `active` explicitly instead of relying on the old exit's side effect. `ClaudeCli.kill()` gained an integration-test caller trace, mirroring the existing `sendMessage` one — attributing kills is the key question when debugging these races in CI logs.
+- **`checkGitHubCli` unit tests no longer spawn the real `gh` CLI.** The two subprocess probes each carry a 5s timeout, overrunning bun's 5s per-test budget on a slow runner (the flaky `checkGitHubCli` timeout on main's CI). The exec call is now injectable and the tests cover all three outcomes (installed+authenticated, not installed, not authenticated) deterministically.
+- **Integration: the `!cd` confirmation wait no longer matches the user's own message.** The loose `/changed|directory|\/tmp/i` pattern matched the `!cd /tmp` command itself, ending the test while the respawn was still in flight — `afterEach`'s `killAllSessions` then raced the restart and leaked an orphaned mock CLI into the next test.
+
 ## [1.21.0] - 2026-08-07
 
 ### Fixed

package/dist/index.js

@@ -14177,7 +14177,7 @@ var require_minimist = __commonJS((exports, module) => {
 // node_modules/rc/index.js
 var require_rc = __commonJS((exports, module) => {
   var cc = require_utils();
-  var join10 = __require("path").join;
+  var join11 = __require("path").join;
   var deepExtend = require_deep_extend();
   var etc = "/etc";
   var win = process.platform === "win32";
@@ -14203,15 +14203,15 @@ var require_rc = __commonJS((exports, module) => {
     }
     if (!win)
       [
-        join10(etc, name, "config"),
-        join10(etc, name + "rc")
+        join11(etc, name, "config"),
+        join11(etc, name + "rc")
       ].forEach(addConfigFile);
     if (home)
       [
-        join10(home, ".config", name, "config"),
-        join10(home, ".config", name),
-        join10(home, "." + name, "config"),
-        join10(home, "." + name + "rc")
+        join11(home, ".config", name, "config"),
+        join11(home, ".config", name),
+        join11(home, "." + name, "config"),
+        join11(home, "." + name + "rc")
       ].forEach(addConfigFile);
     addConfigFile(cc.find("." + name + "rc"));
     if (env3.config)
@@ -55960,7 +55960,7 @@ function cleanupBrowserBridgeSockets() {
     log8.debug(`Browser bridge cleanup failed: ${err}`);
   }
 }
-function buildClaudeChildEnv(parentEnv, account) {
+function buildClaudeChildEnv(parentEnv, account, opts) {
   const env = { ...parentEnv };
   if (env.MCP_CONNECTION_NONBLOCKING === undefined) {
     env.MCP_CONNECTION_NONBLOCKING = "true";
@@ -55968,6 +55968,9 @@ function buildClaudeChildEnv(parentEnv, account) {
   if (env.ENABLE_PROMPT_CACHING_1H === undefined) {
     env.ENABLE_PROMPT_CACHING_1H = "true";
   }
+  if (opts?.decisionBridge && env.MCP_TOOL_TIMEOUT === undefined) {
+    env.MCP_TOOL_TIMEOUT = "3600000";
+  }
   if (account?.home) {
     env.HOME = account.home;
     env.USERPROFILE = account.home;
@@ -56016,6 +56019,12 @@ function buildPermissionArgs(opts) {
     PERMISSION_TIMEOUT_MS: String(opts.permissionTimeoutMs),
     SESSION_OWNER_USERNAME: opts.sessionOwnerUsername || ""
   };
+  if (opts.decisionBridgePath) {
+    mcpEnv.DECISION_BRIDGE_PATH = opts.decisionBridgePath;
+    if (process.env.DECISION_BRIDGE_TIMEOUT_MS) {
+      mcpEnv.DECISION_BRIDGE_TIMEOUT_MS = process.env.DECISION_BRIDGE_TIMEOUT_MS;
+    }
+  }
   if (opts.platformConfig.appToken) {
     mcpEnv.PLATFORM_APP_TOKEN = opts.platformConfig.appToken;
   }
@@ -56156,7 +56165,8 @@ class ClaudeCli extends EventEmitter2 {
       workingDir: this.options.workingDir,
       uploadDir: this.options.uploadDir,
       outboundFiles: this.options.outboundFiles,
-      sessionOwnerUsername: this.options.sessionOwnerUsername
+      sessionOwnerUsername: this.options.sessionOwnerUsername,
+      decisionBridgePath: this.options.decisionBridgePath
     });
     args.push(...permResult.args);
     this.mcpConfigTempFile = permResult.tempFile;
@@ -56341,6 +56351,12 @@ class ClaudeCli extends EventEmitter2 {
     const pid = proc.pid;
     this.process = null;
     this.log.debug(`Killing Claude process (pid=${pid})`);
+    if (process.env.INTEGRATION_TEST === "1") {
+      const stack = new Error().stack?.split(`
+`).slice(2, 7).join(" > ").replace(/\s+at\s+/g, " < ") ?? "?";
+      process.stderr.write(`[claude-cli kill pid=${pid}] | ${stack}
+`);
+    }
     return new Promise((resolve4) => {
       this.log.debug("Sending first SIGINT");
       proc.kill("SIGINT");
@@ -56384,7 +56400,9 @@ class ClaudeCli extends EventEmitter2 {
     return true;
   }
   buildChildEnv() {
-    return buildClaudeChildEnv(process.env, this.options.account);
+    return buildClaudeChildEnv(process.env, this.options.account, {
+      decisionBridge: this.options.decisionBridgePath !== undefined
+    });
   }
   getMcpServerPath() {
     const __filename2 = fileURLToPath3(import.meta.url);
@@ -57237,6 +57255,109 @@ function isAuthorizedForSession(check) {
   return sessionAllowedUsers?.has(username) ?? false;
 }
 
+// src/mcp/decision-bridge.ts
+import { createServer, createConnection } from "node:net";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join9 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdtempSync } from "node:fs";
+import { rm as rm2 } from "node:fs/promises";
+
+class BridgeUnavailableError extends Error {
+}
+function bridgeSocketPath() {
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\ctb-${randomUUID2()}`;
+  }
+  const dir = mkdtempSync(join9(tmpdir2(), "ctb-"));
+  return join9(dir, "b.sock");
+}
+
+class DecisionBridgeServer {
+  server;
+  path;
+  liveSockets = new Set;
+  constructor(server, path2) {
+    this.server = server;
+    this.path = path2;
+  }
+  static async create(handler) {
+    const path2 = bridgeSocketPath();
+    const liveSockets = new Set;
+    const server = createServer((socket) => {
+      liveSockets.add(socket);
+      socket.once("close", () => liveSockets.delete(socket));
+      let buffer = "";
+      const aborter = new AbortController;
+      let responded = false;
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString("utf8");
+        const newline = buffer.indexOf(`
+`);
+        if (newline === -1)
+          return;
+        const line = buffer.slice(0, newline);
+        buffer = "";
+        let request;
+        try {
+          request = JSON.parse(line);
+        } catch {
+          responded = true;
+          socket.end(JSON.stringify({ behavior: "deny", message: "Malformed bridge request" }) + `
+`);
+          return;
+        }
+        handler(request, aborter.signal).then((response) => {
+          responded = true;
+          socket.end(JSON.stringify(response) + `
+`);
+        }).catch((err) => {
+          responded = true;
+          if (err instanceof BridgeUnavailableError) {
+            socket.destroy();
+            return;
+          }
+          socket.end(JSON.stringify({
+            behavior: "deny",
+            message: `Bridge handler failed: ${err instanceof Error ? err.message : String(err)}`
+          }) + `
+`);
+        });
+      });
+      socket.on("close", () => {
+        if (!responded)
+          aborter.abort();
+      });
+      socket.on("error", () => {});
+    });
+    try {
+      await new Promise((resolve4, reject) => {
+        server.once("error", reject);
+        server.listen(path2, () => {
+          server.removeListener("error", reject);
+          resolve4();
+        });
+      });
+    } catch (err) {
+      if (process.platform !== "win32") {
+        await rm2(join9(path2, ".."), { recursive: true, force: true }).catch(() => {});
+      }
+      throw err;
+    }
+    const bridge = new DecisionBridgeServer(server, path2);
+    bridge.liveSockets = liveSockets;
+    return bridge;
+  }
+  async close() {
+    for (const socket of this.liveSockets)
+      socket.destroy();
+    await new Promise((resolve4) => this.server.close(() => resolve4()));
+    if (process.platform !== "win32") {
+      await rm2(join9(this.path, ".."), { recursive: true, force: true }).catch(() => {});
+    }
+  }
+}
+
 // src/commands/registry.ts
 var COMMAND_REGISTRY = [
   {
@@ -58177,7 +58298,7 @@ ${avoidCommands.map((c) => `- \`!${c.command}\` - ${c.reason}`).join(`
 `.trim();
 }
 // src/session/lifecycle.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { existsSync as existsSync12 } from "fs";
 
 // src/utils/keep-alive.ts
@@ -58526,7 +58647,10 @@ function resetSessionActivity(session) {
   session.lastActivityAt = new Date;
   session.timeoutWarningPosted = false;
   session.lifecyclePostId = undefined;
-  transitionTo(session, "active");
+  const state = session.lifecycle.state;
+  if (state !== "restarting" && state !== "cancelling") {
+    transitionTo(session, "active");
+  }
   if (session.worktreeInfo?.worktreePath) {
     updateWorktreeActivity(session.worktreeInfo.worktreePath, session.sessionId);
   }
@@ -58540,23 +58664,23 @@ function updateLastMessage(session, post2) {
 
 // src/operations/streaming/handler.ts
 init_logger();
-import { lstat, mkdir as mkdir2, mkdtemp, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join9 } from "path";
+import { lstat, mkdir as mkdir2, mkdtemp, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join10 } from "path";
 var log19 = createLogger("streaming");
 var UPLOAD_ROOT_DIR = "claude-threads-uploads";
 function safeIdSegment(id) {
   return id.replace(/[^A-Za-z0-9._-]/g, "_");
 }
 function getSessionUploadDir(platformId, threadId) {
-  return join9(tmpdir2(), UPLOAD_ROOT_DIR, `${safeIdSegment(platformId)}-${safeIdSegment(threadId)}`);
+  return join10(tmpdir3(), UPLOAD_ROOT_DIR, `${safeIdSegment(platformId)}-${safeIdSegment(threadId)}`);
 }
 async function cleanupSessionUploads(platformId, threadId) {
   if (!platformId || !threadId)
     return;
   const dir = getSessionUploadDir(platformId, threadId);
   try {
-    await rm2(dir, { recursive: true, force: true });
+    await rm3(dir, { recursive: true, force: true });
   } catch (err) {
     log19.debug(`Upload cleanup for ${platformId}:${threadId} failed (ignored): ${err}`);
   }
@@ -58582,13 +58706,13 @@ async function saveFilesToUploadDir(platform, uploadDir, files, debug = false) {
     log19.error(`Upload dir is a symlink, refusing all writes: ${uploadDir}`);
     return { saved, skipped };
   }
-  const messageDir = await mkdtemp(join9(uploadDir, `${Date.now().toString(36)}-`));
+  const messageDir = await mkdtemp(join10(uploadDir, `${Date.now().toString(36)}-`));
   const usedNames = new Set;
   for (const file of files) {
     try {
       const buffer = await platform.downloadFile(file.id);
       const safeName = dedupeFilename(sanitizeFilename(file.name), usedNames);
-      const absolutePath = join9(messageDir, safeName);
+      const absolutePath = join10(messageDir, safeName);
       await writeFile2(absolutePath, buffer, { mode: 384, flag: "wx" });
       saved.push({
         originalName: file.name,
@@ -58671,12 +58795,13 @@ function buildRestartCliOptions(session, ctx) {
     account: ctx.account,
     uploadDir: getSessionUploadDir(session.platformId, session.threadId),
     outboundFiles: platformMcpConfig.outboundFiles,
-    sessionOwnerUsername: session.startedBy
+    sessionOwnerUsername: session.startedBy,
+    decisionBridgePath: session.decisionBridge?.path
   };
 }
 
 // src/operations/commands/handler.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { resolve as resolve5 } from "path";
 import { existsSync as existsSync11, statSync as statSync3 } from "fs";
 
@@ -62094,8 +62219,8 @@ init_emoji();
 // src/operations/bug-report/handler.ts
 import { execSync as execSync2 } from "child_process";
 import { writeFileSync as writeFileSync6, unlinkSync as unlinkSync3 } from "fs";
-import { tmpdir as tmpdir3 } from "os";
-import { join as join10 } from "path";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join11 } from "path";
 
 // node_modules/@redactpii/node/lib/index.mjs
 class Redactor {
@@ -62641,9 +62766,9 @@ _Reported via claude-threads bug report feature_`);
 function escapeShell(str2) {
   return str2.replace(/"/g, "\\\"");
 }
-function checkGitHubCli() {
+function checkGitHubCli(exec2 = execSync2) {
   try {
-    execSync2("gh --version", {
+    exec2("gh --version", {
       encoding: "utf-8",
       timeout: 5000,
       stdio: ["pipe", "pipe", "pipe"]
@@ -62656,7 +62781,7 @@ function checkGitHubCli() {
     };
   }
   try {
-    execSync2("gh auth status", {
+    exec2("gh auth status", {
       encoding: "utf-8",
       timeout: 5000,
       stdio: ["pipe", "pipe", "pipe"]
@@ -62675,7 +62800,7 @@ async function createGitHubIssue(title, body, workingDir) {
   if (!ghStatus.installed || !ghStatus.authenticated) {
     throw new Error(ghStatus.error);
   }
-  const bodyFile = join10(tmpdir3(), `bug-body-${Date.now()}.md`);
+  const bodyFile = join11(tmpdir4(), `bug-body-${Date.now()}.md`);
   try {
     writeFileSync6(bodyFile, body, "utf-8");
     const cmd = `gh issue create --repo "${GITHUB_REPO}" --title "${escapeShell(title)}" --body-file "${bodyFile}"`;
@@ -66708,6 +66833,8 @@ class MessageManager {
   emitSessionUpdateCallback;
   toolStartTimes = new Map;
   taskTracker = new TaskTracker;
+  pendingBridgePlan = null;
+  pendingBridgeQuestion = null;
   flushTimer = null;
   static DEFAULT_FLUSH_DELAY_MS = 500;
   flushDelayMs;
@@ -67169,9 +67296,66 @@ class MessageManager {
     logger.debug("Reaction not handled by any executor");
     return false;
   }
+  handleBridgeRequest(request, signal) {
+    if (request.kind === "plan_approval") {
+      this.pendingBridgePlan?.resolve({ behavior: "deny", message: "Superseded by a newer plan" });
+      return new Promise((resolve5) => {
+        const pending = { resolve: resolve5, input: request.input };
+        this.pendingBridgePlan = pending;
+        signal?.addEventListener("abort", () => {
+          if (this.pendingBridgePlan === pending)
+            this.pendingBridgePlan = null;
+        });
+      });
+    }
+    if (request.kind === "question") {
+      this.pendingBridgeQuestion?.resolve({ behavior: "deny", message: "Superseded by newer questions" });
+      return new Promise((resolve5) => {
+        const pending = { resolve: resolve5, input: request.input };
+        this.pendingBridgeQuestion = pending;
+        signal?.addEventListener("abort", () => {
+          if (this.pendingBridgeQuestion === pending)
+            this.pendingBridgeQuestion = null;
+        });
+      });
+    }
+    return Promise.resolve({ behavior: "deny", message: `Unknown bridge request kind` });
+  }
+  resolveBridgePlan(approved) {
+    const pending = this.pendingBridgePlan;
+    if (!pending)
+      return false;
+    this.pendingBridgePlan = null;
+    pending.resolve(approved ? { behavior: "allow", updatedInput: pending.input } : { behavior: "deny", message: "The user rejected the plan." });
+    return true;
+  }
+  resolveBridgeQuestion(answers) {
+    const pending = this.pendingBridgeQuestion;
+    if (!pending)
+      return false;
+    this.pendingBridgeQuestion = null;
+    const questions = Array.isArray(pending.input.questions) ? pending.input.questions : [];
+    const record = {};
+    for (const a of answers) {
+      const match = questions.find((q) => q.header === a.header);
+      record[match?.question ?? a.header] = a.answer;
+    }
+    pending.resolve({
+      behavior: "allow",
+      updatedInput: { ...pending.input, answers: record }
+    });
+    return true;
+  }
+  denyPendingBridgeRequests(reason) {
+    this.pendingBridgePlan?.resolve({ behavior: "deny", message: reason });
+    this.pendingBridgePlan = null;
+    this.pendingBridgeQuestion?.resolve({ behavior: "deny", message: reason });
+    this.pendingBridgeQuestion = null;
+  }
   clearClaudeSessionState() {
     this.toolStartTimes.clear();
     this.taskTracker.clear();
+    this.denyPendingBridgeRequests("Claude was restarted before a decision was made");
   }
   reset() {
     this.cancelScheduledFlush();
@@ -67187,6 +67371,7 @@ class MessageManager {
     this.systemExecutor.reset();
   }
   dispose() {
+    this.denyPendingBridgeRequests("Session ended before a decision was made");
     this.cancelScheduledFlush();
     this.postTracker.clearSession(this.sessionId);
     this.events.removeAllListeners();
@@ -67967,7 +68152,7 @@ async function suggestBranchNames(workingDir, userMessage) {
 
 // src/operations/worktree/handler.ts
 init_worktree();
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 init_logger();
 var log25 = createLogger("worktree");
 var sessionLog2 = createSessionLog(log25);
@@ -68214,7 +68399,7 @@ async function createAndSwitchToWorktree(session, branch, username, options) {
         transitionTo(session, "restarting");
         await session.claude.kill();
         await options.flush(session);
-        const newSessionId = randomUUID2();
+        const newSessionId = randomUUID3();
         session.claudeSessionId = newSessionId;
         const needsTitlePrompt = !session.sessionTitle;
         const cliOptions = {
@@ -68233,10 +68418,14 @@ async function createAndSwitchToWorktree(session, branch, username, options) {
           appendSystemPrompt: await buildAppendSystemPrompt(session.platform, session.platformId, existing.path, session.threadId, session.startedBy, session.sessionAllowedUsers, options.appendSystemPrompt ?? "", options.githubEmailsStore, { omitSessionContext: !needsTitlePrompt, userAttribution: session.userAttribution })
         };
         session.messageManager?.clearClaudeSessionState();
-        session.claude = new ClaudeCli(cliOptions);
-        session.claude.on("event", (e) => options.handleEvent(session.sessionId, e));
-        session.claude.on("exit", (code) => options.handleExit(session.sessionId, code));
-        session.claude.start();
+        const newClaude = new ClaudeCli(cliOptions);
+        session.claude = newClaude;
+        newClaude.on("event", (e) => options.handleEvent(session.sessionId, e));
+        newClaude.on("exit", (code) => options.handleExit(session.sessionId, code, newClaude));
+        newClaude.start();
+        if (isSessionRestarting(session)) {
+          transitionTo(session, "active");
+        }
       }
       await options.updateSessionHeader(session);
       await post(session, "success", `${fmt.formatBold("Joined existing worktree")} for branch ${fmt.formatCode(branch)}
@@ -68307,7 +68496,7 @@ ${fmt.formatItalic("Claude Code restarted in the worktree")}`);
       transitionTo(session, "restarting");
       await session.claude.kill();
       await options.flush(session);
-      const newSessionId = randomUUID2();
+      const newSessionId = randomUUID3();
       session.claudeSessionId = newSessionId;
       const needsTitlePrompt = !session.sessionTitle;
       const cliOptions = {
@@ -68326,10 +68515,14 @@ ${fmt.formatItalic("Claude Code restarted in the worktree")}`);
         appendSystemPrompt: await buildAppendSystemPrompt(session.platform, session.platformId, worktreePath, session.threadId, session.startedBy, session.sessionAllowedUsers, options.appendSystemPrompt ?? "", options.githubEmailsStore, { omitSessionContext: !needsTitlePrompt, userAttribution: session.userAttribution })
       };
       session.messageManager?.clearClaudeSessionState();
-      session.claude = new ClaudeCli(cliOptions);
-      session.claude.on("event", (e) => options.handleEvent(session.sessionId, e));
-      session.claude.on("exit", (code) => options.handleExit(session.sessionId, code));
-      session.claude.start();
+      const newClaude = new ClaudeCli(cliOptions);
+      session.claude = newClaude;
+      newClaude.on("event", (e) => options.handleEvent(session.sessionId, e));
+      newClaude.on("exit", (code) => options.handleExit(session.sessionId, code, newClaude));
+      newClaude.start();
+      if (isSessionRestarting(session)) {
+        transitionTo(session, "active");
+      }
     }
     await options.updateSessionHeader(session);
     const shortWorktreePath = shortenPath(worktreePath, undefined, { path: worktreePath, branch });
@@ -69227,18 +69420,25 @@ async function restartClaudeSession(session, cliOptions, ctx, actionName) {
   transitionTo(session, "restarting");
   await session.claude.kill();
   await ctx.ops.flush(session);
+  session.messageManager?.denyPendingBridgeRequests("Claude was restarted before a decision was made");
   if (!cliOptions.resume) {
     session.messageManager?.clearClaudeSessionState();
   }
-  session.claude = new ClaudeCli(cliOptions);
-  session.claude.on("event", (e) => ctx.ops.handleEvent(session.sessionId, e));
-  session.claude.on("exit", (code) => ctx.ops.handleExit(session.sessionId, code));
-  session.claude.on("rate-limit", (hit) => handleRateLimit(session, hit, ctx));
+  const newClaude = new ClaudeCli(cliOptions);
+  session.claude = newClaude;
+  newClaude.on("event", (e) => ctx.ops.handleEvent(session.sessionId, e));
+  newClaude.on("exit", (code) => ctx.ops.handleExit(session.sessionId, code, newClaude));
+  newClaude.on("rate-limit", (hit) => handleRateLimit(session, hit, ctx));
   try {
-    session.claude.start();
+    newClaude.start();
+    if (isSessionRestarting(session)) {
+      transitionTo(session, "active");
+    }
     return true;
   } catch (err) {
-    transitionTo(session, "active");
+    if (isSessionRestarting(session)) {
+      transitionTo(session, "active");
+    }
     await logAndNotify(err, { action: actionName, session });
     return false;
   }
@@ -69302,12 +69502,18 @@ async function approvePendingPlan(session, username, ctx) {
   }
   const { postId } = pendingApproval;
   sessionLog5(session).info(`✅ Plan approved by @${username} via command`);
+  const viaBridge = session.messageManager?.resolveBridgePlan(true) ?? false;
   const formatter = session.platform.getFormatter();
   const statusMessage = `${formatter.formatBold("Plan approved")} by ${formatter.formatUserMention(username)} - starting implementation...`;
   await updatePostSuccess(session, postId, statusMessage);
   session.messageManager?.clearPendingApproval();
   session.messageManager?.clearPendingQuestionSet();
   session.planApproved = true;
+  if (viaBridge) {
+    sessionLog5(session).info("Plan approved via decision bridge (!approve)");
+    ctx.ops.startTyping(session);
+    return;
+  }
   if (session.claude.isRunning()) {
     session.claude.sendMessage("Plan approved! Please proceed with the implementation.");
     ctx.ops.startTyping(session);
@@ -69370,7 +69576,7 @@ async function changeDirectory(session, newDir, username, ctx) {
     sessionLog5(session).debug(`Stored work summary for context preservation`);
   }
   session.workingDir = absoluteDir;
-  const newSessionId = randomUUID3();
+  const newSessionId = randomUUID4();
   session.claudeSessionId = newSessionId;
   const appendSystemPrompt = await buildAppendSystemPrompt(session.platform, session.platformId, absoluteDir, session.threadId, session.startedBy, session.sessionAllowedUsers, CHAT_PLATFORM_PROMPT, ctx.state.githubEmailsStore, { userAttribution: session.userAttribution });
   const cliOptions = {
@@ -69887,6 +70093,8 @@ async function cleanupSession(session, ctx, options = {}) {
     await closeThreadLogger(session, action, details);
   }
   session.messageManager?.dispose();
+  session.decisionBridge?.close();
+  session.decisionBridge = undefined;
   ctx.ops.emitSessionRemove(session.sessionId);
   mutableSessions(ctx).delete(session.sessionId);
   if (doCleanupPostIndex) {
@@ -69904,6 +70112,8 @@ function releaseAccountIfHeld(session, ctx) {
 }
 function removeFromRegistry(session, ctx) {
   session.messageManager?.dispose();
+  session.decisionBridge?.close();
+  session.decisionBridge = undefined;
   ctx.ops.emitSessionRemove(session.sessionId);
   mutableSessions(ctx).delete(session.sessionId);
   cleanupPostIndex(ctx, session.threadId);
@@ -69929,6 +70139,20 @@ function findPersistedByThreadId(persisted, threadId) {
   }
   return;
 }
+async function createSessionDecisionBridge(ref) {
+  try {
+    return await DecisionBridgeServer.create(async (request, signal) => {
+      const messageManager = ref.current?.messageManager;
+      if (!messageManager) {
+        throw new BridgeUnavailableError("Session is not ready for decisions yet");
+      }
+      return messageManager.handleBridgeRequest(request, signal);
+    });
+  } catch (err) {
+    log31.warn(`Decision bridge unavailable — falling back to legacy MCP prompts: ${err}`);
+    return null;
+  }
+}
 function createMessageManager(session, ctx) {
   const postTracker = new PostTracker;
   const messageManager = new MessageManager({
@@ -69959,10 +70183,20 @@ function createMessageManager(session, ctx) {
     flushDelayMs: ctx.config.flushDelayMs
   });
   messageManager.events.on("question:complete", ({ toolUseId: _toolUseId, answers }) => {
+    if (messageManager.resolveBridgeQuestion(answers)) {
+      sessionLog6(session).info("Question answered via decision bridge");
+      ctx.ops.startTyping(session);
+      return;
+    }
     const answerJson = JSON.stringify(answers);
     session.claude.sendMessage(answerJson);
   });
   messageManager.events.on("approval:complete", ({ toolUseId: _toolUseId, approved }) => {
+    if (messageManager.resolveBridgePlan(approved)) {
+      sessionLog6(session).info(`Plan ${approved ? "approved" : "denied"} via decision bridge`);
+      ctx.ops.startTyping(session);
+      return;
+    }
     const response = approved ? "approved" : "denied";
     session.claude.sendMessage(response);
   });
@@ -70228,7 +70462,7 @@ async function startSession(options, username, displayName, replyToPostId, platf
   const actualThreadId = replyToPostId || (startPost ? startPost.id : "");
   const sessionId = ctx.ops.getSessionId(platformId, actualThreadId);
   platform.sendTyping(actualThreadId);
-  const claudeSessionId = randomUUID4();
+  const claudeSessionId = randomUUID5();
   let workingDir = ctx.config.workingDir;
   let permissionMode = ctx.config.permissionMode;
   let forceInteractivePermissions = false;
@@ -70282,6 +70516,8 @@ async function startSession(options, username, displayName, replyToPostId, platf
   if (claudeAccount) {
     log31.info(`Session ${sessionId.substring(0, 20)} reserved Claude account "${claudeAccount.id}"`);
   }
+  const bridgeSessionRef = {};
+  const decisionBridge = await createSessionDecisionBridge(bridgeSessionRef);
   const cliOptions = {
     workingDir,
     threadId: actualThreadId,
@@ -70296,9 +70532,16 @@ async function startSession(options, username, displayName, replyToPostId, platf
     account: claudeAccount ? { id: claudeAccount.id, home: claudeAccount.home, apiKey: claudeAccount.apiKey } : undefined,
     uploadDir: getSessionUploadDir(platformId, actualThreadId),
     outboundFiles: platformMcpConfig.outboundFiles,
-    sessionOwnerUsername: username
+    sessionOwnerUsername: username,
+    decisionBridgePath: decisionBridge?.path
   };
-  const claude = new ClaudeCli(cliOptions);
+  let claude;
+  try {
+    claude = new ClaudeCli(cliOptions);
+  } catch (err) {
+    decisionBridge?.close();
+    throw err;
+  }
   const session = {
     platformId,
     threadId: actualThreadId,
@@ -70332,7 +70575,9 @@ async function startSession(options, username, displayName, replyToPostId, platf
       enabled: ctx.config.threadLogsEnabled ?? true
     })
   };
+  session.decisionBridge = decisionBridge ?? undefined;
   session.messageManager = createMessageManager(session, ctx);
+  bridgeSessionRef.current = session;
   session.threadLogger?.logLifecycle("start", {
     username,
     workingDir: ctx.config.workingDir
@@ -70351,7 +70596,7 @@ async function startSession(options, username, displayName, replyToPostId, platf
   await ctx.ops.updateStickyMessage();
   ctx.ops.startTyping(session);
   claude.on("event", (e) => ctx.ops.handleEvent(sessionId, e));
-  claude.on("exit", (code) => ctx.ops.handleExit(sessionId, code));
+  claude.on("exit", (code) => ctx.ops.handleExit(sessionId, code, claude));
   claude.on("rate-limit", (hit) => handleRateLimit(session, hit, ctx));
   try {
     claude.start();
@@ -70359,6 +70604,8 @@ async function startSession(options, username, displayName, replyToPostId, platf
     await logAndNotify(err, { action: "Start Claude", session });
     ctx.ops.stopTyping(session);
     session.messageManager?.dispose();
+    session.decisionBridge?.close();
+    session.decisionBridge = undefined;
     ctx.ops.emitSessionRemove(session.sessionId);
     mutableSessions(ctx).delete(session.sessionId);
     releaseAccountIfHeld(session, ctx);
@@ -70442,6 +70689,8 @@ Please start a new session.`), { action: "Post resume failure notification" });
   if (state.claudeAccountId && !claudeAccount) {
     log31.warn(`Persisted session referenced Claude account "${state.claudeAccountId}" ` + `which is no longer configured — resuming under default env`);
   }
+  const resumeBridgeRef = {};
+  const resumeBridge = await createSessionDecisionBridge(resumeBridgeRef);
   const cliOptions = {
     workingDir: state.workingDir,
     threadId: state.threadId,
@@ -70456,9 +70705,16 @@ Please start a new session.`), { action: "Post resume failure notification" });
     account: claudeAccount ? { id: claudeAccount.id, home: claudeAccount.home, apiKey: claudeAccount.apiKey } : undefined,
     uploadDir: getSessionUploadDir(platformId, state.threadId),
     outboundFiles: platformMcpConfig.outboundFiles,
-    sessionOwnerUsername: state.startedBy
+    sessionOwnerUsername: state.startedBy,
+    decisionBridgePath: resumeBridge?.path
   };
-  const claude = new ClaudeCli(cliOptions);
+  let claude;
+  try {
+    claude = new ClaudeCli(cliOptions);
+  } catch (err) {
+    resumeBridge?.close();
+    throw err;
+  }
   const session = {
     platformId,
     threadId: state.threadId,
@@ -70504,6 +70760,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
       enabled: ctx.config.threadLogsEnabled ?? true
     })
   };
+  session.decisionBridge = resumeBridge ?? undefined;
   if (!session.worktreeInfo) {
     const detected = await detectWorktreeInfo(session.workingDir);
     if (detected) {
@@ -70516,6 +70773,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
     }
   }
   session.messageManager = createMessageManager(session, ctx);
+  resumeBridgeRef.current = session;
   await session.messageManager.restoreTaskListFromPersistence({
     tasksPostId: state.tasksPostId,
     lastTasksContent: state.lastTasksContent,
@@ -70546,7 +70804,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
   ctx.ops.emitSessionAdd(session);
   keepAlive.sessionStarted();
   claude.on("event", (e) => ctx.ops.handleEvent(sessionId, e));
-  claude.on("exit", (code) => ctx.ops.handleExit(sessionId, code));
+  claude.on("exit", (code) => ctx.ops.handleExit(sessionId, code, claude));
   claude.on("rate-limit", (hit) => handleRateLimit(session, hit, ctx));
   try {
     claude.start();
@@ -70571,6 +70829,8 @@ ${sessionFormatter.formatItalic("Reconnected to Claude session. You can continue
   } catch (err) {
     log31.error(`Failed to resume session ${shortId}`, err instanceof Error ? err : undefined);
     session.messageManager?.dispose();
+    session.decisionBridge?.close();
+    session.decisionBridge = undefined;
     ctx.ops.emitSessionRemove(sessionId);
     mutableSessions(ctx).delete(sessionId);
     ctx.state.sessionStore.remove(sessionId);
@@ -70634,7 +70894,7 @@ async function resumePausedSession(threadId, message, files, ctx, username) {
     log31.warn(`Failed to resume session ${shortId}..., could not send message`);
   }
 }
-async function handleExit(sessionId, code, ctx) {
+async function handleExit(sessionId, code, ctx, source) {
   const session = mutableSessions(ctx).get(sessionId);
   const shortId = sessionId.substring(0, 8);
   sessionLog6(session).debug(`handleExit called code=${code} isShuttingDown=${ctx.state.isShuttingDown}`);
@@ -70642,6 +70902,10 @@ async function handleExit(sessionId, code, ctx) {
     log31.debug(`Session ${shortId}... not found (already cleaned up)`);
     return;
   }
+  if (source && session.claude !== source) {
+    sessionLog6(session).debug(`Ignoring exit from replaced Claude process`);
+    return;
+  }
   if (isSessionRestarting(session)) {
     sessionLog6(session).debug(`Restarting, skipping cleanup`);
     transitionTo(session, "active");
@@ -71365,7 +71629,7 @@ class SessionManager extends EventEmitter4 {
       updateSessionHeader: (s) => this.updateSessionHeader(s),
       updateStickyMessage: () => this.updateStickyMessage(),
       handleEvent: (sid, e) => this.handleEvent(sid, e),
-      handleExit: (sid, code) => this.handleExit(sid, code),
+      handleExit: (sid, code, source) => this.handleExit(sid, code, source),
       killSession: (tid) => this.killSession(tid),
       shouldPromptForWorktree: (s) => this.shouldPromptForWorktree(s),
       postWorktreePrompt: (s, r) => this.postWorktreePrompt(s, r),
@@ -71469,8 +71733,8 @@ class SessionManager extends EventEmitter4 {
     session.messageManager.handleEvent(event);
     handleEventPostProcessing(session, event, this.getContext());
   }
-  async handleExit(sessionId, code) {
-    await handleExit(sessionId, code, this.getContext());
+  async handleExit(sessionId, code, source) {
+    await handleExit(sessionId, code, this.getContext(), source);
   }
   startTyping(session) {
     const wasTyping = session.timers.typingTimer !== null;
@@ -71985,7 +72249,7 @@ class SessionManager extends EventEmitter4 {
       worktreeMode: this.worktreeMode,
       permissionTimeoutMs: this.limits.permissionTimeoutSeconds * 1000,
       handleEvent: (tid, e) => this.handleEvent(tid, e),
-      handleExit: (tid, code) => this.handleExit(tid, code),
+      handleExit: (tid, code, source) => this.handleExit(tid, code, source),
       updateSessionHeader: (s) => this.updateSessionHeader(s),
       flush: async (s) => {
         if (s.messageManager) {
@@ -82561,7 +82825,7 @@ class UpdateInstaller {
 init_logger();
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync15, statSync as statSync4 } from "fs";
-import { delimiter, join as join11 } from "path";
+import { delimiter, join as join12 } from "path";
 var log39 = createLogger("respawn");
 function decideRespawn(env5 = process.env, isTTY = !!process.stdout.isTTY) {
   if (env5.CLAUDE_THREADS_BIN) {
@@ -82587,16 +82851,16 @@ function resolveClaudeThreadsBin(_env = process.env, _existsSync = existsSync15,
   const path10 = _env.PATH || _env.Path || "";
   const dirs = path10.split(delimiter).filter(Boolean);
   const home = _env.HOME || _env.USERPROFILE;
-  const bunRoot = _env.BUN_INSTALL || (home ? join11(home, ".bun") : null);
+  const bunRoot = _env.BUN_INSTALL || (home ? join12(home, ".bun") : null);
   if (bunRoot) {
-    const bunBin = join11(bunRoot, "bin");
+    const bunBin = join12(bunRoot, "bin");
     if (!dirs.includes(bunBin)) {
       dirs.push(bunBin);
     }
   }
   for (const dir of dirs) {
     for (const name of names) {
-      const candidate = join11(dir, name);
+      const candidate = join12(dir, name);
       if (_existsSync(candidate) && _isFileExecutable(candidate)) {
         return candidate;
       }

package/dist/mcp/mcp-server.js

@@ -51569,6 +51569,8 @@ class MessageManager {
   emitSessionUpdateCallback;
   toolStartTimes = new Map;
   taskTracker = new TaskTracker;
+  pendingBridgePlan = null;
+  pendingBridgeQuestion = null;
   flushTimer = null;
   static DEFAULT_FLUSH_DELAY_MS = 500;
   flushDelayMs;
@@ -52030,9 +52032,66 @@ class MessageManager {
     logger.debug("Reaction not handled by any executor");
     return false;
   }
+  handleBridgeRequest(request, signal) {
+    if (request.kind === "plan_approval") {
+      this.pendingBridgePlan?.resolve({ behavior: "deny", message: "Superseded by a newer plan" });
+      return new Promise((resolve2) => {
+        const pending = { resolve: resolve2, input: request.input };
+        this.pendingBridgePlan = pending;
+        signal?.addEventListener("abort", () => {
+          if (this.pendingBridgePlan === pending)
+            this.pendingBridgePlan = null;
+        });
+      });
+    }
+    if (request.kind === "question") {
+      this.pendingBridgeQuestion?.resolve({ behavior: "deny", message: "Superseded by newer questions" });
+      return new Promise((resolve2) => {
+        const pending = { resolve: resolve2, input: request.input };
+        this.pendingBridgeQuestion = pending;
+        signal?.addEventListener("abort", () => {
+          if (this.pendingBridgeQuestion === pending)
+            this.pendingBridgeQuestion = null;
+        });
+      });
+    }
+    return Promise.resolve({ behavior: "deny", message: `Unknown bridge request kind` });
+  }
+  resolveBridgePlan(approved) {
+    const pending = this.pendingBridgePlan;
+    if (!pending)
+      return false;
+    this.pendingBridgePlan = null;
+    pending.resolve(approved ? { behavior: "allow", updatedInput: pending.input } : { behavior: "deny", message: "The user rejected the plan." });
+    return true;
+  }
+  resolveBridgeQuestion(answers) {
+    const pending = this.pendingBridgeQuestion;
+    if (!pending)
+      return false;
+    this.pendingBridgeQuestion = null;
+    const questions = Array.isArray(pending.input.questions) ? pending.input.questions : [];
+    const record4 = {};
+    for (const a of answers) {
+      const match = questions.find((q) => q.header === a.header);
+      record4[match?.question ?? a.header] = a.answer;
+    }
+    pending.resolve({
+      behavior: "allow",
+      updatedInput: { ...pending.input, answers: record4 }
+    });
+    return true;
+  }
+  denyPendingBridgeRequests(reason) {
+    this.pendingBridgePlan?.resolve({ behavior: "deny", message: reason });
+    this.pendingBridgePlan = null;
+    this.pendingBridgeQuestion?.resolve({ behavior: "deny", message: reason });
+    this.pendingBridgeQuestion = null;
+  }
   clearClaudeSessionState() {
     this.toolStartTimes.clear();
     this.taskTracker.clear();
+    this.denyPendingBridgeRequests("Claude was restarted before a decision was made");
   }
   reset() {
     this.cancelScheduledFlush();
@@ -52048,6 +52107,7 @@ class MessageManager {
     this.systemExecutor.reset();
   }
   dispose() {
+    this.denyPendingBridgeRequests("Session ended before a decision was made");
     this.cancelScheduledFlush();
     this.postTracker.clearSession(this.sessionId);
     this.events.removeAllListeners();
@@ -55751,6 +55811,148 @@ class UsernameAnonymizer {
     return anonymized;
   }
 }
+// src/mcp/decision-bridge.ts
+import { createServer, createConnection } from "node:net";
+import { tmpdir } from "node:os";
+import { join as join3 } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdtempSync } from "node:fs";
+import { rm } from "node:fs/promises";
+
+class BridgeUnavailableError extends Error {
+}
+function bridgeSocketPath() {
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\ctb-${randomUUID()}`;
+  }
+  const dir = mkdtempSync(join3(tmpdir(), "ctb-"));
+  return join3(dir, "b.sock");
+}
+
+class DecisionBridgeServer {
+  server;
+  path;
+  liveSockets = new Set;
+  constructor(server, path) {
+    this.server = server;
+    this.path = path;
+  }
+  static async create(handler2) {
+    const path = bridgeSocketPath();
+    const liveSockets = new Set;
+    const server = createServer((socket) => {
+      liveSockets.add(socket);
+      socket.once("close", () => liveSockets.delete(socket));
+      let buffer = "";
+      const aborter = new AbortController;
+      let responded = false;
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString("utf8");
+        const newline = buffer.indexOf(`
+`);
+        if (newline === -1)
+          return;
+        const line = buffer.slice(0, newline);
+        buffer = "";
+        let request;
+        try {
+          request = JSON.parse(line);
+        } catch {
+          responded = true;
+          socket.end(JSON.stringify({ behavior: "deny", message: "Malformed bridge request" }) + `
+`);
+          return;
+        }
+        handler2(request, aborter.signal).then((response) => {
+          responded = true;
+          socket.end(JSON.stringify(response) + `
+`);
+        }).catch((err) => {
+          responded = true;
+          if (err instanceof BridgeUnavailableError) {
+            socket.destroy();
+            return;
+          }
+          socket.end(JSON.stringify({
+            behavior: "deny",
+            message: `Bridge handler failed: ${err instanceof Error ? err.message : String(err)}`
+          }) + `
+`);
+        });
+      });
+      socket.on("close", () => {
+        if (!responded)
+          aborter.abort();
+      });
+      socket.on("error", () => {});
+    });
+    try {
+      await new Promise((resolve4, reject) => {
+        server.once("error", reject);
+        server.listen(path, () => {
+          server.removeListener("error", reject);
+          resolve4();
+        });
+      });
+    } catch (err) {
+      if (process.platform !== "win32") {
+        await rm(join3(path, ".."), { recursive: true, force: true }).catch(() => {});
+      }
+      throw err;
+    }
+    const bridge = new DecisionBridgeServer(server, path);
+    bridge.liveSockets = liveSockets;
+    return bridge;
+  }
+  async close() {
+    for (const socket of this.liveSockets)
+      socket.destroy();
+    await new Promise((resolve4) => this.server.close(() => resolve4()));
+    if (process.platform !== "win32") {
+      await rm(join3(this.path, ".."), { recursive: true, force: true }).catch(() => {});
+    }
+  }
+}
+function requestBridgeDecision(path, request, timeoutMs) {
+  return new Promise((resolve4, reject) => {
+    const socket = createConnection(path);
+    let buffer = "";
+    let settled = false;
+    const fail = (err) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      reject(err);
+    };
+    const timer = setTimeout(() => fail(new Error(`Bridge decision timed out after ${timeoutMs}ms`)), timeoutMs);
+    socket.on("connect", () => {
+      socket.write(JSON.stringify(request) + `
+`);
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      const newline = buffer.indexOf(`
+`);
+      if (newline === -1)
+        return;
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      try {
+        resolve4(JSON.parse(buffer.slice(0, newline)));
+      } catch {
+        reject(new Error("Malformed bridge response"));
+      }
+    });
+    socket.on("error", (err) => fail(err));
+    socket.on("close", () => fail(new Error("Bridge connection closed before a decision arrived")));
+  });
+}
+
 // src/utils/spawn.ts
 import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "child_process";
 var isWindows = process.platform === "win32";
@@ -55769,8 +55971,8 @@ import { EventEmitter as EventEmitter2 } from "events";
 import { resolve as resolve4, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { existsSync as existsSync4, readFileSync as readFileSync3, watchFile, unwatchFile, unlinkSync, statSync, readdirSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join4 } from "path";
 
 // src/mcp/outbound-env.ts
 var OUTBOUND_ENV = {
@@ -55864,11 +56066,11 @@ function parseRateLimitEvent(event, now = Date.now()) {
 var log8 = createLogger("claude");
 function cleanupBrowserBridgeSockets() {
   try {
-    const tempDir = tmpdir();
+    const tempDir = tmpdir2();
     const files = readdirSync(tempDir);
     for (const file2 of files) {
       if (file2.startsWith("claude-mcp-browser-bridge-")) {
-        const filePath = join3(tempDir, file2);
+        const filePath = join4(tempDir, file2);
         try {
           const stats = statSync(filePath);
           if (stats.isSocket()) {
@@ -55882,7 +56084,7 @@ function cleanupBrowserBridgeSockets() {
     log8.debug(`Browser bridge cleanup failed: ${err}`);
   }
 }
-function buildClaudeChildEnv(parentEnv, account) {
+function buildClaudeChildEnv(parentEnv, account, opts) {
   const env = { ...parentEnv };
   if (env.MCP_CONNECTION_NONBLOCKING === undefined) {
     env.MCP_CONNECTION_NONBLOCKING = "true";
@@ -55890,6 +56092,9 @@ function buildClaudeChildEnv(parentEnv, account) {
   if (env.ENABLE_PROMPT_CACHING_1H === undefined) {
     env.ENABLE_PROMPT_CACHING_1H = "true";
   }
+  if (opts?.decisionBridge && env.MCP_TOOL_TIMEOUT === undefined) {
+    env.MCP_TOOL_TIMEOUT = "3600000";
+  }
   if (account?.home) {
     env.HOME = account.home;
     env.USERPROFILE = account.home;
@@ -55913,8 +56118,8 @@ function materializeMcpConfig(config3, sessionId, opts = {}) {
   if (opts.inline) {
     return { mode: "inline", value: JSON.stringify(config3) };
   }
-  const dir = opts.tmpDirOverride ?? tmpdir();
-  const path = join3(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
+  const dir = opts.tmpDirOverride ?? tmpdir2();
+  const path = join4(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
   writeFileSync(path, JSON.stringify(config3), { mode: 384 });
   return { mode: "file", path };
 }
@@ -55938,6 +56143,12 @@ function buildPermissionArgs(opts) {
     PERMISSION_TIMEOUT_MS: String(opts.permissionTimeoutMs),
     SESSION_OWNER_USERNAME: opts.sessionOwnerUsername || ""
   };
+  if (opts.decisionBridgePath) {
+    mcpEnv.DECISION_BRIDGE_PATH = opts.decisionBridgePath;
+    if (process.env.DECISION_BRIDGE_TIMEOUT_MS) {
+      mcpEnv.DECISION_BRIDGE_TIMEOUT_MS = process.env.DECISION_BRIDGE_TIMEOUT_MS;
+    }
+  }
   if (opts.platformConfig.appToken) {
     mcpEnv.PLATFORM_APP_TOKEN = opts.platformConfig.appToken;
   }
@@ -56078,7 +56289,8 @@ class ClaudeCli extends EventEmitter2 {
       workingDir: this.options.workingDir,
       uploadDir: this.options.uploadDir,
       outboundFiles: this.options.outboundFiles,
-      sessionOwnerUsername: this.options.sessionOwnerUsername
+      sessionOwnerUsername: this.options.sessionOwnerUsername,
+      decisionBridgePath: this.options.decisionBridgePath
     });
     args.push(...permResult.args);
     this.mcpConfigTempFile = permResult.tempFile;
@@ -56089,7 +56301,7 @@ class ClaudeCli extends EventEmitter2 {
       args.push("--append-system-prompt", this.options.appendSystemPrompt);
     }
     if (this.options.sessionId) {
-      this.statusFilePath = join3(tmpdir(), `claude-threads-status-${this.options.sessionId}.json`);
+      this.statusFilePath = join4(tmpdir2(), `claude-threads-status-${this.options.sessionId}.json`);
       const statusLineWriterPath = this.getStatusLineWriterPath();
       const statusLineSettings = {
         statusLine: {
@@ -56263,6 +56475,12 @@ class ClaudeCli extends EventEmitter2 {
     const pid = proc.pid;
     this.process = null;
     this.log.debug(`Killing Claude process (pid=${pid})`);
+    if (process.env.INTEGRATION_TEST === "1") {
+      const stack = new Error().stack?.split(`
+`).slice(2, 7).join(" > ").replace(/\s+at\s+/g, " < ") ?? "?";
+      process.stderr.write(`[claude-cli kill pid=${pid}] | ${stack}
+`);
+    }
     return new Promise((resolve5) => {
       this.log.debug("Sending first SIGINT");
       proc.kill("SIGINT");
@@ -56306,7 +56524,9 @@ class ClaudeCli extends EventEmitter2 {
     return true;
   }
   buildChildEnv() {
-    return buildClaudeChildEnv(process.env, this.options.account);
+    return buildClaudeChildEnv(process.env, this.options.account, {
+      decisionBridge: this.options.decisionBridgePath !== undefined
+    });
   }
   getMcpServerPath() {
     const __filename2 = fileURLToPath3(import.meta.url);
@@ -56999,10 +57219,10 @@ init_emoji();
 
 // src/persistence/github-emails-store.ts
 import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var log18 = createLogger("gh-emails");
-var DEFAULT_CONFIG_DIR = join5(homedir4(), ".config", "claude-threads");
-var DEFAULT_FILE = join5(DEFAULT_CONFIG_DIR, "github-emails.yaml");
+var DEFAULT_CONFIG_DIR = join6(homedir4(), ".config", "claude-threads");
+var DEFAULT_FILE = join6(DEFAULT_CONFIG_DIR, "github-emails.yaml");
 
 // src/operations/commands/handler.ts
 var log19 = createLogger("commands");
@@ -58374,6 +58594,8 @@ var PLATFORM_CHANNEL_ID = process.env.PLATFORM_CHANNEL_ID || "";
 var PLATFORM_THREAD_ID = process.env.PLATFORM_THREAD_ID || "";
 var ALLOWED_USERS = (process.env.ALLOWED_USERS || "").split(",").map((u) => u.trim()).filter((u) => u.length > 0);
 var PERMISSION_TIMEOUT_MS = parseInt(process.env.PERMISSION_TIMEOUT_MS || "120000", 10);
+var DECISION_BRIDGE_PATH = process.env.DECISION_BRIDGE_PATH || "";
+var DECISION_BRIDGE_TIMEOUT_MS = parseInt(process.env.DECISION_BRIDGE_TIMEOUT_MS || "3600000", 10);
 var SESSION_OWNER_USERNAME = process.env.SESSION_OWNER_USERNAME || "";
 var SESSION_WORKING_DIR = process.env[OUTBOUND_ENV.SESSION_WORKING_DIR] || "";
 var SESSION_UPLOAD_DIR = process.env[OUTBOUND_ENV.SESSION_UPLOAD_DIR] || "";
@@ -58436,6 +58658,21 @@ async function handlePermissionWith(toolName, toolInput, cfg) {
     mcpLogger.debug(`Skipping standard prompt for ${toolName} (handler enforces its own gate)`);
     return { behavior: "allow", updatedInput: toolInput };
   }
+  const hasMultiSelect = toolName === "AskUserQuestion" && Array.isArray(toolInput.questions) && toolInput.questions.some((q) => q?.multiSelect === true);
+  if ((toolName === "ExitPlanMode" || toolName === "AskUserQuestion") && cfg.decisionBridge && !hasMultiSelect) {
+    const kind = toolName === "ExitPlanMode" ? "plan_approval" : "question";
+    try {
+      const decision = await (cfg.decisionBridge.request ?? requestBridgeDecision)(cfg.decisionBridge.path, { kind, toolName, input: toolInput }, cfg.decisionBridge.timeoutMs);
+      mcpLogger.info(`${toolName} decided via bridge: ${decision.behavior}`);
+      return {
+        behavior: decision.behavior,
+        updatedInput: decision.updatedInput ?? toolInput,
+        message: decision.message
+      };
+    } catch (err) {
+      mcpLogger.warn(`Decision bridge unavailable for ${toolName} (${err}) — legacy fallback`);
+    }
+  }
   if (toolName === "AskUserQuestion") {
     mcpLogger.debug("Auto-allowing AskUserQuestion (question UI is handled by the main bot)");
     return { behavior: "allow", updatedInput: toolInput };
@@ -58522,7 +58759,8 @@ async function handlePermission(toolName, toolInput) {
     getAllowAll: () => allowAllSession,
     setAllowAll: (v) => {
       allowAllSession = v;
-    }
+    },
+    decisionBridge: DECISION_BRIDGE_PATH ? { path: DECISION_BRIDGE_PATH, timeoutMs: DECISION_BRIDGE_TIMEOUT_MS } : undefined
   });
 }
 var permissionInputSchema = {

package/docs/CONFIGURATION.md

@@ -211,6 +211,7 @@ Exactly one of `home` or `apiKey` should be set per account. Persisted sessions
 | `SESSION_TIMEOUT_MS` | Idle timeout in milliseconds. Legacy fallback for `limits.sessionTimeoutMinutes`. | `1800000` (30 min) |
 | `DEBUG` | Enable verbose logging | - |
 | `CLAUDE_PATH` | Path to the `claude` binary. Overrides the PATH lookup and the common install locations. | `claude` (from PATH) |
+| `DECISION_BRIDGE_TIMEOUT_MS` | How long the MCP permission server waits for a plan approval or question answer routed through the decision bridge (the bot's reaction UI) before falling back to the legacy behavior (generic prompt for plans, auto-allow for questions). | `3600000` (1 h) |
 | `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB` | Strip `ANTHROPIC_*`, `AWS_*_TOKEN`, `CLAUDE_CODE_OAUTH_TOKEN`, `GOOGLE_APPLICATION_CREDENTIALS`, and similar from Bash, hook, and stdio-MCP subprocesses Claude spawns. Bot-specific vars like `PLATFORM_TOKEN` pass through. **Also forces permission mode to `default`**; `--dangerously-skip-permissions` will be rejected. Requires Claude CLI 2.1.83+. | - |
 | `CLAUDE_THREADS_SESSIONS_PATH` | Override the path to the persisted sessions file (default `~/.config/claude-threads/sessions.json`). | - |
 | `CLAUDE_THREADS_GITHUB_EMAILS_PATH` | Override the path to the GitHub-emails store used for commit attribution. | - |
@@ -218,15 +219,16 @@ Exactly one of `home` or `apiKey` should be set per account. Persisted sessions
 
 ### Forwarded to Claude CLI automatically
 
-The bot sets two tuning flags on the Claude child process when they aren't
+The bot sets these tuning flags on the Claude child process when they aren't
 already present in the bot's environment:
 
 | Variable | Effect | Requires |
 |----------|--------|----------|
 | `MCP_CONNECTION_NONBLOCKING=true` | Caps `--mcp-config` connects at 5s so a slow MCP server never delays startup | Claude CLI 2.1.89+ |
 | `ENABLE_PROMPT_CACHING_1H=true` | Opts into 1-hour prompt cache TTL, cutting re-caching cost on long-lived threads | Claude CLI 2.1.108+ |
+| `MCP_TOOL_TIMEOUT=3600000` | Only set when the session has a decision bridge. Without it the CLI abandons a pending MCP permission call after ~2 minutes — far too short for plan approvals and question answers that wait on a human reaction. One hour matches the bridge's own `DECISION_BRIDGE_TIMEOUT_MS` default. Verified against CLI 2.1.223. | — |
 
-Export either with a different value in the bot's own env to disable.
+Export any of them with a different value in the bot's own env to override.
 
 ## CLI Options
 

package/docs/MCP-TOOLS.md

@@ -15,7 +15,7 @@ The permission handler the Claude CLI calls before running a tool that needs app
 | `tool_name` | string | Name of the tool requesting permission. |
 | `input` | object | The tool's input parameters, shown to the user in the prompt. |
 
-**Guardrail:** Only reactions from users on the session allowlist count. The bot's own reactions (the option emoji it adds) are ignored. If no reaction arrives within `limits.permissionTimeoutSeconds` (default 120), the request is denied.
+**Guardrail:** Only reactions from users on the session allowlist count. The bot's own reactions (the option emoji it adds) are ignored. If no reaction arrives within `limits.permissionTimeoutSeconds` (default 120), the request is denied. Exception: on modern CLIs, `ExitPlanMode` and `AskUserQuestion` don't post a generic prompt at all — they are forwarded over the session's decision bridge to the bot's plan/question reaction UI and wait up to `DECISION_BRIDGE_TIMEOUT_MS` (default 1 hour) for a decision there. To make that hour real, the bot spawns the CLI with `MCP_TOOL_TIMEOUT=3600000` whenever a bridge is configured — without it the CLI abandons a pending permission call after ~2 minutes (verified against CLI 2.1.223). Multi-select questions and any bridge failure fall back to the legacy behavior: generic prompt for plans, auto-allow for questions.
 
 ## send_file
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "1.21.0",
+  "version": "1.21.2",
   "description": "Run Claude Code from Slack or Mattermost. Sessions stream live into threads where your whole team can watch and steer.",
   "main": "dist/index.js",
   "type": "module",