claude-threads 1.21.1 → 1.22.0

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)
@@ -16965,8 +16965,8 @@ var require_gt3 = __commonJS((exports, module) => {
 // node_modules/package-json/node_modules/semver/functions/lt.js
 var require_lt2 = __commonJS((exports, module) => {
   var compare = require_compare3();
-  var lt = (a, b, loose) => compare(a, b, loose) < 0;
-  module.exports = lt;
+  var lt2 = (a, b, loose) => compare(a, b, loose) < 0;
+  module.exports = lt2;
 });
 
 // node_modules/package-json/node_modules/semver/functions/eq.js
@@ -17003,7 +17003,7 @@ var require_cmp2 = __commonJS((exports, module) => {
   var neq = require_neq2();
   var gt = require_gt3();
   var gte = require_gte2();
-  var lt = require_lt2();
+  var lt2 = require_lt2();
   var lte = require_lte2();
   var cmp = (a, op, b, loose) => {
     switch (op) {
@@ -17034,7 +17034,7 @@ var require_cmp2 = __commonJS((exports, module) => {
       case ">=":
         return gte(a, b, loose);
       case "<":
-        return lt(a, b, loose);
+        return lt2(a, b, loose);
       case "<=":
         return lte(a, b, loose);
       default:
@@ -17755,7 +17755,7 @@ var require_outside2 = __commonJS((exports, module) => {
   var Range = require_range2();
   var satisfies2 = require_satisfies2();
   var gt = require_gt3();
-  var lt = require_lt2();
+  var lt2 = require_lt2();
   var lte = require_lte2();
   var gte = require_gte2();
   var outside = (version, range, hilo, options) => {
@@ -17766,12 +17766,12 @@ var require_outside2 = __commonJS((exports, module) => {
       case ">":
         gtfn = gt;
         ltefn = lte;
-        ltfn = lt;
+        ltfn = lt2;
         comp = ">";
         ecomp = ">=";
         break;
       case "<":
-        gtfn = lt;
+        gtfn = lt2;
         ltefn = gte;
         ltfn = gt;
         comp = "<";
@@ -17937,12 +17937,12 @@ var require_subset2 = __commonJS((exports, module) => {
       }
     }
     const eqSet = new Set;
-    let gt, lt;
+    let gt, lt2;
     for (const c of sub) {
       if (c.operator === ">" || c.operator === ">=") {
         gt = higherGT(gt, c, options);
       } else if (c.operator === "<" || c.operator === "<=") {
-        lt = lowerLT(lt, c, options);
+        lt2 = lowerLT(lt2, c, options);
       } else {
         eqSet.add(c.semver);
       }
@@ -17951,11 +17951,11 @@ var require_subset2 = __commonJS((exports, module) => {
       return null;
     }
     let gtltComp;
-    if (gt && lt) {
-      gtltComp = compare(gt.semver, lt.semver, options);
+    if (gt && lt2) {
+      gtltComp = compare(gt.semver, lt2.semver, options);
       if (gtltComp > 0) {
         return null;
-      } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+      } else if (gtltComp === 0 && (gt.operator !== ">=" || lt2.operator !== "<=")) {
         return null;
       }
     }
@@ -17963,7 +17963,7 @@ var require_subset2 = __commonJS((exports, module) => {
       if (gt && !satisfies2(eq, String(gt), options)) {
         return null;
       }
-      if (lt && !satisfies2(eq, String(lt), options)) {
+      if (lt2 && !satisfies2(eq, String(lt2), options)) {
         return null;
       }
       for (const c of dom) {
@@ -17975,9 +17975,9 @@ var require_subset2 = __commonJS((exports, module) => {
     }
     let higher, lower;
     let hasDomLT, hasDomGT;
-    let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+    let needDomLTPre = lt2 && !options.includePrerelease && lt2.semver.prerelease.length ? lt2.semver : false;
     let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
-    if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+    if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt2.operator === "<" && needDomLTPre.prerelease[0] === 0) {
       needDomLTPre = false;
     }
     for (const c of dom) {
@@ -17998,29 +17998,29 @@ var require_subset2 = __commonJS((exports, module) => {
           return false;
         }
       }
-      if (lt) {
+      if (lt2) {
         if (needDomLTPre) {
           if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
             needDomLTPre = false;
           }
         }
         if (c.operator === "<" || c.operator === "<=") {
-          lower = lowerLT(lt, c, options);
-          if (lower === c && lower !== lt) {
+          lower = lowerLT(lt2, c, options);
+          if (lower === c && lower !== lt2) {
             return false;
           }
-        } else if (lt.operator === "<=" && !satisfies2(lt.semver, String(c), options)) {
+        } else if (lt2.operator === "<=" && !satisfies2(lt2.semver, String(c), options)) {
           return false;
         }
       }
-      if (!c.operator && (lt || gt) && gtltComp !== 0) {
+      if (!c.operator && (lt2 || gt) && gtltComp !== 0) {
         return false;
       }
     }
-    if (gt && hasDomLT && !lt && gtltComp !== 0) {
+    if (gt && hasDomLT && !lt2 && gtltComp !== 0) {
       return false;
     }
-    if (lt && hasDomGT && !gt && gtltComp !== 0) {
+    if (lt2 && hasDomGT && !gt && gtltComp !== 0) {
       return false;
     }
     if (needDomGTPre || needDomLTPre) {
@@ -18067,7 +18067,7 @@ var require_semver5 = __commonJS((exports, module) => {
   var sort = require_sort2();
   var rsort = require_rsort2();
   var gt = require_gt3();
-  var lt = require_lt2();
+  var lt2 = require_lt2();
   var eq = require_eq2();
   var neq = require_neq2();
   var gte = require_gte2();
@@ -18105,7 +18105,7 @@ var require_semver5 = __commonJS((exports, module) => {
     sort,
     rsort,
     gt,
-    lt,
+    lt: lt2,
     eq,
     neq,
     gte,
@@ -51296,6 +51296,7 @@ var dim = (s) => `${colors.dim}${s}${colors.reset}`;
 var bold = (s) => `${colors.bold}${s}${colors.reset}`;
 var green = (s) => `${colors.green}${s}${colors.reset}`;
 var red = (s) => `${colors.red}${s}${colors.reset}`;
+var yellow = (s) => `${colors.yellow}${s}${colors.reset}`;
 
 // src/claude/version-check.ts
 var import_semver = __toESM(require_semver2(), 1);
@@ -51315,7 +51316,10 @@ var COMMON_CLAUDE_PATHS = process.platform === "win32" ? [
   `${process.env.HOME}/.bun/bin/claude`,
   "/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli.js"
 ];
-var CLAUDE_CLI_VERSION_RANGE = ">=2.0.74 <2.2.0";
+var CLAUDE_CLI_MIN_VERSION = "2.0.74";
+var CLAUDE_CLI_VERIFIED_RANGE = ">=2.0.74 <2.2.0";
+var CLAUDE_CLI_SUPPORTED_MAJOR = 2;
+var CLAUDE_CLI_LATEST_VERIFIED = "2.1.223";
 function tryClaudeVersion(claudePath) {
   try {
     const output = execSync(`"${claudePath}" --version`, {
@@ -51387,11 +51391,17 @@ function getClaudeCliVersion() {
     error: `Command 'claude' not found. Searched: ${checkedPaths.slice(0, 3).join(", ")}...`
   };
 }
-function isVersionCompatible(version) {
+function classifyClaudeVersion(version) {
   const semverVersion = import_semver.coerce(version);
   if (!semverVersion)
-    return false;
-  return import_semver.satisfies(semverVersion, CLAUDE_CLI_VERSION_RANGE);
+    return "incompatible";
+  if (import_semver.lt(semverVersion, CLAUDE_CLI_MIN_VERSION))
+    return "incompatible";
+  if (semverVersion.major > CLAUDE_CLI_SUPPORTED_MAJOR)
+    return "incompatible";
+  if (import_semver.satisfies(semverVersion, CLAUDE_CLI_VERIFIED_RANGE))
+    return "ok";
+  return "untested";
 }
 function getClaudePath() {
   if (process.env.CLAUDE_PATH) {
@@ -51419,36 +51429,41 @@ function validateClaudeCli() {
       installed: false,
       version: null,
       compatible: false,
+      status: "incompatible",
       message: `Claude CLI not found at '${claudePath}'. Install it with: npm install -g @anthropic-ai/claude-code`,
       error: result.error
     };
   }
-  if (!result.version && result.rawOutput) {
+  if (!result.version) {
     return {
       installed: true,
       version: null,
       compatible: true,
+      status: "ok",
       message: `Claude CLI found (version unknown)`,
-      rawOutput: result.rawOutput
+      rawOutput: result.rawOutput ?? undefined
     };
   }
-  if (!result.version) {
+  const status = classifyClaudeVersion(result.version);
+  if (status === "incompatible") {
+    const semverVersion = import_semver.coerce(result.version);
+    const reason = semverVersion && semverVersion.major > CLAUDE_CLI_SUPPORTED_MAJOR ? `is a new major version (only ${CLAUDE_CLI_SUPPORTED_MAJOR}.x is supported)` : `is too old (minimum: ${CLAUDE_CLI_MIN_VERSION})`;
     return {
       installed: true,
-      version: null,
-      compatible: true,
-      message: "Claude CLI found (version unknown)",
+      version: result.version,
+      compatible: false,
+      status,
+      message: `Claude CLI version ${result.version} ${reason}. ` + `Install a verified version: npm install -g @anthropic-ai/claude-code@${CLAUDE_CLI_LATEST_VERIFIED}`,
       rawOutput: result.rawOutput ?? undefined
     };
   }
-  const compatible = isVersionCompatible(result.version);
-  if (!compatible) {
+  if (status === "untested") {
     return {
       installed: true,
       version: result.version,
-      compatible: false,
-      message: `Claude CLI version ${result.version} is not compatible. Required: ${CLAUDE_CLI_VERSION_RANGE}
-` + `Install a compatible version: npm install -g @anthropic-ai/claude-code@2.1.223`,
+      compatible: true,
+      status,
+      message: `Claude CLI ${result.version} is newer than the latest verified version (${CLAUDE_CLI_LATEST_VERIFIED}) — untested, continuing anyway. ` + `Features may misbehave; pin a verified version with: npm install -g @anthropic-ai/claude-code@${CLAUDE_CLI_LATEST_VERIFIED}`,
       rawOutput: result.rawOutput ?? undefined
     };
   }
@@ -51456,6 +51471,7 @@ function validateClaudeCli() {
     installed: true,
     version: result.version,
     compatible: true,
+    status,
     message: `Claude CLI ${result.version} ✓`,
     rawOutput: result.rawOutput ?? undefined
   };
@@ -51694,34 +51710,30 @@ async function runOnboarding(reconfigure = false) {
   }
   if (!claudeCheck.compatible) {
     console.log("");
-    if (claudeCheck.version) {
-      console.log(dim(`  ⚠️  Claude Code CLI ${claudeCheck.version} is not compatible`));
-      console.log("");
-      console.log(dim(`  Install a compatible version:`));
-      console.log(dim("    npm install -g @anthropic-ai/claude-code@2.1.223"));
-    } else {
-      console.log(dim("  ⚠️  Claude Code CLI found but version could not be determined"));
-      if (claudeCheck.rawOutput) {
-        console.log(dim(`  Output from "claude --version": ${claudeCheck.rawOutput}`));
-      }
-      console.log("");
-      console.log(dim("  This may work fine - Claude was installed in a non-standard way."));
-    }
+    console.log(dim(`  ⚠️  ${claudeCheck.message}`));
     console.log("");
     const { continueAnyway } = await import_prompts.default({
       type: "confirm",
       name: "continueAnyway",
       message: "Continue anyway? (may not work correctly)",
-      initial: !claudeCheck.version
+      initial: false
     }, { onCancel });
     if (!continueAnyway) {
       console.log("");
       console.log(dim("  Setup cancelled."));
       process.exit(0);
     }
+  } else if (claudeCheck.status === "untested") {
+    console.log("");
+    console.log(dim(`  ⚠️  ${claudeCheck.message}`));
+  } else if (!claudeCheck.version) {
+    console.log(dim("  ⚠️  Claude Code CLI found but version could not be determined"));
+    if (claudeCheck.rawOutput) {
+      console.log(dim(`  Output from "claude --version": ${claudeCheck.rawOutput}`));
+    }
+    console.log(dim("  This may work fine - Claude was installed in a non-standard way."));
   } else {
-    const versionInfo = claudeCheck.version ?? "version unknown";
-    console.log(dim(`  ✓ Claude Code CLI ${versionInfo}`));
+    console.log(dim(`  ✓ Claude Code CLI ${claudeCheck.version}`));
   }
   console.log("");
   console.log(dim("  \uD83D\uDCD6 Need help creating a bot?"));
@@ -53034,7 +53046,11 @@ function formatRelativeTimeShort(date) {
 }
 function formatVersionString() {
   const claudeVersion = getClaudeCliVersion().version;
-  return claudeVersion ? `CT v${VERSION} · CC v${claudeVersion}` : `CT v${VERSION}`;
+  if (!claudeVersion)
+    return `CT v${VERSION}`;
+  const status = classifyClaudeVersion(claudeVersion);
+  const marker = status === "untested" ? " ⚠️ untested" : status === "incompatible" ? " ⚠️ unsupported" : "";
+  return `CT v${VERSION} · CC v${claudeVersion}${marker}`;
 }
 function truncateAtWord(str2, maxLength) {
   if (str2.length <= maxLength)
@@ -55960,7 +55976,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 +55984,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 +56035,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 +56181,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;
@@ -56390,7 +56416,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);
@@ -57243,6 +57271,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 = [
   {
@@ -58183,7 +58314,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
@@ -58549,23 +58680,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}`);
   }
@@ -58591,13 +58722,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,
@@ -58680,12 +58811,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";
 
@@ -62103,8 +62235,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 {
@@ -62684,7 +62816,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}"`;
@@ -66717,6 +66849,8 @@ class MessageManager {
   emitSessionUpdateCallback;
   toolStartTimes = new Map;
   taskTracker = new TaskTracker;
+  pendingBridgePlan = null;
+  pendingBridgeQuestion = null;
   flushTimer = null;
   static DEFAULT_FLUSH_DELAY_MS = 500;
   flushDelayMs;
@@ -67178,9 +67312,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();
@@ -67196,6 +67387,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();
@@ -67976,7 +68168,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);
@@ -68223,7 +68415,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 = {
@@ -68320,7 +68512,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 = {
@@ -69244,6 +69436,7 @@ 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();
   }
@@ -69325,12 +69518,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);
@@ -69393,7 +69592,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 = {
@@ -69910,6 +70109,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) {
@@ -69927,6 +70128,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);
@@ -69952,6 +70155,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({
@@ -69982,10 +70199,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);
   });
@@ -70251,7 +70478,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;
@@ -70305,6 +70532,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,
@@ -70319,9 +70548,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,
@@ -70355,7 +70591,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
@@ -70382,6 +70620,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);
@@ -70465,6 +70705,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,
@@ -70479,9 +70721,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,
@@ -70527,6 +70776,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) {
@@ -70539,6 +70789,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,
@@ -70594,6 +70845,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);
@@ -77177,7 +77430,7 @@ var import_react61 = __toESM(require_react(), 1);
 
 // src/ui/components/Header.tsx
 var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
-function Header({ version, workingDir, claudeVersion }) {
+function Header({ version, workingDir, claudeVersion, claudeStatus }) {
   return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
     borderStyle: "round",
     paddingX: 1,
@@ -77263,7 +77516,15 @@ function Header({ version, workingDir, claudeVersion }) {
               " | Claude ",
               claudeVersion
             ]
-          }, undefined, true, undefined, this)
+          }, undefined, true, undefined, this),
+          claudeStatus === "untested" && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+            color: "yellow",
+            children: " ⚠ untested"
+          }, undefined, false, undefined, this),
+          claudeStatus === "incompatible" && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+            color: "yellow",
+            children: " ⚠ unsupported"
+          }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this)
     ]
@@ -81231,7 +81492,8 @@ function App2({ config, onStateReady, onResizeReady, onQuit, toggleCallbacks })
   const headerContent = /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Header, {
     version: config.version,
     workingDir: config.workingDir,
-    claudeVersion: config.claudeVersion
+    claudeVersion: config.claudeVersion,
+    claudeStatus: config.claudeStatus
   }, undefined, false, undefined, this);
   const footerContent = /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(Footer, {
     ready: state.ready,
@@ -81619,7 +81881,8 @@ class HeadlessProvider {
     const { config } = this.options;
     this.log("HeadlessProvider", `claude-threads v${config.version} starting in headless mode`);
     this.log("HeadlessProvider", `Working directory: ${config.workingDir}`);
-    this.log("HeadlessProvider", `Claude CLI: ${config.claudeVersion}`);
+    const cliMarker = config.claudeStatus === "untested" ? " ⚠️ untested (newer than the verified range)" : config.claudeStatus === "incompatible" ? " ⚠️ unsupported (version check bypassed)" : "";
+    this.log("HeadlessProvider", `Claude CLI: ${config.claudeVersion}${cliMarker}`);
   }
   async stop() {
     this.log("HeadlessProvider", "Stopped");
@@ -82588,7 +82851,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) {
@@ -82614,16 +82877,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;
       }
@@ -83040,6 +83303,15 @@ async function startWithoutDaemon() {
     console.error("");
     process.exit(1);
   }
+  if (claudeValidation.status === "untested") {
+    console.error(yellow(`  ⚠️  ${claudeValidation.message}`));
+    console.error("");
+  }
+  if (!claudeValidation.compatible && opts.skipVersionCheck) {
+    const prefix = claudeValidation.installed ? "running with an unsupported Claude CLI. " : "";
+    console.error(yellow(`  ⚠️  --skip-version-check: ${prefix}${claudeValidation.message}`));
+    console.error("");
+  }
   if (process.env.CLAUDE_CODE_SUBPROCESS_ENV_SCRUB === "1") {
     const hasSkipPermissionPlatform = config.platforms.some((p) => p.skipPermissions === true);
     if (hasSkipPermissionPlatform) {
@@ -83074,7 +83346,7 @@ async function startWithoutDaemon() {
       version: VERSION,
       workingDir,
       claudeVersion: claudeValidation.version || "unknown",
-      claudeCompatible: claudeValidation.compatible,
+      claudeStatus: claudeValidation.status,
       permissionMode: runtimeConfig.permissionMode,
       chromeEnabled: runtimeConfig.chromeEnabled,
       keepAliveEnabled: runtimeConfig.keepAliveEnabled