claude-code-best 1.4.2 → 1.4.3

package/dist/{chunk-aew7yrsf.js → chunk-8czrx8ht.js}

@@ -2,6 +2,9 @@
 import {
   createCapacityWake
 } from "./chunk-ae76ded0.js";
+import {
+  getPollIntervalConfig
+} from "./chunk-5q0pv8vm.js";
 import {
   buildCCRv2SdkUrl,
   buildSdkUrl,
@@ -9,164 +12,103 @@ import {
   registerWorker,
   sameSessionId
 } from "./chunk-2m6jk78c.js";
-import {
-  getPollIntervalConfig
-} from "./chunk-fqfhd27m.js";
 import {
   createTokenRefreshScheduler
-} from "./chunk-qppzesmk.js";
+} from "./chunk-kw1hpgh9.js";
 import {
   getBootstrapArgs,
   getScriptPath,
   init_cliLaunch
 } from "./chunk-w669wpk5.js";
 import {
+  $toString,
   init_server
 } from "./chunk-jdgeec04.js";
 import {
-  BRIDGE_LOGIN_ERROR,
   BridgeFatalError,
-  DEFAULT_SESSION_TIMEOUT_MS,
+  FAILED_FOOTER_TEXT,
+  TOOL_DISPLAY_EXPIRY_MS,
+  buildActiveFooterText,
+  buildBridgeConnectUrl,
+  buildBridgeSessionUrl,
+  buildIdleFooterText,
   createAgentWorktree,
   createBridgeApiClient,
   getRemoteSessionUrl,
   init_bridgeApi,
   init_bridgeStatusUtil,
   init_product,
-  init_types4 as init_types,
   init_worktree,
   isExpiredErrorType,
   isSuppressible403,
   removeAgentWorktree,
-  validateBridgeId
-} from "./chunk-w3h4a3kh.js";
+  timestamp,
+  validateBridgeId,
+  wrapWithOsc8Link
+} from "./chunk-p814dt75.js";
 import {
   init_rcDebugLog,
   rcLog
-} from "./chunk-k7aebzb7.js";
-import"./chunk-x5k1etjx.js";
-import"./chunk-qe3qr56q.js";
+} from "./chunk-rmb338tt.js";
 import {
   getTrustedDeviceToken,
   init_trustedDevice
-} from "./chunk-98z3psrf.js";
-import"./chunk-et824jj8.js";
-import"./chunk-c7vjkt02.js";
-import"./chunk-var1et7e.js";
-import"./chunk-vrpq3d3m.js";
-import"./chunk-2gzv8nrw.js";
-import"./chunk-ehtwnxpg.js";
-import"./chunk-wf0tb0v2.js";
-import"./chunk-ytrefhw5.js";
-import"./chunk-cgfdkzhb.js";
-import"./chunk-2f6hs25r.js";
-import"./chunk-dpzdk73b.js";
-import"./chunk-6qj1adtm.js";
-import"./chunk-d6v6abvy.js";
-import"./chunk-d127m8zb.js";
-import"./chunk-zttmdag3.js";
-import"./chunk-8zdrx5jf.js";
-import"./chunk-p5816r2t.js";
-import"./chunk-ps49ymvj.js";
+} from "./chunk-1nkqjw8f.js";
+import {
+  BRIDGE_LOGIN_ERROR,
+  DEFAULT_SESSION_TIMEOUT_MS,
+  init_types
+} from "./chunk-bhdt6k7w.js";
 import {
   debugTruncate,
   describeAxiosError,
   init_debugUtils,
   init_sessionIdCompat,
-  toCompatSessionId
-} from "./chunk-chzfw06n.js";
-import"./chunk-rd2884ff.js";
-import"./chunk-t4kcvmes.js";
-import"./chunk-padnh4m8.js";
-import"./chunk-41qawevz.js";
-import"./chunk-cy1z66c2.js";
-import"./chunk-v134wa9t.js";
-import"./chunk-3twcp74a.js";
-import"./chunk-4jm600zv.js";
-import"./chunk-5t6qedbx.js";
-import"./chunk-3xzcr9ha.js";
-import"./chunk-rkmwx1yz.js";
-import"./chunk-k523rbgc.js";
-import"./chunk-ykr5qx9v.js";
-import"./chunk-d6pvxq4t.js";
-import"./chunk-nt2esar1.js";
+  toCompatSessionId,
+  toInfraSessionId
+} from "./chunk-0cshr8vt.js";
 import {
-  init_datadog
-} from "./chunk-5smyhzmn.js";
-import"./chunk-8cb8dhn1.js";
-import"./chunk-ad6rg8vz.js";
-import"./chunk-x95fhbwq.js";
+  init_datadog,
+  shutdownDatadog
+} from "./chunk-k3p4x944.js";
 import {
-  getClaudeAIOAuthTokens,
-  init_auth,
+  BRIDGE_FAILED_INDICATOR,
+  BRIDGE_READY_INDICATOR,
+  BRIDGE_SPINNER_FRAMES,
+  checkGate_CACHED_OR_BLOCKING,
   init_figures,
   init_firstPartyEventLogger,
-  init_growthbook
-} from "./chunk-pp51xf04.js";
-import"./chunk-h3p151fx.js";
-import"./chunk-0spb0sqd.js";
-import"./chunk-zwarn9h7.js";
-import"./chunk-hxc8e6wd.js";
-import"./chunk-7hmy36fh.js";
-import"./chunk-6kpbgc5w.js";
-import"./chunk-xpsb3jm8.js";
-import"./chunk-64c1avct.js";
-import"./chunk-pjz4m7pd.js";
+  init_growthbook,
+  shutdown1PEventLogging
+} from "./chunk-ch7hgejq.js";
 import {
   init_sleep,
   sleep
 } from "./chunk-8g5pe1gr.js";
-import"./chunk-zvdc0eh1.js";
-import"./chunk-4cp6193g.js";
-import"./chunk-8g747a8x.js";
-import"./chunk-d7886r6a.js";
-import"./chunk-90wp6wez.js";
-import"./chunk-a8ejc632.js";
-import"./chunk-f5ma3nh5.js";
-import"./chunk-qz2x630m.js";
-import"./chunk-c7t69jmn.js";
-import"./chunk-6y2wszkc.js";
-import"./chunk-3c25bcsw.js";
-import"./chunk-9qh5f9r3.js";
-import"./chunk-xhesahm0.js";
-import"./chunk-rh5a2rg9.js";
-import"./chunk-p2816w9z.js";
-import"./chunk-v9smspw2.js";
-import"./chunk-v1kzp02e.js";
 import {
   formatDuration,
   init_format,
   truncateToWidth
-} from "./chunk-axenqvc8.js";
-import"./chunk-crmjpsqe.js";
+} from "./chunk-ea7t0b92.js";
 import {
-  init_src
+  init_source,
+  init_src,
+  source_default,
+  stringWidth
 } from "./chunk-m9w972ny.js";
-import"./chunk-b5wxetbv.js";
 import {
   init_analytics,
-  logEvent
-} from "./chunk-h0rbjg6x.js";
-import"./chunk-0vkfrmqm.js";
-import"./chunk-0xjaqda8.js";
-import"./chunk-trt2sfjg.js";
+  logEvent,
+  logEventAsync
+} from "./chunk-f2mhrmww.js";
 import {
   init_diagLogs,
   logForDiagnosticsNoPII
 } from "./chunk-73pxnrgv.js";
-import"./chunk-5aw4k8fc.js";
-import"./chunk-zs5b1dgr.js";
-import"./chunk-99zt59gg.js";
-import"./chunk-tv74hgw9.js";
 import {
   init_log,
   logError
 } from "./chunk-vp2p7azg.js";
-import"./chunk-8tnsngw2.js";
-import"./chunk-vsbyhpfy.js";
-import"./chunk-p7pj6wf8.js";
-import"./chunk-5z28bqne.js";
-import"./chunk-qajrkk97.js";
 import {
   errorMessage,
   init_debug,
@@ -176,28 +118,15 @@ import {
   jsonStringify,
   logForDebugging
 } from "./chunk-5khwvj1z.js";
-import"./chunk-fbv4apne.js";
-import"./chunk-gzp6rza1.js";
-import"./chunk-50dgek10.js";
-import"./chunk-7wm5s02e.js";
-import"./chunk-z0csm2zq.js";
 import {
   init_envUtils,
   isEnvTruthy,
   isInProtectedNamespace
 } from "./chunk-hxhwzgnn.js";
-import"./chunk-qx8z601m.js";
-import"./chunk-cgm6758j.js";
-import"./chunk-9m27g5s1.js";
-import"./chunk-8pn8tvgg.js";
-import"./chunk-netzwgv1.js";
 import {
   __require
 } from "./chunk-qp2qdcda.js";
 
-// src/daemon/workerRegistry.ts
-import { resolve as resolve2 } from "path";
-
 // src/bridge/bridgeMain.ts
 init_product();
 init_datadog();
@@ -221,11 +150,366 @@ import { hostname, tmpdir as tmpdir2 } from "os";
 import { basename, join as join2, resolve } from "path";
 
 // src/bridge/bridgeUI.ts
+init_source();
 init_server();
 init_figures();
 init_src();
 init_debug();
 init_bridgeStatusUtil();
+var QR_OPTIONS = {
+  type: "utf8",
+  errorCorrectionLevel: "L",
+  small: true
+};
+async function generateQr(url) {
+  const qr = await $toString(url, QR_OPTIONS);
+  return qr.split(`
+`).filter((line) => line.length > 0);
+}
+function createBridgeLogger(options) {
+  const write = options.write ?? ((s) => process.stdout.write(s));
+  const verbose = options.verbose;
+  let statusLineCount = 0;
+  let currentState = "idle";
+  let currentStateText = "Ready";
+  let repoName = "";
+  let branch = "";
+  let debugLogPath = "";
+  let connectUrl = "";
+  let cachedIngressUrl = "";
+  let cachedEnvironmentId = "";
+  let activeSessionUrl = null;
+  let qrLines = [];
+  let qrVisible = false;
+  let lastToolSummary = null;
+  let lastToolTime = 0;
+  let sessionActive = 0;
+  let sessionMax = 1;
+  let spawnModeDisplay = null;
+  let spawnMode = "single-session";
+  const sessionDisplayInfo = new Map;
+  let connectingTimer = null;
+  let connectingTick = 0;
+  function countVisualLines(text) {
+    const cols = process.stdout.columns || 80;
+    let count = 0;
+    for (const logical of text.split(`
+`)) {
+      if (logical.length === 0) {
+        count++;
+        continue;
+      }
+      const width = stringWidth(logical);
+      count += Math.max(1, Math.ceil(width / cols));
+    }
+    if (text.endsWith(`
+`)) {
+      count--;
+    }
+    return count;
+  }
+  function writeStatus(text) {
+    write(text);
+    statusLineCount += countVisualLines(text);
+  }
+  function clearStatusLines() {
+    if (statusLineCount <= 0)
+      return;
+    logForDebugging(`[bridge:ui] clearStatusLines count=${statusLineCount}`);
+    write(`\x1B[${statusLineCount}A`);
+    write("\x1B[J");
+    statusLineCount = 0;
+  }
+  function printLog(line) {
+    clearStatusLines();
+    write(line);
+  }
+  function regenerateQr(url) {
+    generateQr(url).then((lines) => {
+      qrLines = lines;
+      renderStatusLine();
+    }).catch((e) => {
+      logForDebugging(`QR code generation failed: ${e}`, { level: "error" });
+    });
+  }
+  function renderConnectingLine() {
+    clearStatusLines();
+    const frame = BRIDGE_SPINNER_FRAMES[connectingTick % BRIDGE_SPINNER_FRAMES.length];
+    let suffix = "";
+    if (repoName) {
+      suffix += source_default.dim(" \xB7 ") + source_default.dim(repoName);
+    }
+    if (branch) {
+      suffix += source_default.dim(" \xB7 ") + source_default.dim(branch);
+    }
+    writeStatus(`${source_default.yellow(frame)} ${source_default.yellow("Connecting")}${suffix}
+`);
+  }
+  function startConnecting() {
+    stopConnecting();
+    renderConnectingLine();
+    connectingTimer = setInterval(() => {
+      connectingTick++;
+      renderConnectingLine();
+    }, 150);
+  }
+  function stopConnecting() {
+    if (connectingTimer) {
+      clearInterval(connectingTimer);
+      connectingTimer = null;
+    }
+  }
+  function renderStatusLine() {
+    if (currentState === "reconnecting" || currentState === "failed") {
+      return;
+    }
+    clearStatusLines();
+    const isIdle = currentState === "idle";
+    if (qrVisible) {
+      for (const line of qrLines) {
+        writeStatus(`${source_default.dim(line)}
+`);
+      }
+    }
+    const indicator = BRIDGE_READY_INDICATOR;
+    const indicatorColor = isIdle ? source_default.green : source_default.cyan;
+    const baseColor = isIdle ? source_default.green : source_default.cyan;
+    const stateText = baseColor(currentStateText);
+    let suffix = "";
+    if (repoName) {
+      suffix += source_default.dim(" \xB7 ") + source_default.dim(repoName);
+    }
+    if (branch && spawnMode !== "worktree") {
+      suffix += source_default.dim(" \xB7 ") + source_default.dim(branch);
+    }
+    if (process.env.USER_TYPE === "ant" && debugLogPath) {
+      writeStatus(`${source_default.yellow("[ANT-ONLY] Logs:")} ${source_default.dim(debugLogPath)}
+`);
+    }
+    writeStatus(`${indicatorColor(indicator)} ${stateText}${suffix}
+`);
+    if (sessionMax > 1) {
+      const modeHint = spawnMode === "worktree" ? "New sessions will be created in an isolated worktree" : "New sessions will be created in the current directory";
+      writeStatus(`    ${source_default.dim(`Capacity: ${sessionActive}/${sessionMax} \xB7 ${modeHint}`)}
+`);
+      for (const [, info] of sessionDisplayInfo) {
+        const titleText = info.title ? truncateToWidth(info.title, 35) : source_default.dim("Attached");
+        const titleLinked = wrapWithOsc8Link(titleText, info.url);
+        const act = info.activity;
+        const showAct = act && act.type !== "result" && act.type !== "error";
+        const actText = showAct ? source_default.dim(` ${truncateToWidth(act.summary, 40)}`) : "";
+        writeStatus(`    ${titleLinked}${actText}
+`);
+      }
+    }
+    if (sessionMax === 1) {
+      const modeText = spawnMode === "single-session" ? "Single session \xB7 exits when complete" : spawnMode === "worktree" ? `Capacity: ${sessionActive}/1 \xB7 New sessions will be created in an isolated worktree` : `Capacity: ${sessionActive}/1 \xB7 New sessions will be created in the current directory`;
+      writeStatus(`    ${source_default.dim(modeText)}
+`);
+    }
+    if (sessionMax === 1 && !isIdle && lastToolSummary && Date.now() - lastToolTime < TOOL_DISPLAY_EXPIRY_MS) {
+      writeStatus(`  ${source_default.dim(truncateToWidth(lastToolSummary, 60))}
+`);
+    }
+    const url = activeSessionUrl ?? connectUrl;
+    if (url) {
+      writeStatus(`
+`);
+      const footerText = isIdle ? buildIdleFooterText(url) : buildActiveFooterText(url);
+      const qrHint = qrVisible ? source_default.dim.italic("space to hide QR code") : source_default.dim.italic("space to show QR code");
+      const toggleHint = spawnModeDisplay ? source_default.dim.italic(" \xB7 w to toggle spawn mode") : "";
+      writeStatus(`${source_default.dim(footerText)}
+`);
+      writeStatus(`${qrHint}${toggleHint}
+`);
+    }
+  }
+  return {
+    printBanner(config, environmentId) {
+      cachedIngressUrl = config.sessionIngressUrl;
+      cachedEnvironmentId = environmentId;
+      connectUrl = buildBridgeConnectUrl(environmentId, cachedIngressUrl);
+      regenerateQr(connectUrl);
+      if (verbose) {
+        write(source_default.dim(`Remote Control`) + ` v${"2.1.888"}
+`);
+      }
+      if (verbose) {
+        if (config.spawnMode !== "single-session") {
+          write(source_default.dim(`Spawn mode: `) + `${config.spawnMode}
+`);
+          write(source_default.dim(`Max concurrent sessions: `) + `${config.maxSessions}
+`);
+        }
+        write(source_default.dim(`Environment ID: `) + `${environmentId}
+`);
+      }
+      if (config.sandbox) {
+        write(source_default.dim(`Sandbox: `) + `${source_default.green("Enabled")}
+`);
+      }
+      write(`
+`);
+      startConnecting();
+    },
+    logSessionStart(sessionId, prompt) {
+      if (verbose) {
+        const short = truncateToWidth(prompt, 80);
+        printLog(source_default.dim(`[${timestamp()}]`) + ` Session started: ${source_default.white(`"${short}"`)} (${source_default.dim(sessionId)})
+`);
+      }
+    },
+    logSessionComplete(sessionId, durationMs) {
+      printLog(source_default.dim(`[${timestamp()}]`) + ` Session ${source_default.green("completed")} (${formatDuration(durationMs)}) ${source_default.dim(sessionId)}
+`);
+    },
+    logSessionFailed(sessionId, error) {
+      printLog(source_default.dim(`[${timestamp()}]`) + ` Session ${source_default.red("failed")}: ${error} ${source_default.dim(sessionId)}
+`);
+    },
+    logStatus(message) {
+      printLog(source_default.dim(`[${timestamp()}]`) + ` ${message}
+`);
+    },
+    logVerbose(message) {
+      if (verbose) {
+        printLog(source_default.dim(`[${timestamp()}] ${message}`) + `
+`);
+      }
+    },
+    logError(message) {
+      printLog(source_default.red(`[${timestamp()}] Error: ${message}`) + `
+`);
+    },
+    logReconnected(disconnectedMs) {
+      printLog(source_default.dim(`[${timestamp()}]`) + ` ${source_default.green("Reconnected")} after ${formatDuration(disconnectedMs)}
+`);
+    },
+    setRepoInfo(repo, branchName) {
+      repoName = repo;
+      branch = branchName;
+    },
+    setDebugLogPath(path) {
+      debugLogPath = path;
+    },
+    updateIdleStatus() {
+      stopConnecting();
+      currentState = "idle";
+      currentStateText = "Ready";
+      lastToolSummary = null;
+      lastToolTime = 0;
+      activeSessionUrl = null;
+      regenerateQr(connectUrl);
+      renderStatusLine();
+    },
+    setAttached(sessionId) {
+      stopConnecting();
+      currentState = "attached";
+      currentStateText = "Connected";
+      lastToolSummary = null;
+      lastToolTime = 0;
+      if (sessionMax <= 1) {
+        activeSessionUrl = buildBridgeSessionUrl(sessionId, cachedEnvironmentId, cachedIngressUrl);
+        regenerateQr(activeSessionUrl);
+      }
+      renderStatusLine();
+    },
+    updateReconnectingStatus(delayStr, elapsedStr) {
+      stopConnecting();
+      clearStatusLines();
+      currentState = "reconnecting";
+      if (qrVisible) {
+        for (const line of qrLines) {
+          writeStatus(`${source_default.dim(line)}
+`);
+        }
+      }
+      const frame = BRIDGE_SPINNER_FRAMES[connectingTick % BRIDGE_SPINNER_FRAMES.length];
+      connectingTick++;
+      writeStatus(`${source_default.yellow(frame)} ${source_default.yellow("Reconnecting")} ${source_default.dim("\xB7")} ${source_default.dim(`retrying in ${delayStr}`)} ${source_default.dim("\xB7")} ${source_default.dim(`disconnected ${elapsedStr}`)}
+`);
+    },
+    updateFailedStatus(error) {
+      stopConnecting();
+      clearStatusLines();
+      currentState = "failed";
+      let suffix = "";
+      if (repoName) {
+        suffix += source_default.dim(" \xB7 ") + source_default.dim(repoName);
+      }
+      if (branch) {
+        suffix += source_default.dim(" \xB7 ") + source_default.dim(branch);
+      }
+      writeStatus(`${source_default.red(BRIDGE_FAILED_INDICATOR)} ${source_default.red("Remote Control Failed")}${suffix}
+`);
+      writeStatus(`${source_default.dim(FAILED_FOOTER_TEXT)}
+`);
+      if (error) {
+        writeStatus(`${source_default.red(error)}
+`);
+      }
+    },
+    updateSessionStatus(_sessionId, _elapsed, activity, _trail) {
+      if (activity.type === "tool_start") {
+        lastToolSummary = activity.summary;
+        lastToolTime = Date.now();
+      }
+      renderStatusLine();
+    },
+    clearStatus() {
+      stopConnecting();
+      clearStatusLines();
+    },
+    toggleQr() {
+      qrVisible = !qrVisible;
+      renderStatusLine();
+    },
+    updateSessionCount(active, max, mode) {
+      if (sessionActive === active && sessionMax === max && spawnMode === mode)
+        return;
+      sessionActive = active;
+      sessionMax = max;
+      spawnMode = mode;
+    },
+    setSpawnModeDisplay(mode) {
+      if (spawnModeDisplay === mode)
+        return;
+      spawnModeDisplay = mode;
+      if (mode)
+        spawnMode = mode;
+    },
+    addSession(sessionId, url) {
+      sessionDisplayInfo.set(sessionId, { url });
+    },
+    updateSessionActivity(sessionId, activity) {
+      const info = sessionDisplayInfo.get(sessionId);
+      if (!info)
+        return;
+      info.activity = activity;
+    },
+    setSessionTitle(sessionId, title) {
+      const info = sessionDisplayInfo.get(sessionId);
+      if (!info)
+        return;
+      info.title = title;
+      if (currentState === "reconnecting" || currentState === "failed")
+        return;
+      if (sessionMax === 1) {
+        currentState = "titled";
+        currentStateText = truncateToWidth(title, 40);
+      }
+      renderStatusLine();
+    },
+    removeSession(sessionId) {
+      sessionDisplayInfo.delete(sessionId);
+    },
+    refreshDisplay() {
+      if (currentState === "reconnecting" || currentState === "failed")
+        return;
+      renderStatusLine();
+    }
+  };
+}
 
 // src/bridge/bridgeMain.ts
 init_debugUtils();
@@ -592,6 +876,10 @@ var DEFAULT_BACKOFF = {
   generalGiveUpMs: 600000
 };
 var STATUS_UPDATE_INTERVAL_MS = 1000;
+var SPAWN_SESSIONS_DEFAULT = 32;
+async function isMultiSessionSpawnEnabled() {
+  return checkGate_CACHED_OR_BLOCKING("tengu_ccr_bridge_multi_session");
+}
 function pollSleepDetectionThresholdMs(backoff) {
   return backoff.connCapMs * 2;
 }
@@ -1067,7 +1355,7 @@ async function runBridgeLoop(config, environmentId, environmentSecret, api, spaw
               const title = deriveSessionTitle(text);
               logger.setSessionTitle(compatSessionId, title);
               logForDebugging(`[bridge:title] derived title for ${compatSessionId}: ${title}`);
-              import("./chunk-cbew0pjr.js").then(({ updateBridgeSessionTitle }) => updateBridgeSessionTitle(compatSessionId, title, {
+              import("./chunk-01pfrqr8.js").then(({ updateBridgeSessionTitle }) => updateBridgeSessionTitle(compatSessionId, title, {
                 baseUrl: config.apiBaseUrl
               })).catch((err) => logForDebugging(`[bridge:title] failed to update title for ${compatSessionId}: ${err}`, { level: "error" }));
             }
@@ -1401,16 +1689,651 @@ function onSessionTimeout(sessionId, timeoutMs, logger, timedOutSessions, handle
   timedOutSessions.add(sessionId);
   handle.kill();
 }
+var SPAWN_FLAG_VALUES = ["session", "same-dir", "worktree"];
+function parseSpawnValue(raw) {
+  if (raw === "session")
+    return "single-session";
+  if (raw === "same-dir")
+    return "same-dir";
+  if (raw === "worktree")
+    return "worktree";
+  return `--spawn requires one of: ${SPAWN_FLAG_VALUES.join(", ")} (got: ${raw ?? "<missing>"})`;
+}
+function parseCapacityValue(raw) {
+  const n = raw === undefined ? NaN : parseInt(raw, 10);
+  if (isNaN(n) || n < 1) {
+    return `--capacity requires a positive integer (got: ${raw ?? "<missing>"})`;
+  }
+  return n;
+}
+function parseArgs(args) {
+  let verbose = false;
+  let sandbox = false;
+  let debugFile;
+  let sessionTimeoutMs;
+  let permissionMode;
+  let name;
+  let help = false;
+  let spawnMode;
+  let capacity;
+  let createSessionInDir;
+  let sessionId;
+  let continueSession = false;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      help = true;
+    } else if (arg === "--verbose" || arg === "-v") {
+      verbose = true;
+    } else if (arg === "--sandbox") {
+      sandbox = true;
+    } else if (arg === "--no-sandbox") {
+      sandbox = false;
+    } else if (arg === "--debug-file" && i + 1 < args.length) {
+      debugFile = resolve(args[++i]);
+    } else if (arg.startsWith("--debug-file=")) {
+      debugFile = resolve(arg.slice("--debug-file=".length));
+    } else if (arg === "--session-timeout" && i + 1 < args.length) {
+      sessionTimeoutMs = parseInt(args[++i], 10) * 1000;
+    } else if (arg.startsWith("--session-timeout=")) {
+      sessionTimeoutMs = parseInt(arg.slice("--session-timeout=".length), 10) * 1000;
+    } else if (arg === "--permission-mode" && i + 1 < args.length) {
+      permissionMode = args[++i];
+    } else if (arg.startsWith("--permission-mode=")) {
+      permissionMode = arg.slice("--permission-mode=".length);
+    } else if (arg === "--name" && i + 1 < args.length) {
+      name = args[++i];
+    } else if (arg.startsWith("--name=")) {
+      name = arg.slice("--name=".length);
+    } else if (arg === "--session-id" && i + 1 < args.length) {
+      sessionId = args[++i];
+      if (!sessionId) {
+        return makeError("--session-id requires a value");
+      }
+    } else if (arg.startsWith("--session-id=")) {
+      sessionId = arg.slice("--session-id=".length);
+      if (!sessionId) {
+        return makeError("--session-id requires a value");
+      }
+    } else if (arg === "--continue" || arg === "-c") {
+      continueSession = true;
+    } else if (arg === "--spawn" || arg.startsWith("--spawn=")) {
+      if (spawnMode !== undefined) {
+        return makeError("--spawn may only be specified once");
+      }
+      const raw = arg.startsWith("--spawn=") ? arg.slice("--spawn=".length) : args[++i];
+      const v = parseSpawnValue(raw);
+      if (v === "single-session" || v === "same-dir" || v === "worktree") {
+        spawnMode = v;
+      } else {
+        return makeError(v);
+      }
+    } else if (arg === "--capacity" || arg.startsWith("--capacity=")) {
+      if (capacity !== undefined) {
+        return makeError("--capacity may only be specified once");
+      }
+      const raw = arg.startsWith("--capacity=") ? arg.slice("--capacity=".length) : args[++i];
+      const v = parseCapacityValue(raw);
+      if (typeof v === "number")
+        capacity = v;
+      else
+        return makeError(v);
+    } else if (arg === "--create-session-in-dir") {
+      createSessionInDir = true;
+    } else if (arg === "--no-create-session-in-dir") {
+      createSessionInDir = false;
+    } else {
+      return makeError(`Unknown argument: ${arg}
+Run 'claude remote-control --help' for usage.`);
+    }
+  }
+  if (spawnMode === "single-session" && capacity !== undefined) {
+    return makeError(`--capacity cannot be used with --spawn=session (single-session mode has fixed capacity 1).`);
+  }
+  if ((sessionId || continueSession) && (spawnMode !== undefined || capacity !== undefined || createSessionInDir !== undefined)) {
+    return makeError(`--session-id and --continue cannot be used with --spawn, --capacity, or --create-session-in-dir.`);
+  }
+  if (sessionId && continueSession) {
+    return makeError(`--session-id and --continue cannot be used together.`);
+  }
+  return {
+    verbose,
+    sandbox,
+    debugFile,
+    sessionTimeoutMs,
+    permissionMode,
+    name,
+    spawnMode,
+    capacity,
+    createSessionInDir,
+    sessionId,
+    continueSession,
+    help
+  };
+  function makeError(error) {
+    return {
+      verbose,
+      sandbox,
+      debugFile,
+      sessionTimeoutMs,
+      permissionMode,
+      name,
+      spawnMode,
+      capacity,
+      createSessionInDir,
+      sessionId,
+      continueSession,
+      help,
+      error
+    };
+  }
+}
+async function printHelp() {
+  const { EXTERNAL_PERMISSION_MODES } = await import("./chunk-g1k68z1b.js");
+  const modes = EXTERNAL_PERMISSION_MODES.join(", ");
+  const showServer = await isMultiSessionSpawnEnabled();
+  const serverOptions = showServer ? `  --spawn <mode>                   Spawn mode: same-dir, worktree, session
+                                   (default: same-dir)
+  --capacity <N>                   Max concurrent sessions in worktree or
+                                   same-dir mode (default: ${SPAWN_SESSIONS_DEFAULT})
+  --[no-]create-session-in-dir     Pre-create a session in the current
+                                   directory; in worktree mode this session
+                                   stays in cwd while on-demand sessions get
+                                   isolated worktrees (default: on)
+` : "";
+  const serverDescription = showServer ? `
+  Remote Control runs as a persistent server that accepts multiple concurrent
+  sessions in the current directory. One session is pre-created on start so
+  you have somewhere to type immediately. Use --spawn=worktree to isolate
+  each on-demand session in its own git worktree, or --spawn=session for
+  the classic single-session mode (exits when that session ends). Press 'w'
+  during runtime to toggle between same-dir and worktree.
+` : "";
+  const serverNote = showServer ? `  - Worktree mode requires a git repository or WorktreeCreate/WorktreeRemove hooks
+` : "";
+  const help = `
+Remote Control - Connect your local environment to claude.ai/code
+
+USAGE
+  claude remote-control [options]
+OPTIONS
+  --name <name>                    Name for the session (shown in claude.ai/code)
+  -c, --continue                   Resume the last session in this directory
+  --session-id <id>                Resume a specific session by ID (cannot be
+                                   used with spawn flags or --continue)
+  --permission-mode <mode>         Permission mode for spawned sessions
+                                   (${modes})
+  --debug-file <path>              Write debug logs to file
+  -v, --verbose                    Enable verbose output
+  -h, --help                       Show this help
+${serverOptions}
+DESCRIPTION
+  Remote Control allows you to control sessions on your local device from
+  claude.ai/code (https://claude.ai/code). Run this command in the
+  directory you want to work in, then connect from the Claude app or web.
+${serverDescription}
+NOTES
+  - You must be logged in with a Claude account that has a subscription
+  - Run \`claude\` first in the directory to accept the workspace trust dialog
+${serverNote}`;
+  console.log(help);
+}
 var TITLE_MAX_LEN = 80;
 function deriveSessionTitle(text) {
   const flat = text.replace(/\s+/g, " ").trim();
   return truncateToWidth(flat, TITLE_MAX_LEN);
 }
 async function fetchSessionTitle(compatSessionId, baseUrl) {
-  const { getBridgeSession } = await import("./chunk-cbew0pjr.js");
+  const { getBridgeSession } = await import("./chunk-01pfrqr8.js");
   const session = await getBridgeSession(compatSessionId, { baseUrl });
   return session?.title || undefined;
 }
+async function bridgeMain(args) {
+  const parsed = parseArgs(args);
+  if (parsed.help) {
+    await printHelp();
+    return;
+  }
+  if (parsed.error) {
+    console.error(`Error: ${parsed.error}`);
+    process.exit(1);
+  }
+  const {
+    verbose,
+    sandbox,
+    debugFile,
+    sessionTimeoutMs,
+    permissionMode,
+    name,
+    spawnMode: parsedSpawnMode,
+    capacity: parsedCapacity,
+    createSessionInDir: parsedCreateSessionInDir,
+    sessionId: parsedSessionId,
+    continueSession
+  } = parsed;
+  let resumeSessionId = parsedSessionId;
+  let resumePointerDir;
+  const usedMultiSessionFeature = parsedSpawnMode !== undefined || parsedCapacity !== undefined || parsedCreateSessionInDir !== undefined;
+  if (permissionMode !== undefined) {
+    const { PERMISSION_MODES } = await import("./chunk-g1k68z1b.js");
+    const valid = PERMISSION_MODES;
+    if (!valid.includes(permissionMode)) {
+      console.error(`Error: Invalid permission mode '${permissionMode}'. Valid modes: ${valid.join(", ")}`);
+      process.exit(1);
+    }
+  }
+  const dir = resolve(".");
+  const { enableConfigs, checkHasTrustDialogAccepted } = await import("./chunk-cbssxph9.js");
+  enableConfigs();
+  const { initSinks } = await import("./chunk-sfmxv59p.js");
+  initSinks();
+  const multiSessionEnabled = await isMultiSessionSpawnEnabled();
+  if (usedMultiSessionFeature && !multiSessionEnabled) {
+    await logEventAsync("tengu_bridge_multi_session_denied", {
+      used_spawn: parsedSpawnMode !== undefined,
+      used_capacity: parsedCapacity !== undefined,
+      used_create_session_in_dir: parsedCreateSessionInDir !== undefined
+    });
+    await Promise.race([
+      Promise.all([shutdown1PEventLogging(), shutdownDatadog()]),
+      sleep(500, undefined, { unref: true })
+    ]).catch(() => {});
+    console.error("Error: Multi-session Remote Control is not enabled for your account yet.");
+    process.exit(1);
+  }
+  const { setOriginalCwd, setCwdState } = await import("./chunk-m1tjr9xq.js");
+  setOriginalCwd(dir);
+  setCwdState(dir);
+  if (!checkHasTrustDialogAccepted()) {
+    console.error(`Error: Workspace not trusted. Please run \`claude\` in ${dir} first to review and accept the workspace trust dialog.`);
+    process.exit(1);
+  }
+  const { clearOAuthTokenCache, checkAndRefreshOAuthTokenIfNeeded } = await import("./chunk-w0hw971e.js");
+  const { getBridgeAccessToken, getBridgeBaseUrl } = await import("./chunk-bec4mkst.js");
+  const bridgeToken = getBridgeAccessToken();
+  if (!bridgeToken) {
+    console.error(BRIDGE_LOGIN_ERROR);
+    process.exit(1);
+  }
+  const {
+    getGlobalConfig,
+    saveGlobalConfig,
+    getCurrentProjectConfig,
+    saveCurrentProjectConfig
+  } = await import("./chunk-cbssxph9.js");
+  if (!getGlobalConfig().remoteDialogSeen) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    console.log(`
+Remote Control lets you access this CLI session from the web (claude.ai/code)
+or the Claude app, so you can pick up where you left off on any device.
+
+You can disconnect remote access anytime by running /remote-control again.
+`);
+    const answer = await new Promise((resolve2) => {
+      rl.question("Enable Remote Control? (y/n) ", resolve2);
+    });
+    rl.close();
+    saveGlobalConfig((current) => {
+      if (current.remoteDialogSeen)
+        return current;
+      return { ...current, remoteDialogSeen: true };
+    });
+    if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+      process.exit(0);
+    }
+  }
+  if (continueSession) {
+    const { readBridgePointerAcrossWorktrees } = await import("./chunk-fxpsa506.js");
+    const found = await readBridgePointerAcrossWorktrees(dir);
+    if (!found) {
+      console.error(`Error: No recent session found in this directory or its worktrees. Run \`claude remote-control\` to start a new one.`);
+      process.exit(1);
+    }
+    const { pointer, dir: pointerDir } = found;
+    const ageMin = Math.round(pointer.ageMs / 60000);
+    const ageStr = ageMin < 60 ? `${ageMin}m` : `${Math.round(ageMin / 60)}h`;
+    const fromWt = pointerDir !== dir ? ` from worktree ${pointerDir}` : "";
+    console.error(`Resuming session ${pointer.sessionId} (${ageStr} ago)${fromWt}\u2026`);
+    resumeSessionId = pointer.sessionId;
+    resumePointerDir = pointerDir;
+  }
+  const baseUrl = getBridgeBaseUrl();
+  if (baseUrl.startsWith("http://") && !baseUrl.includes("localhost") && !baseUrl.includes("127.0.0.1")) {
+    console.error("Error: Remote Control base URL uses HTTP. Only HTTPS or localhost HTTP is allowed.");
+    process.exit(1);
+  }
+  const sessionIngressUrl = process.env.CLAUDE_BRIDGE_SESSION_INGRESS_URL || baseUrl;
+  const { getBranch, getRemoteUrl, findGitRoot } = await import("./chunk-dy8tttdp.js");
+  const { hasWorktreeCreateHook } = await import("./chunk-6kwx0aa4.js");
+  const worktreeAvailable = hasWorktreeCreateHook() || findGitRoot(dir) !== null;
+  let savedSpawnMode = multiSessionEnabled ? getCurrentProjectConfig().remoteControlSpawnMode : undefined;
+  if (savedSpawnMode === "worktree" && !worktreeAvailable) {
+    console.error("Warning: Saved spawn mode is worktree but this directory is not a git repository. Falling back to same-dir.");
+    savedSpawnMode = undefined;
+    saveCurrentProjectConfig((current) => {
+      if (current.remoteControlSpawnMode === undefined)
+        return current;
+      return { ...current, remoteControlSpawnMode: undefined };
+    });
+  }
+  if (multiSessionEnabled && !savedSpawnMode && worktreeAvailable && parsedSpawnMode === undefined && !resumeSessionId && process.stdin.isTTY) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    console.log(`
+Claude Remote Control is launching in spawn mode which lets you create new sessions in this project from Claude Code on Web or your Mobile app. Learn more here: https://code.claude.com/docs/en/remote-control
+
+Spawn mode for this project:
+` + `  [1] same-dir \u2014 sessions share the current directory (default)
+` + `  [2] worktree \u2014 each session gets an isolated git worktree
+
+` + `This can be changed later or explicitly set with --spawn=same-dir or --spawn=worktree.
+`);
+    const answer = await new Promise((resolve2) => {
+      rl.question("Choose [1/2] (default: 1): ", resolve2);
+    });
+    rl.close();
+    const chosen = answer.trim() === "2" ? "worktree" : "same-dir";
+    savedSpawnMode = chosen;
+    logEvent("tengu_bridge_spawn_mode_chosen", {
+      spawn_mode: chosen
+    });
+    saveCurrentProjectConfig((current) => {
+      if (current.remoteControlSpawnMode === chosen)
+        return current;
+      return { ...current, remoteControlSpawnMode: chosen };
+    });
+  }
+  let spawnModeSource;
+  let spawnMode;
+  if (resumeSessionId) {
+    spawnMode = "single-session";
+    spawnModeSource = "resume";
+  } else if (parsedSpawnMode !== undefined) {
+    spawnMode = parsedSpawnMode;
+    spawnModeSource = "flag";
+  } else if (savedSpawnMode !== undefined) {
+    spawnMode = savedSpawnMode;
+    spawnModeSource = "saved";
+  } else {
+    spawnMode = multiSessionEnabled ? "same-dir" : "single-session";
+    spawnModeSource = "gate_default";
+  }
+  const maxSessions = spawnMode === "single-session" ? 1 : parsedCapacity ?? SPAWN_SESSIONS_DEFAULT;
+  const preCreateSession = parsedCreateSessionInDir ?? true;
+  if (!resumeSessionId) {
+    const { clearBridgePointer } = await import("./chunk-fxpsa506.js");
+    await clearBridgePointer(dir);
+  }
+  if (spawnMode === "worktree" && !worktreeAvailable) {
+    console.error(`Error: Worktree mode requires a git repository or WorktreeCreate hooks configured. Use --spawn=session for single-session mode.`);
+    process.exit(1);
+  }
+  const branch = await getBranch();
+  const gitRepoUrl = await getRemoteUrl();
+  const machineName = hostname();
+  const bridgeId = randomUUID();
+  const { handleOAuth401Error } = await import("./chunk-w0hw971e.js");
+  const api = createBridgeApiClient({
+    baseUrl,
+    getAccessToken: getBridgeAccessToken,
+    runnerVersion: "2.1.888",
+    onDebug: logForDebugging,
+    onAuth401: handleOAuth401Error,
+    getTrustedDeviceToken
+  });
+  let reuseEnvironmentId;
+  if (resumeSessionId) {
+    try {
+      validateBridgeId(resumeSessionId, "sessionId");
+    } catch {
+      console.error(`Error: Invalid session ID "${resumeSessionId}". Session IDs must not contain unsafe characters.`);
+      process.exit(1);
+    }
+    await checkAndRefreshOAuthTokenIfNeeded();
+    clearOAuthTokenCache();
+    const { getBridgeSession } = await import("./chunk-01pfrqr8.js");
+    const session = await getBridgeSession(resumeSessionId, {
+      baseUrl,
+      getAccessToken: getBridgeAccessToken
+    });
+    if (!session) {
+      if (resumePointerDir) {
+        const { clearBridgePointer } = await import("./chunk-fxpsa506.js");
+        await clearBridgePointer(resumePointerDir);
+      }
+      console.error(`Error: Session ${resumeSessionId} not found. It may have been archived or expired, or your login may have lapsed (run \`claude /login\`).`);
+      process.exit(1);
+    }
+    if (!session.environment_id) {
+      if (resumePointerDir) {
+        const { clearBridgePointer } = await import("./chunk-fxpsa506.js");
+        await clearBridgePointer(resumePointerDir);
+      }
+      console.error(`Error: Session ${resumeSessionId} has no environment_id. It may never have been attached to a bridge.`);
+      process.exit(1);
+    }
+    reuseEnvironmentId = session.environment_id;
+    logForDebugging(`[bridge:init] Resuming session ${resumeSessionId} on environment ${reuseEnvironmentId}`);
+  }
+  const config = {
+    dir,
+    machineName,
+    branch,
+    gitRepoUrl,
+    maxSessions,
+    spawnMode,
+    verbose,
+    sandbox,
+    bridgeId,
+    workerType: "claude_code",
+    environmentId: randomUUID(),
+    reuseEnvironmentId,
+    apiBaseUrl: baseUrl,
+    sessionIngressUrl,
+    debugFile,
+    sessionTimeoutMs
+  };
+  logForDebugging(`[bridge:init] bridgeId=${bridgeId}${reuseEnvironmentId ? ` reuseEnvironmentId=${reuseEnvironmentId}` : ""} dir=${dir} branch=${branch} gitRepoUrl=${gitRepoUrl} machine=${machineName}`);
+  logForDebugging(`[bridge:init] apiBaseUrl=${baseUrl} sessionIngressUrl=${sessionIngressUrl}`);
+  logForDebugging(`[bridge:init] sandbox=${sandbox}${debugFile ? ` debugFile=${debugFile}` : ""}`);
+  let environmentId;
+  let environmentSecret;
+  try {
+    const reg = await api.registerBridgeEnvironment(config);
+    environmentId = reg.environment_id;
+    environmentSecret = reg.environment_secret;
+  } catch (err) {
+    logEvent("tengu_bridge_registration_failed", {
+      status: err instanceof BridgeFatalError ? err.status : undefined
+    });
+    console.error(err instanceof BridgeFatalError && err.status === 404 ? "Remote Control environments are not available for your account." : `Error: ${errorMessage(err)}`);
+    process.exit(1);
+  }
+  let effectiveResumeSessionId;
+  if (resumeSessionId) {
+    if (reuseEnvironmentId && environmentId !== reuseEnvironmentId) {
+      logError(new Error(`Bridge resume env mismatch: requested ${reuseEnvironmentId}, backend returned ${environmentId}. Falling back to fresh session.`));
+      console.warn(`Warning: Could not resume session ${resumeSessionId} \u2014 its environment has expired. Creating a fresh session instead.`);
+    } else {
+      const infraResumeId = toInfraSessionId(resumeSessionId);
+      const reconnectCandidates = infraResumeId === resumeSessionId ? [resumeSessionId] : [resumeSessionId, infraResumeId];
+      let reconnected = false;
+      let lastReconnectErr;
+      for (const candidateId of reconnectCandidates) {
+        try {
+          await api.reconnectSession(environmentId, candidateId);
+          logForDebugging(`[bridge:init] Session ${candidateId} re-queued via bridge/reconnect`);
+          effectiveResumeSessionId = resumeSessionId;
+          reconnected = true;
+          break;
+        } catch (err) {
+          lastReconnectErr = err;
+          logForDebugging(`[bridge:init] reconnectSession(${candidateId}) failed: ${errorMessage(err)}`);
+        }
+      }
+      if (!reconnected) {
+        const err = lastReconnectErr;
+        const isFatal = err instanceof BridgeFatalError;
+        if (resumePointerDir && isFatal) {
+          const { clearBridgePointer } = await import("./chunk-fxpsa506.js");
+          await clearBridgePointer(resumePointerDir);
+        }
+        console.error(isFatal ? `Error: ${errorMessage(err)}` : `Error: Failed to reconnect session ${resumeSessionId}: ${errorMessage(err)}
+The session may still be resumable \u2014 try running the same command again.`);
+        process.exit(1);
+      }
+    }
+  }
+  logForDebugging(`[bridge:init] Registered, server environmentId=${environmentId}`);
+  const startupPollConfig = getPollIntervalConfig();
+  logEvent("tengu_bridge_started", {
+    max_sessions: config.maxSessions,
+    has_debug_file: !!config.debugFile,
+    sandbox: config.sandbox,
+    verbose: config.verbose,
+    heartbeat_interval_ms: startupPollConfig.non_exclusive_heartbeat_interval_ms,
+    spawn_mode: config.spawnMode,
+    spawn_mode_source: spawnModeSource,
+    multi_session_gate: multiSessionEnabled,
+    pre_create_session: preCreateSession,
+    worktree_available: worktreeAvailable
+  });
+  logForDiagnosticsNoPII("info", "bridge_started", {
+    max_sessions: config.maxSessions,
+    sandbox: config.sandbox,
+    spawn_mode: config.spawnMode
+  });
+  const spawner = createSessionSpawner({
+    execPath: process.execPath,
+    scriptArgs: spawnScriptArgs(),
+    env: process.env,
+    verbose,
+    sandbox,
+    debugFile,
+    permissionMode,
+    onDebug: logForDebugging,
+    onActivity: (sessionId, activity) => {
+      logForDebugging(`[bridge:activity] sessionId=${sessionId} ${activity.type} ${activity.summary}`);
+    },
+    onPermissionRequest: (sessionId, request, _accessToken) => {
+      logForDebugging(`[bridge:perm] sessionId=${sessionId} tool=${request.request.tool_name} request_id=${request.request_id} (not auto-approving)`);
+    }
+  });
+  const logger = createBridgeLogger({ verbose });
+  const { parseGitHubRepository } = await import("./chunk-469hyn07.js");
+  const ownerRepo = gitRepoUrl ? parseGitHubRepository(gitRepoUrl) : null;
+  const repoName = ownerRepo ? ownerRepo.split("/").pop() : basename(dir);
+  logger.setRepoInfo(repoName, branch);
+  const toggleAvailable = spawnMode !== "single-session" && worktreeAvailable;
+  if (toggleAvailable) {
+    logger.setSpawnModeDisplay(spawnMode);
+  }
+  const onStdinData = (data) => {
+    if (data[0] === 3 || data[0] === 4) {
+      process.emit("SIGINT");
+      return;
+    }
+    if (data[0] === 32) {
+      logger.toggleQr();
+      return;
+    }
+    if (data[0] === 119) {
+      if (!toggleAvailable)
+        return;
+      const newMode = config.spawnMode === "same-dir" ? "worktree" : "same-dir";
+      config.spawnMode = newMode;
+      logEvent("tengu_bridge_spawn_mode_toggled", {
+        spawn_mode: newMode
+      });
+      logger.logStatus(newMode === "worktree" ? "Spawn mode: worktree (new sessions get isolated git worktrees)" : "Spawn mode: same-dir (new sessions share the current directory)");
+      logger.setSpawnModeDisplay(newMode);
+      logger.refreshDisplay();
+      saveCurrentProjectConfig((current) => {
+        if (current.remoteControlSpawnMode === newMode)
+          return current;
+        return { ...current, remoteControlSpawnMode: newMode };
+      });
+      return;
+    }
+  };
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", onStdinData);
+  }
+  const controller = new AbortController;
+  const onSigint = () => {
+    logForDebugging("[bridge:shutdown] SIGINT received, shutting down");
+    controller.abort();
+  };
+  const onSigterm = () => {
+    logForDebugging("[bridge:shutdown] SIGTERM received, shutting down");
+    controller.abort();
+  };
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigterm);
+  let initialSessionId = effectiveResumeSessionId ? effectiveResumeSessionId : null;
+  if (preCreateSession && !effectiveResumeSessionId) {
+    const { createBridgeSession } = await import("./chunk-01pfrqr8.js");
+    try {
+      initialSessionId = await createBridgeSession({
+        environmentId,
+        title: name,
+        events: [],
+        gitRepoUrl,
+        branch,
+        signal: controller.signal,
+        baseUrl,
+        getAccessToken: getBridgeAccessToken,
+        permissionMode
+      });
+      if (initialSessionId) {
+        logForDebugging(`[bridge:init] Created initial session ${initialSessionId}`);
+      }
+    } catch (err) {
+      logForDebugging(`[bridge:init] Session creation failed (non-fatal): ${errorMessage(err)}`);
+    }
+  }
+  let pointerRefreshTimer = null;
+  if (initialSessionId && spawnMode === "single-session") {
+    const { writeBridgePointer } = await import("./chunk-fxpsa506.js");
+    const pointerPayload = {
+      sessionId: initialSessionId,
+      environmentId,
+      source: "standalone"
+    };
+    await writeBridgePointer(config.dir, pointerPayload);
+    pointerRefreshTimer = setInterval(writeBridgePointer, 3600000, config.dir, pointerPayload);
+    pointerRefreshTimer.unref?.();
+  }
+  try {
+    await runBridgeLoop(config, environmentId, environmentSecret, api, spawner, logger, controller.signal, undefined, initialSessionId ?? undefined, async () => {
+      clearOAuthTokenCache();
+      await checkAndRefreshOAuthTokenIfNeeded();
+      return getBridgeAccessToken();
+    });
+  } finally {
+    if (pointerRefreshTimer !== null) {
+      clearInterval(pointerRefreshTimer);
+    }
+    process.off("SIGINT", onSigint);
+    process.off("SIGTERM", onSigterm);
+    process.stdin.off("data", onStdinData);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.pause();
+  }
+  process.exit(0);
+}
+
 class BridgeHeadlessPermanentError extends Error {
   constructor(message) {
     super(message);
@@ -1423,9 +2346,9 @@ async function runBridgeHeadless(opts, signal) {
   const { setOriginalCwd, setCwdState } = await import("./chunk-m1tjr9xq.js");
   setOriginalCwd(dir);
   setCwdState(dir);
-  const { enableConfigs, checkHasTrustDialogAccepted } = await import("./chunk-3t37as7j.js");
+  const { enableConfigs, checkHasTrustDialogAccepted } = await import("./chunk-cbssxph9.js");
   enableConfigs();
-  const { initSinks } = await import("./chunk-5tf3y2x4.js");
+  const { initSinks } = await import("./chunk-sfmxv59p.js");
   initSinks();
   if (!checkHasTrustDialogAccepted()) {
     throw new BridgeHeadlessPermanentError(`Workspace not trusted: ${dir}. Run \`claude\` in that directory first to accept the trust dialog.`);
@@ -1433,14 +2356,14 @@ async function runBridgeHeadless(opts, signal) {
   if (!opts.getAccessToken()) {
     throw new Error(BRIDGE_LOGIN_ERROR);
   }
-  const { getBridgeBaseUrl } = await import("./chunk-k83gceng.js");
+  const { getBridgeBaseUrl } = await import("./chunk-bec4mkst.js");
   const baseUrl = getBridgeBaseUrl();
   if (baseUrl.startsWith("http://") && !baseUrl.includes("localhost") && !baseUrl.includes("127.0.0.1")) {
     throw new BridgeHeadlessPermanentError("Remote Control base URL uses HTTP. Only HTTPS or localhost HTTP is allowed.");
   }
   const sessionIngressUrl = process.env.CLAUDE_BRIDGE_SESSION_INGRESS_URL || baseUrl;
   const { getBranch, getRemoteUrl, findGitRoot } = await import("./chunk-dy8tttdp.js");
-  const { hasWorktreeCreateHook } = await import("./chunk-s99sq9ns.js");
+  const { hasWorktreeCreateHook } = await import("./chunk-6kwx0aa4.js");
   if (opts.spawnMode === "worktree") {
     const worktreeAvailable = hasWorktreeCreateHook() || findGitRoot(dir) !== null;
     if (!worktreeAvailable) {
@@ -1497,7 +2420,7 @@ async function runBridgeHeadless(opts, signal) {
   logger.printBanner(config, environmentId);
   let initialSessionId;
   if (opts.createSessionOnStart) {
-    const { createBridgeSession } = await import("./chunk-cbew0pjr.js");
+    const { createBridgeSession } = await import("./chunk-01pfrqr8.js");
     try {
       const sid = await createBridgeSession({
         environmentId,
@@ -1550,72 +2473,4 @@ function createHeadlessBridgeLogger(log) {
   };
 }
 
-// src/daemon/workerRegistry.ts
-init_auth();
-init_errors();
-var EXIT_CODE_PERMANENT = 78;
-var EXIT_CODE_TRANSIENT = 1;
-async function runDaemonWorker(kind) {
-  if (!kind) {
-    console.error("Error: --daemon-worker requires a worker kind");
-    process.exitCode = EXIT_CODE_PERMANENT;
-    return;
-  }
-  switch (kind) {
-    case "remoteControl":
-      await runRemoteControlWorker();
-      break;
-    default:
-      console.error(`Error: unknown daemon worker kind '${kind}'`);
-      process.exitCode = EXIT_CODE_PERMANENT;
-  }
-}
-async function runRemoteControlWorker() {
-  const dir = process.env.DAEMON_WORKER_DIR || resolve2(".");
-  const name = process.env.DAEMON_WORKER_NAME || undefined;
-  const spawnMode = process.env.DAEMON_WORKER_SPAWN_MODE || "same-dir";
-  const capacity = parseInt(process.env.DAEMON_WORKER_CAPACITY || "4", 10);
-  const permissionMode = process.env.DAEMON_WORKER_PERMISSION || undefined;
-  const sandbox = process.env.DAEMON_WORKER_SANDBOX === "1";
-  const sessionTimeoutMs = process.env.DAEMON_WORKER_TIMEOUT_MS ? parseInt(process.env.DAEMON_WORKER_TIMEOUT_MS, 10) : undefined;
-  const createSessionOnStart = process.env.DAEMON_WORKER_CREATE_SESSION !== "0";
-  const controller = new AbortController;
-  const onSignal = () => controller.abort();
-  process.on("SIGTERM", onSignal);
-  process.on("SIGINT", onSignal);
-  const opts = {
-    dir,
-    name,
-    spawnMode,
-    capacity,
-    permissionMode,
-    sandbox,
-    sessionTimeoutMs,
-    createSessionOnStart,
-    getAccessToken: () => getClaudeAIOAuthTokens()?.accessToken,
-    onAuth401: async (_failedToken) => {
-      const tokens = getClaudeAIOAuthTokens();
-      return !!tokens?.accessToken;
-    },
-    log: (s) => {
-      console.log(`[remoteControl] ${s}`);
-    }
-  };
-  try {
-    await runBridgeHeadless(opts, controller.signal);
-  } catch (err) {
-    if (err instanceof BridgeHeadlessPermanentError) {
-      console.error(`[remoteControl] permanent error: ${err.message}`);
-      process.exitCode = EXIT_CODE_PERMANENT;
-    } else {
-      console.error(`[remoteControl] transient error: ${errorMessage(err)}`);
-      process.exitCode = EXIT_CODE_TRANSIENT;
-    }
-  } finally {
-    process.off("SIGTERM", onSignal);
-    process.off("SIGINT", onSignal);
-  }
-}
-export {
-  runDaemonWorker
-};
+export { runBridgeLoop, isConnectionError, isServerError, parseArgs, bridgeMain, BridgeHeadlessPermanentError, runBridgeHeadless };