@funnycode/myclaude 0.1.200 → 0.1.268

package/dist/myclaude.js

@@ -4,13 +4,16 @@
 // MACRO - build-time constants (injected by build.ts)
 // MACRO injected by build script
 globalThis.MACRO = {
-  VERSION: "0.1.200",
-  BUILD_TIME: "2026-08-16T02:15:29.761Z",
+  VERSION: "0.1.268",
+  BUILD_TIME: "2026-08-17T03:36:55.543Z",
   PACKAGE_URL: "@funnycode/myclaude",
   NATIVE_PACKAGE_URL: "@funnycode/myclaude",
   VERSION_CHANGELOG: '',
   ISSUES_EXPLAINER: 'file an issue at ' + "https://github.com/thomaslwq/myclaude/issues",
   FEEDBACK_CHANNEL: 'github',
+  DEV_BRIDGE_OVERRIDES_ENABLED: false,
+  BRIDGE_OVERRIDE_TOKEN: "",
+  BRIDGE_OVERRIDE_BASE_URL: "",
 };
 // Polyfill for bun:bundle feature() — all features default to false
 // when running outside of Bun's compile-time macro system.
@@ -1955,6 +1958,7 @@ function resetSettingsCache() {
   sessionSettingsCache = null;
   perSourceCache.clear();
   parseFileCache.clear();
+  pluginSettingsBase = undefined;
 }
 function getPluginSettingsBase() {
   return pluginSettingsBase;
@@ -40562,7 +40566,7 @@ function stripLineNumberPrefix(line) {
   const match = line.match(/^\s*\d+[\u2192\t](.*)$/);
   return match?.[1] ?? line;
 }
-function isDirEmpty(dirPath) {
+function isDirEmptySync(dirPath) {
   try {
     return getFsImplementation().isDirEmptySync(dirPath);
   } catch (e) {
@@ -40625,21 +40629,7 @@ function writeFileSyncAndFlush_DEPRECATED(filePath, content, options = { encodin
     } catch (cleanupError) {
       logForDebugging(`Failed to clean up temp file: ${cleanupError}`);
     }
-    logForDebugging(`Falling back to non-atomic write for ${targetPath}`);
-    try {
-      const fallbackOptions = {
-        encoding: options.encoding,
-        flush: true
-      };
-      if (!targetExists && options.mode !== undefined) {
-        fallbackOptions.mode = options.mode;
-      }
-      fsWriteFileSync2(targetPath, content, fallbackOptions);
-      logForDebugging(`File ${targetPath} written successfully with non-atomic fallback`);
-    } catch (fallbackError) {
-      logForDebugging(`Non-atomic write also failed: ${fallbackError}`);
-      throw fallbackError;
-    }
+    throw atomicError;
   }
 }
 function getDesktopPath() {
@@ -117157,7 +117147,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@funnycode/myclaude",
-    version: "0.1.200",
+    version: "0.1.268",
     private: false,
     description: "An open-source AI coding assistant in your terminal - powered by Claude",
     license: "MIT",
@@ -117173,7 +117163,7 @@ var init_package = __esm(() => {
     homepage: "https://github.com/thomaslwq/myclaude",
     engines: {
       bun: ">=1.3.5",
-      node: ">=18.0.0"
+      node: ">=18.17.0"
     },
     scripts: {
       dev: "bun run ./src/dev-entry.ts",
@@ -117213,13 +117203,13 @@ var init_package = __esm(() => {
       "@growthbook/growthbook": "1.6.5",
       "@modelcontextprotocol/sdk": "1.29.0",
       "@opentelemetry/api": "1.9.1",
-      "@opentelemetry/api-logs": "0.214.0",
-      "@opentelemetry/core": "2.6.1",
-      "@opentelemetry/resources": "2.6.1",
-      "@opentelemetry/sdk-logs": "0.214.0",
-      "@opentelemetry/sdk-metrics": "2.6.1",
-      "@opentelemetry/sdk-trace-base": "2.6.1",
-      "@opentelemetry/semantic-conventions": "1.40.0",
+      "@opentelemetry/api-logs": "0.221.0",
+      "@opentelemetry/core": "1.28.0",
+      "@opentelemetry/resources": "1.28.0",
+      "@opentelemetry/sdk-logs": "0.52.0",
+      "@opentelemetry/sdk-metrics": "1.28.0",
+      "@opentelemetry/sdk-trace-base": "1.28.0",
+      "@opentelemetry/semantic-conventions": "1.43.0",
       ajv: "8.18.0",
       asciichart: "1.5.25",
       "async-mutex": "^0.5.0",
@@ -117245,8 +117235,8 @@ var init_package = __esm(() => {
       ink: "6.8.0",
       "jsonc-parser": "3.3.1",
       "lodash-es": "4.17.23",
-      "lru-cache": "11.2.7",
-      marked: "17.0.5",
+      "lru-cache": "11.5.2",
+      marked: "18.0.9",
       "p-map": "7.0.4",
       picomatch: "4.0.4",
       "proper-lockfile": "4.1.2",
@@ -209693,6 +209683,26 @@ var init_dumpPrompts = __esm(() => {
 
 // src/utils/abortController.ts
 import { setMaxListeners as setMaxListeners2 } from "events";
+function combineAbortSignals(signals2) {
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any(signals2);
+  }
+  const controller = new AbortController;
+  const abort = () => controller.abort();
+  for (const signal of signals2) {
+    if (signal.aborted) {
+      controller.abort();
+      return controller.signal;
+    }
+    signal.addEventListener("abort", abort, { once: true });
+  }
+  controller.signal.addEventListener("abort", () => {
+    for (const signal of signals2) {
+      signal.removeEventListener("abort", abort);
+    }
+  });
+  return controller.signal;
+}
 function createAbortController(maxListeners = DEFAULT_MAX_LISTENERS) {
   const controller = new AbortController;
   setMaxListeners2(maxListeners, controller.signal);
@@ -279592,13 +279602,15 @@ function resetCseShimGateForTesting() {
 function toCompatSessionId(id) {
   if (!id.startsWith("cse_"))
     return id;
-  if (_isCseShimEnabled && !_isCseShimEnabled())
+  if (_isCseShimEnabled !== undefined && !_isCseShimEnabled())
     return id;
   return "session_" + id.slice("cse_".length);
 }
 function toInfraSessionId(id) {
   if (!id.startsWith("session_"))
     return id;
+  if (_isCseShimEnabled && !_isCseShimEnabled())
+    return id;
   return "cse_" + id.slice("session_".length);
 }
 var _isCseShimEnabled;
@@ -280211,35 +280223,144 @@ function validateBlock(block, blockIndex) {
 }
 function checkDuplicateKeysInJson(jsonString) {
   const warnings = [];
-  const bindingsBlockPattern = /"bindings"\s*:\s*\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g;
-  let blockMatch;
-  while ((blockMatch = bindingsBlockPattern.exec(jsonString)) !== null) {
-    const blockContent = blockMatch[1];
-    if (!blockContent)
-      continue;
-    const textBeforeBlock = jsonString.slice(0, blockMatch.index);
-    const contextMatch = textBeforeBlock.match(/"context"\s*:\s*"([^"]+)"[^{]*$/);
-    const context = contextMatch?.[1] ?? "unknown";
-    const keyPattern = /"([^"]+)"\s*:/g;
-    const keysByName = new Map;
-    let keyMatch;
-    while ((keyMatch = keyPattern.exec(blockContent)) !== null) {
-      const key2 = keyMatch[1];
-      if (!key2)
-        continue;
-      const count3 = (keysByName.get(key2) ?? 0) + 1;
-      keysByName.set(key2, count3);
-      if (count3 === 2) {
-        warnings.push({
-          type: "duplicate",
-          severity: "warning",
-          message: `Duplicate key "${key2}" in ${context} bindings`,
-          key: key2,
-          context,
-          suggestion: `This key appears multiple times in the same context. JSON uses the last value, earlier values are ignored.`
-        });
+  let i3 = 0;
+  const len = jsonString.length;
+  let depth = 0;
+  let inBindings = false;
+  let currentContext = "unknown";
+  const bindingsKeyMaps = [];
+  function parseString(pos) {
+    if (pos >= len || jsonString[pos] !== '"')
+      return null;
+    let end = pos + 1;
+    while (end < len) {
+      if (jsonString[end] === "\\") {
+        end += 2;
+      } else if (jsonString[end] === '"') {
+        let decoded = "";
+        for (let k2 = pos + 1;k2 < end; k2++) {
+          if (jsonString[k2] === "\\" && k2 + 1 < end) {
+            const esc2 = jsonString[k2 + 1];
+            switch (esc2) {
+              case '"':
+                decoded += '"';
+                break;
+              case "\\":
+                decoded += "\\";
+                break;
+              case "/":
+                decoded += "/";
+                break;
+              case "b":
+                decoded += "\b";
+                break;
+              case "f":
+                decoded += "\f";
+                break;
+              case "n":
+                decoded += `
+`;
+                break;
+              case "r":
+                decoded += "\r";
+                break;
+              case "t":
+                decoded += "\t";
+                break;
+              case "u": {
+                if (k2 + 5 < end) {
+                  const hex3 = jsonString.slice(k2 + 2, k2 + 6);
+                  const cp2 = parseInt(hex3, 16);
+                  decoded += isNaN(cp2) ? jsonString.slice(k2, k2 + 6) : String.fromCharCode(cp2);
+                  k2 += 4;
+                } else {
+                  decoded += "u";
+                  k2++;
+                }
+                break;
+              }
+              default:
+                decoded += esc2;
+                break;
+            }
+            k2++;
+          } else {
+            decoded += jsonString[k2];
+          }
+        }
+        return { str: decoded, nextPos: end + 1 };
+      } else {
+        end++;
       }
     }
+    return null;
+  }
+  function skipWhitespace(pos) {
+    while (pos < len && (jsonString[pos] === " " || jsonString[pos] === `
+` || jsonString[pos] === "\t" || jsonString[pos] === "\r")) {
+      pos++;
+    }
+    return pos;
+  }
+  while (i3 < len) {
+    const char = jsonString[i3];
+    if (char === "{") {
+      depth++;
+      if (depth === 2 && inBindings) {
+        bindingsKeyMaps.push(new Map);
+      }
+      i3++;
+    } else if (char === "}") {
+      if (depth === 2 && inBindings) {
+        bindingsKeyMaps.pop();
+      }
+      depth--;
+      i3++;
+    } else if (char === '"') {
+      const result = parseString(i3);
+      if (result) {
+        const str = result.str;
+        i3 = result.nextPos;
+        const after = skipWhitespace(i3);
+        if (after < len && jsonString[after] === ":") {
+          if (depth === 1) {
+            if (str === "context") {
+              const afterColon = skipWhitespace(after + 1);
+              const valResult = parseString(afterColon);
+              if (valResult) {
+                currentContext = valResult.str;
+                i3 = valResult.nextPos;
+              }
+            } else if (str === "bindings") {
+              inBindings = true;
+            }
+          } else if (depth === 2 && inBindings) {
+            if (bindingsKeyMaps.length > 0) {
+              const keysMap = bindingsKeyMaps[bindingsKeyMaps.length - 1];
+              const count3 = (keysMap.get(str) ?? 0) + 1;
+              keysMap.set(str, count3);
+              if (count3 === 2) {
+                warnings.push({
+                  type: "duplicate",
+                  severity: "warning",
+                  message: `Duplicate key "${str}" in ${currentContext} bindings`,
+                  key: str,
+                  context: currentContext,
+                  suggestion: `This key appears multiple times in the same context. JSON uses the last value, earlier values are ignored.`
+                });
+              }
+            }
+          }
+        }
+      } else {
+        i3++;
+      }
+    } else if (char === "]" || char === "[" || char === "," || char === ":" || ` 
+	\r`.includes(char)) {
+      i3++;
+    } else {
+      i3++;
+    }
   }
   return warnings;
 }
@@ -281053,15 +281174,19 @@ function useKeybinding(action, handler, options = {}) {
       return;
     return keybindingContext.registerHandler({ action, context, handler });
   }, [action, context, handler, keybindingContext, isActive]);
-  const handleInput = import_react33.useCallback((input, key2, event) => {
+  const uniqueContexts = import_react33.useMemo(() => {
     if (!keybindingContext)
-      return;
+      return [];
     const contextsToCheck = [
       ...keybindingContext.activeContexts,
       context,
       "Global"
     ];
-    const uniqueContexts = [...new Set(contextsToCheck)];
+    return [...new Set(contextsToCheck)];
+  }, [keybindingContext?.activeContexts, context]);
+  const handleInput = import_react33.useCallback((input, key2, event) => {
+    if (!keybindingContext)
+      return;
     const result = keybindingContext.resolve(input, key2, uniqueContexts);
     switch (result.type) {
       case "match":
@@ -281092,11 +281217,13 @@ function useKeybinding(action, handler, options = {}) {
 function useKeybindings(handlers, options = {}) {
   const { context = "Global", isActive = true } = options;
   const keybindingContext = useOptionalKeybindingContext();
+  const handlersRef = import_react33.useRef(handlers);
+  handlersRef.current = handlers;
   import_react33.useEffect(() => {
     if (!keybindingContext || !isActive)
       return;
     const unregisterFns = [];
-    for (const [action, handler] of Object.entries(handlers)) {
+    for (const [action, handler] of Object.entries(handlersRef.current)) {
       unregisterFns.push(keybindingContext.registerHandler({ action, context, handler }));
     }
     return () => {
@@ -281118,8 +281245,8 @@ function useKeybindings(handlers, options = {}) {
     switch (result.type) {
       case "match":
         keybindingContext.setPendingChord(null);
-        if (result.action in handlers) {
-          const handler = handlers[result.action];
+        if (result.action in handlersRef.current) {
+          const handler = handlersRef.current[result.action];
           if (handler && handler() !== false) {
             event.stopImmediatePropagation();
           }
@@ -281139,7 +281266,7 @@ function useKeybindings(handlers, options = {}) {
       case "none":
         break;
     }
-  }, [context, handlers, keybindingContext]);
+  }, [context, keybindingContext]);
   use_input_default(handleInput, { isActive });
 }
 var import_react33;
@@ -286010,7 +286137,7 @@ var init_utils6 = __esm(() => {
 function makeXaaFetch(abortSignal) {
   return (url3, init2) => {
     const timeout = AbortSignal.timeout(XAA_REQUEST_TIMEOUT_MS);
-    const signal = abortSignal ? AbortSignal.any([timeout, abortSignal]) : timeout;
+    const signal = abortSignal ? combineAbortSignals([timeout, abortSignal]) : timeout;
     return fetch(url3, { ...init2, signal });
   };
 }
@@ -286213,6 +286340,7 @@ var init_xaa = __esm(() => {
   init_v4();
   init_log3();
   init_slowOperations();
+  init_abortController();
   defaultFetch = makeXaaFetch();
   XaaTokenExchangeError = class XaaTokenExchangeError extends Error {
     shouldClearIdToken;
@@ -319466,10 +319594,6 @@ var init_select = __esm(() => {
 });
 
 // src/bridge/bridgeStatusUtil.ts
-function buildBridgeConnectUrl(environmentId, ingressUrl) {
-  const baseUrl = getClaudeAiBaseUrl(undefined, ingressUrl);
-  return `${baseUrl}/code?bridge=${environmentId}`;
-}
 function getBridgeStatus({
   error: error49,
   connected,
@@ -407070,69 +407194,68 @@ function isInputModeCharacter(input) {
 }
 
 // src/projectOnboardingState.ts
-import { join as join105, resolve as resolve44, basename as basename37, sep as pathSep2 } from "path";
+import { join as join105 } from "path";
 function clearCachedSteps() {
-  cachedSteps = null;
-  cachedClaudeMdMtime = -1;
-  cachedRootMtime = -1;
-  cachedAt = null;
+  cache3 = null;
 }
-function isCacheValid() {
-  if (!cachedSteps)
+function isCacheValid(cached2) {
+  const now2 = performance.now();
+  if (now2 - cached2.timestamp > CACHE_TTL_MS4) {
     return false;
+  }
   const cwd2 = getCwd();
-  const claudeMdPath = join105(cwd2, "CLAUDE.md");
   const fs13 = getFsImplementation();
-  try {
-    const currentClaudeMdMtime = fs13.existsSync(claudeMdPath) ? getFileModificationTime(claudeMdPath) ?? -1 : -1;
-    if (currentClaudeMdMtime !== cachedClaudeMdMtime)
+  const hasClaudeMd = fs13.existsSync(join105(cwd2, "CLAUDE.md"));
+  if (hasClaudeMd) {
+    try {
+      const currentMtime = fs13.statSync(join105(cwd2, "CLAUDE.md"))?.mtimeMs ?? null;
+      if (currentMtime !== cached2.claudeMdMtime) {
+        return false;
+      }
+    } catch {
       return false;
-  } catch {
+    }
+  } else if (cached2.claudeMdMtime !== null) {
     return false;
   }
+  let currentIsWorkspaceDirEmpty;
   try {
-    const currentRootMtime = fs13.statSync(cwd2).mtimeMs;
-    if (Math.abs(currentRootMtime - cachedRootMtime) > 0.5)
-      return false;
+    currentIsWorkspaceDirEmpty = isDirEmptySync(cwd2);
   } catch {
-    return false;
+    currentIsWorkspaceDirEmpty = false;
   }
-  if (cachedAt !== null && Date.now() - cachedAt > CACHE_MAX_AGE_MS) {
+  if (currentIsWorkspaceDirEmpty !== cached2.isWorkspaceDirEmpty) {
     return false;
   }
   return true;
 }
 function getSteps() {
-  if (isCacheValid()) {
-    return cachedSteps;
+  if (cache3 && isCacheValid(cache3)) {
+    return cache3.steps;
   }
   const cwd2 = getCwd();
   const fs13 = getFsImplementation();
-  let hasClaudeMd = false;
-  let isWorkspaceDirEmpty = true;
+  let hasClaudeMd;
+  let isWorkspaceDirEmpty;
+  let claudeMdMtime = null;
   try {
     hasClaudeMd = fs13.existsSync(join105(cwd2, "CLAUDE.md"));
   } catch {
     hasClaudeMd = false;
   }
   try {
-    isWorkspaceDirEmpty = isDirEmpty(cwd2);
+    isWorkspaceDirEmpty = isDirEmptySync(cwd2);
   } catch {
-    isWorkspaceDirEmpty = true;
+    isWorkspaceDirEmpty = false;
   }
-  const claudeMdPath = join105(cwd2, "CLAUDE.md");
-  try {
-    cachedClaudeMdMtime = hasClaudeMd ? getFileModificationTime(claudeMdPath) : -1;
-  } catch {
-    cachedClaudeMdMtime = -1;
-  }
-  try {
-    cachedRootMtime = fs13.statSync(cwd2).mtimeMs;
-  } catch {
-    cachedRootMtime = -1;
+  if (hasClaudeMd) {
+    try {
+      claudeMdMtime = fs13.statSync(join105(cwd2, "CLAUDE.md"))?.mtimeMs ?? null;
+    } catch {
+      hasClaudeMd = false;
+    }
   }
-  cachedAt = Date.now();
-  cachedSteps = [
+  const steps = [
     {
       key: "workspace",
       text: "Ask Claude to create a new app or clone a repository",
@@ -407148,7 +407271,14 @@ function getSteps() {
       isEnabled: !isWorkspaceDirEmpty
     }
   ];
-  return cachedSteps;
+  const newCache = {
+    steps,
+    timestamp: performance.now(),
+    claudeMdMtime,
+    isWorkspaceDirEmpty
+  };
+  cache3 = newCache;
+  return steps;
 }
 function isProjectOnboardingComplete() {
   return getSteps().filter(({ isCompletable, isEnabled: isEnabled2 }) => isCompletable && isEnabled2).every(({ isComplete }) => isComplete);
@@ -407166,7 +407296,7 @@ function maybeMarkProjectOnboardingComplete() {
 }
 function shouldShowProjectOnboarding() {
   const projectConfig = getCurrentProjectConfig();
-  if (projectConfig.hasCompletedProjectOnboarding || projectConfig.projectOnboardingSeenCount >= 4 || process.env.IS_DEMO) {
+  if (projectConfig.hasCompletedProjectOnboarding || projectConfig.hasDismissedProjectOnboarding) {
     return false;
   }
   return !isProjectOnboardingComplete();
@@ -407177,7 +407307,7 @@ function incrementProjectOnboardingSeenCount() {
     projectOnboardingSeenCount: current.projectOnboardingSeenCount + 1
   }));
 }
-var cachedSteps = null, cachedClaudeMdMtime = -1, cachedRootMtime = -1, cachedAt = null, CACHE_MAX_AGE_MS = 60000;
+var CACHE_TTL_MS4 = 5000, cache3 = null;
 var init_projectOnboardingState = __esm(() => {
   init_config();
   init_cwd2();
@@ -409547,7 +409677,7 @@ var init_renderPlaceholder = __esm(() => {
 });
 
 // src/hooks/usePasteHandler.ts
-import { basename as basename38 } from "path";
+import { basename as basename37 } from "path";
 function usePasteHandler({
   onPaste,
   onInput,
@@ -409598,7 +409728,7 @@ function usePasteHandler({
             const validImages = results.filter((r) => r !== null);
             if (validImages.length > 0) {
               for (const imageData of validImages) {
-                const filename = basename38(imageData.path);
+                const filename = basename37(imageData.path);
                 onImagePaste2(imageData.base64, imageData.mediaType, filename, imageData.dimensions, imageData.path);
               }
               const nonImageLines = lines2.filter((line) => !isImageFilePath(line));
@@ -410203,7 +410333,7 @@ var init_TextInput = __esm(() => {
 });
 
 // src/utils/suggestions/directoryCompletion.ts
-import { basename as basename39, dirname as dirname53, join as join112, sep as sep31 } from "path";
+import { basename as basename38, dirname as dirname53, join as join112, sep as sep31 } from "path";
 function parsePartialPath(partialPath, basePath) {
   if (!partialPath) {
     const directory2 = basePath || getCwd();
@@ -410214,7 +410344,7 @@ function parsePartialPath(partialPath, basePath) {
     return { directory: resolved, prefix: "" };
   }
   const directory = dirname53(resolved);
-  const prefix = basename39(partialPath);
+  const prefix = basename38(partialPath);
   return { directory, prefix };
 }
 async function scanDirectory(dirPath) {
@@ -412351,8 +412481,8 @@ class FileIndex {
   }
   loadFromFileListAsync(fileList) {
     let markQueryable = () => {};
-    const queryable = new Promise((resolve45) => {
-      markQueryable = resolve45;
+    const queryable = new Promise((resolve44) => {
+      markQueryable = resolve44;
     });
     const done = this.buildAsync(fileList, markQueryable);
     return { queryable, done };
@@ -412533,7 +412663,7 @@ function isUpper(code) {
   return code >= 65 && code <= 90;
 }
 function yieldToEventLoop() {
-  return new Promise((resolve45) => setImmediate(resolve45));
+  return new Promise((resolve44) => setImmediate(resolve44));
 }
 function computeTopLevelEntries(paths2, limit2) {
   const topLevel = new Set;
@@ -421895,7 +422025,7 @@ function extractFirstFrame(output) {
   return output.slice(contentStart, endIndex);
 }
 function renderToAnsiString(node, columns) {
-  return new Promise(async (resolve45) => {
+  return new Promise(async (resolve44) => {
     let output = "";
     const stream4 = new PassThrough3;
     if (columns !== undefined) {
@@ -421911,7 +422041,7 @@ function renderToAnsiString(node, columns) {
       patchConsole: false
     });
     await instance.waitUntilExit();
-    await resolve45(extractFirstFrame(output));
+    await resolve44(extractFirstFrame(output));
   });
 }
 async function renderToString(node, columns) {
@@ -422419,14 +422549,14 @@ function computeTurnStats(turn) {
   };
 }
 function useTurnDiffs(messages) {
-  const cache3 = import_react111.useRef({
+  const cache4 = import_react111.useRef({
     completedTurns: [],
     currentTurn: null,
     lastProcessedIndex: 0,
     lastTurnIndex: 0
   });
   return import_react111.useMemo(() => {
-    const c6 = cache3.current;
+    const c6 = cache4.current;
     if (messages.length < c6.lastProcessedIndex) {
       c6.completedTurns = [];
       c6.currentTurn = null;
@@ -422507,7 +422637,7 @@ var init_useTurnDiffs = __esm(() => {
 });
 
 // src/components/diff/DiffDetailView.tsx
-import { resolve as resolve45 } from "path";
+import { resolve as resolve44 } from "path";
 function DiffDetailView(t0) {
   const $3 = import_compiler_runtime146.c(53);
   const {
@@ -422540,7 +422670,7 @@ function DiffDetailView(t0) {
     let content;
     let t22;
     if ($3[1] !== filePath) {
-      const fullPath = resolve45(getCwd(), filePath);
+      const fullPath = resolve44(getCwd(), filePath);
       content = readFileSafe(fullPath);
       t22 = content?.split(`
 `)[0] ?? null;
@@ -426495,12 +426625,12 @@ import {
   spawn as spawn10,
   spawnSync as spawnSync4
 } from "child_process";
-import { basename as basename40 } from "path";
+import { basename as basename39 } from "path";
 function isCommandAvailable3(command3) {
   return !!whichSync(command3);
 }
 function classifyGuiEditor(editor) {
-  const base2 = basename40(editor.split(" ")[0] ?? "");
+  const base2 = basename39(editor.split(" ")[0] ?? "");
   return GUI_EDITORS.find((g2) => base2.includes(g2));
 }
 function guiGotoArgv(guiFamily, filePath, line) {
@@ -426537,7 +426667,7 @@ function openFileInExternalEditor(filePath, line) {
   const inkInstance = instances_default.get(process.stdout);
   if (!inkInstance)
     return false;
-  const useGotoLine = line && PLUS_N_EDITORS.test(basename40(base2));
+  const useGotoLine = line && PLUS_N_EDITORS.test(basename39(base2));
   inkInstance.enterAlternateScreen();
   try {
     const syncOpts = { stdio: "inherit" };
@@ -433717,7 +433847,7 @@ var init_channelPermissions = __esm(() => {
 });
 
 // src/services/mcp/useManageMCPConnections.ts
-import { basename as basename41 } from "path";
+import { basename as basename40 } from "path";
 function getErrorKey(error49) {
   const plugin = "plugin" in error49 ? error49.plugin : "no-plugin";
   return `${error49.type}:${error49.source}:${plugin}`;
@@ -433872,8 +434002,8 @@ function useManageMCPConnections(dynamicMcpConfig, isStrictMcpConfig = false) {
                 }
                 const backoffMs = Math.min(INITIAL_BACKOFF_MS * Math.pow(2, attempt - 1), MAX_BACKOFF_MS);
                 logMCPDebug(client.name, `Scheduling reconnection attempt ${attempt + 1} in ${backoffMs}ms`);
-                await new Promise((resolve46) => {
-                  const timer = setTimeout(resolve46, backoffMs);
+                await new Promise((resolve45) => {
+                  const timer = setTimeout(resolve45, backoffMs);
                   reconnectTimersRef.current.set(client.name, timer);
                 });
               }
@@ -434094,7 +434224,7 @@ function useManageMCPConnections(dynamicMcpConfig, isStrictMcpConfig = false) {
         else if (serverConfig.scope === "claudeai")
           counts.claudeai++;
         if (process.env.USER_TYPE === "ant" && !isMcpServerDisabled(name) && (serverConfig.type === undefined || serverConfig.type === "stdio") && "command" in serverConfig) {
-          stdioCommands.push(basename41(serverConfig.command));
+          stdioCommands.push(basename40(serverConfig.command));
         }
       }
       logEvent("tengu_mcp_servers", {
@@ -436896,7 +437026,7 @@ var init_pluginStartupCheck = __esm(() => {
 
 // src/utils/plugins/parseMarketplaceInput.ts
 import { homedir as homedir30 } from "os";
-import { resolve as resolve46 } from "path";
+import { resolve as resolve45 } from "path";
 async function parseMarketplaceInput(input) {
   const trimmed = input.trim();
   const fs13 = getFsImplementation();
@@ -436931,7 +437061,7 @@ async function parseMarketplaceInput(input) {
   const isWindows2 = process.platform === "win32";
   const isWindowsPath = isWindows2 && (trimmed.startsWith(".\\") || trimmed.startsWith("..\\") || /^[a-zA-Z]:[/\\]/.test(trimmed));
   if (trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("/") || trimmed.startsWith("~") || isWindowsPath) {
-    const resolvedPath = resolve46(trimmed.startsWith("~") ? trimmed.replace(/^~/, homedir30()) : trimmed);
+    const resolvedPath = resolve45(trimmed.startsWith("~") ? trimmed.replace(/^~/, homedir30()) : trimmed);
     let stats;
     try {
       stats = await fs13.stat(resolvedPath);
@@ -437196,34 +437326,34 @@ async function loadInstallCountsCache() {
       logForDebugging("Install counts cache has invalid structure");
       return null;
     }
-    const cache3 = parsed;
-    if (cache3.version !== INSTALL_COUNTS_CACHE_VERSION) {
-      logForDebugging(`Install counts cache version mismatch (got ${cache3.version}, expected ${INSTALL_COUNTS_CACHE_VERSION})`);
+    const cache4 = parsed;
+    if (cache4.version !== INSTALL_COUNTS_CACHE_VERSION) {
+      logForDebugging(`Install counts cache version mismatch (got ${cache4.version}, expected ${INSTALL_COUNTS_CACHE_VERSION})`);
       return null;
     }
-    if (typeof cache3.fetchedAt !== "string" || !Array.isArray(cache3.counts)) {
+    if (typeof cache4.fetchedAt !== "string" || !Array.isArray(cache4.counts)) {
       logForDebugging("Install counts cache has invalid structure");
       return null;
     }
-    const fetchedAt = new Date(cache3.fetchedAt).getTime();
+    const fetchedAt = new Date(cache4.fetchedAt).getTime();
     if (Number.isNaN(fetchedAt)) {
       logForDebugging("Install counts cache has invalid fetchedAt timestamp");
       return null;
     }
-    const validCounts = cache3.counts.every((entry) => typeof entry === "object" && entry !== null && typeof entry.plugin === "string" && typeof entry.unique_installs === "number");
+    const validCounts = cache4.counts.every((entry) => typeof entry === "object" && entry !== null && typeof entry.plugin === "string" && typeof entry.unique_installs === "number");
     if (!validCounts) {
       logForDebugging("Install counts cache has malformed entries");
       return null;
     }
     const now2 = Date.now();
-    if (now2 - fetchedAt > CACHE_TTL_MS4) {
+    if (now2 - fetchedAt > CACHE_TTL_MS5) {
       logForDebugging("Install counts cache is stale (>24h old)");
       return null;
     }
     return {
-      version: cache3.version,
-      fetchedAt: cache3.fetchedAt,
-      counts: cache3.counts
+      version: cache4.version,
+      fetchedAt: cache4.fetchedAt,
+      counts: cache4.counts
     };
   } catch (error49) {
     const code = getErrnoCode(error49);
@@ -437233,13 +437363,13 @@ async function loadInstallCountsCache() {
     return null;
   }
 }
-async function saveInstallCountsCache(cache3) {
+async function saveInstallCountsCache(cache4) {
   const cachePath = getInstallCountsCachePath();
   const tempPath = `${cachePath}.${randomBytes16(8).toString("hex")}.tmp`;
   try {
     const pluginsDir = getPluginsDirectory();
     await getFsImplementation().mkdir(pluginsDir);
-    const content = jsonStringify(cache3, null, 2);
+    const content = jsonStringify(cache4, null, 2);
     await writeFile33(tempPath, content, {
       encoding: "utf-8",
       mode: 384
@@ -437271,12 +437401,12 @@ async function fetchInstallCountsFromGitHub() {
   }
 }
 async function getInstallCounts() {
-  const cache3 = await loadInstallCountsCache();
-  if (cache3) {
+  const cache4 = await loadInstallCountsCache();
+  if (cache4) {
     logForDebugging("Using cached install counts");
     logPluginFetch("install_counts", INSTALL_COUNTS_URL, "cache_hit", 0);
     const map3 = new Map;
-    for (const entry of cache3.counts) {
+    for (const entry of cache4.counts) {
       map3.set(entry.plugin, entry.unique_installs);
     }
     return map3;
@@ -437313,7 +437443,7 @@ function formatInstallCount(count4) {
   const formatted = m2.toFixed(1);
   return formatted.endsWith(".0") ? `${formatted.slice(0, -2)}M` : `${formatted}M`;
 }
-var INSTALL_COUNTS_CACHE_VERSION = 1, INSTALL_COUNTS_CACHE_FILENAME = "install-counts-cache.json", INSTALL_COUNTS_URL = "https://raw.githubusercontent.com/anthropics/claude-plugins-official/refs/heads/stats/stats/plugin-installs.json", CACHE_TTL_MS4;
+var INSTALL_COUNTS_CACHE_VERSION = 1, INSTALL_COUNTS_CACHE_FILENAME = "install-counts-cache.json", INSTALL_COUNTS_URL = "https://raw.githubusercontent.com/anthropics/claude-plugins-official/refs/heads/stats/stats/plugin-installs.json", CACHE_TTL_MS5;
 var init_installCounts = __esm(() => {
   init_axios2();
   init_debug();
@@ -437323,7 +437453,7 @@ var init_installCounts = __esm(() => {
   init_slowOperations();
   init_fetchTelemetry();
   init_pluginDirectories();
-  CACHE_TTL_MS4 = 24 * 60 * 60 * 1000;
+  CACHE_TTL_MS5 = 24 * 60 * 60 * 1000;
 });
 
 // src/commands/plugin/PluginOptionsDialog.tsx
@@ -441693,7 +441823,7 @@ async function writeToDisk(plugins) {
       mode: 384
     });
     await rename10(tempPath, filePath);
-    cache3 = plugins;
+    cache4 = plugins;
   } catch (error49) {
     logError2(error49);
     try {
@@ -441711,20 +441841,20 @@ async function loadFlaggedPlugins() {
       changed = true;
     }
   }
-  cache3 = all4;
+  cache4 = all4;
   if (changed) {
     await writeToDisk(all4);
   }
 }
 function getFlaggedPlugins() {
-  return cache3 ?? {};
+  return cache4 ?? {};
 }
 async function addFlaggedPlugin(pluginId) {
-  if (cache3 === null) {
-    cache3 = await readFromDisk();
+  if (cache4 === null) {
+    cache4 = await readFromDisk();
   }
   const updated = {
-    ...cache3,
+    ...cache4,
     [pluginId]: {
       flaggedAt: new Date().toISOString()
     }
@@ -441733,12 +441863,12 @@ async function addFlaggedPlugin(pluginId) {
   logForDebugging(`Flagged plugin: ${pluginId}`);
 }
 async function markFlaggedPluginsSeen(pluginIds) {
-  if (cache3 === null) {
-    cache3 = await readFromDisk();
+  if (cache4 === null) {
+    cache4 = await readFromDisk();
   }
   const now2 = new Date().toISOString();
   let changed = false;
-  const updated = { ...cache3 };
+  const updated = { ...cache4 };
   for (const id of pluginIds) {
     const entry = updated[id];
     if (entry && !entry.seenAt) {
@@ -441751,16 +441881,16 @@ async function markFlaggedPluginsSeen(pluginIds) {
   }
 }
 async function removeFlaggedPlugin(pluginId) {
-  if (cache3 === null) {
-    cache3 = await readFromDisk();
+  if (cache4 === null) {
+    cache4 = await readFromDisk();
   }
-  if (!(pluginId in cache3))
+  if (!(pluginId in cache4))
     return;
-  const { [pluginId]: _2, ...rest } = cache3;
-  cache3 = rest;
+  const { [pluginId]: _2, ...rest } = cache4;
+  cache4 = rest;
   await writeToDisk(rest);
 }
-var FLAGGED_PLUGINS_FILENAME = "flagged-plugins.json", SEEN_EXPIRY_MS, cache3 = null;
+var FLAGGED_PLUGINS_FILENAME = "flagged-plugins.json", SEEN_EXPIRY_MS, cache4 = null;
 var init_pluginFlagging = __esm(() => {
   init_debug();
   init_fsOperations();
@@ -451209,10 +451339,10 @@ var require_browser2 = __commonJS((exports) => {
         text2 = canvas;
         canvas = undefined;
       }
-      return new Promise(function(resolve48, reject2) {
+      return new Promise(function(resolve47, reject2) {
         try {
           const data = QRCode.create(text2, opts);
-          resolve48(renderFunc(data, canvas, opts));
+          resolve47(renderFunc(data, canvas, opts));
         } catch (e) {
           reject2(e);
         }
@@ -451268,11 +451398,11 @@ function getStringRendererFromType(type) {
 }
 function render2(renderFunc, text2, params) {
   if (!params.cb) {
-    return new Promise(function(resolve48, reject2) {
+    return new Promise(function(resolve47, reject2) {
       try {
         const data = QRCode.create(text2, params.opts);
         return renderFunc(data, params.opts, function(err2, data2) {
-          return err2 ? reject2(err2) : resolve48(data2);
+          return err2 ? reject2(err2) : resolve47(data2);
         });
       } catch (e) {
         reject2(e);
@@ -451987,21 +452117,45 @@ var init_release_notes2 = __esm(() => {
 });
 
 // src/bridge/bridgeConfig.ts
+function createBridgeOverrideResolver(macro) {
+  const devEnabled = macro?.DEV_BRIDGE_OVERRIDES_ENABLED === true;
+  const token = macro?.BRIDGE_OVERRIDE_TOKEN || "";
+  const baseUrl = macro?.BRIDGE_OVERRIDE_BASE_URL || "";
+  return {
+    getBridgeTokenOverride() {
+      if (!devEnabled) {
+        return;
+      }
+      return token || undefined;
+    },
+    getBridgeBaseUrlOverride() {
+      if (!devEnabled) {
+        return;
+      }
+      return baseUrl || undefined;
+    }
+  };
+}
+function getResolver() {
+  return _resolver;
+}
 function getBridgeTokenOverride() {
-  return process.env.USER_TYPE === "ant" && process.env.CLAUDE_BRIDGE_OAUTH_TOKEN || undefined;
+  return getResolver().getBridgeTokenOverride();
 }
 function getBridgeBaseUrlOverride() {
-  return process.env.USER_TYPE === "ant" && process.env.CLAUDE_BRIDGE_BASE_URL || undefined;
+  return getResolver().getBridgeBaseUrlOverride();
 }
 function getBridgeAccessToken() {
-  return getBridgeTokenOverride() ?? getClaudeAIOAuthTokens()?.accessToken;
+  return getClaudeAIOAuthTokens()?.accessToken;
 }
 function getBridgeBaseUrl() {
-  return getBridgeBaseUrlOverride() ?? getOauthConfig().BASE_API_URL;
+  return getOauthConfig().bridgeUrl;
 }
+var _resolver;
 var init_bridgeConfig = __esm(() => {
   init_oauth();
   init_auth();
+  _resolver = createBridgeOverrideResolver(globalThis.MACRO);
 });
 
 // src/utils/sessionTitle.ts
@@ -453666,8 +453820,8 @@ async function fetchReferralEligibility(campaign = "claude_code_guest_pass") {
   const url3 = `${getOauthConfig().BASE_API_URL}/api/oauth/organizations/${orgUUID}/referral/eligibility`;
   let resolvePromise;
   let rejectPromise;
-  const promise3 = new Promise((resolve48, reject2) => {
-    resolvePromise = resolve48;
+  const promise3 = new Promise((resolve47, reject2) => {
+    resolvePromise = resolve47;
     rejectPromise = reject2;
   });
   fetchInProgressMap.set(orgUUID, promise3);
@@ -468405,6 +468559,369 @@ var init_vim2 = __esm(() => {
   vim_default = command5;
 });
 
+// src/flows/definitions.ts
+function getFlowByName(name) {
+  return DEFAULT_FLOWS.find((flow) => flow.name === name);
+}
+function getAllFlows() {
+  return DEFAULT_FLOWS;
+}
+var DEFAULT_FLOWS;
+var init_definitions = __esm(() => {
+  DEFAULT_FLOWS = [
+    {
+      name: "docker-setup",
+      description: "Set up a Docker Compose environment with a web application",
+      steps: [
+        {
+          id: "1",
+          description: "Create Dockerfile for the application",
+          files: ["Dockerfile"],
+          reasoning: "Define how the application should be containerized"
+        },
+        {
+          id: "2",
+          description: "Create docker-compose.yml with services",
+          files: ["docker-compose.yml"],
+          reasoning: "Define the services and their configuration"
+        },
+        {
+          id: "3",
+          description: "Create .dockerignore file",
+          files: [".dockerignore"],
+          reasoning: "Exclude unnecessary files from the Docker build context"
+        },
+        {
+          id: "4",
+          description: "Create .env.example file",
+          files: [".env.example"],
+          reasoning: "Document required environment variables"
+        },
+        {
+          id: "5",
+          description: "Create README with Docker setup instructions",
+          files: ["README.md"],
+          reasoning: "Provide clear instructions for users"
+        }
+      ]
+    },
+    {
+      name: "rest-api-setup",
+      description: "Create a REST API with authentication",
+      steps: [
+        {
+          id: "1",
+          description: "Initialize Node.js project with package.json",
+          files: ["package.json"],
+          reasoning: "Set up the project structure"
+        },
+        {
+          id: "2",
+          description: "Install dependencies (express, jsonwebtoken, bcrypt)",
+          command: "npm install express jsonwebtoken bcrypt",
+          reasoning: "Add necessary packages for the API"
+        },
+        {
+          id: "3",
+          description: "Create server.js with Express setup",
+          files: ["server.js"],
+          reasoning: "Set up the HTTP server"
+        },
+        {
+          id: "4",
+          description: "Create routes directory and user routes",
+          files: ["routes/userRoutes.js"],
+          reasoning: "Define API endpoints"
+        },
+        {
+          id: "5",
+          description: "Create middleware for authentication",
+          files: ["middleware/auth.js"],
+          reasoning: "Add security to protected routes"
+        },
+        {
+          id: "6",
+          description: "Create .env.example file",
+          files: [".env.example"],
+          reasoning: "Document required environment variables"
+        },
+        {
+          id: "7",
+          description: "Create README with API documentation",
+          files: ["README.md"],
+          reasoning: "Provide clear usage instructions"
+        }
+      ]
+    },
+    {
+      name: "react-app-setup",
+      description: "Set up a modern React application with TypeScript",
+      steps: [
+        {
+          id: "1",
+          description: "Create package.json with React dependencies",
+          files: ["package.json"],
+          reasoning: "Define project dependencies"
+        },
+        {
+          id: "2",
+          description: "Create tsconfig.json",
+          files: ["tsconfig.json"],
+          reasoning: "Configure TypeScript"
+        },
+        {
+          id: "3",
+          description: "Create vite.config.ts",
+          files: ["vite.config.ts"],
+          reasoning: "Configure Vite build tool"
+        },
+        {
+          id: "4",
+          description: "Create index.html entry point",
+          files: ["index.html"],
+          reasoning: "Define the HTML structure"
+        },
+        {
+          id: "5",
+          description: "Create src/main.tsx",
+          files: ["src/main.tsx"],
+          reasoning: "Set up the React entry point"
+        },
+        {
+          id: "6",
+          description: "Create src/App.tsx",
+          files: ["src/App.tsx"],
+          reasoning: "Create the main application component"
+        },
+        {
+          id: "7",
+          description: "Create .gitignore",
+          files: [".gitignore"],
+          reasoning: "Exclude build artifacts and node_modules"
+        },
+        {
+          id: "8",
+          description: "Create README with setup instructions",
+          files: ["README.md"],
+          reasoning: "Provide clear setup instructions"
+        }
+      ]
+    },
+    {
+      name: "testing-setup",
+      description: "Set up a comprehensive testing suite",
+      steps: [
+        {
+          id: "1",
+          description: "Install testing dependencies (vitest, @testing-library/react)",
+          command: "npm install -D vitest @testing-library/react @testing-library/jest-dom",
+          reasoning: "Add testing tools"
+        },
+        {
+          id: "2",
+          description: "Create vitest.config.ts",
+          files: ["vitest.config.ts"],
+          reasoning: "Configure Vitest"
+        },
+        {
+          id: "3",
+          description: "Create test setup file",
+          files: ["src/setupTests.ts"],
+          reasoning: "Set up testing environment"
+        },
+        {
+          id: "4",
+          description: "Create example test file",
+          files: ["src/__tests__/example.test.ts"],
+          reasoning: "Provide a template for writing tests"
+        },
+        {
+          id: "5",
+          description: "Update package.json scripts",
+          files: ["package.json"],
+          reasoning: "Add test scripts"
+        },
+        {
+          id: "6",
+          description: "Create README with testing guide",
+          files: ["README.md"],
+          reasoning: "Document testing practices"
+        }
+      ]
+    }
+  ];
+});
+
+// src/flows/executor.ts
+async function executeFlow(flow, context2, onStepStart, onStepComplete, onStepFail, onComplete) {
+  const state = {
+    currentStepIndex: 0,
+    completedSteps: [],
+    failedSteps: [],
+    totalSteps: flow.steps.length,
+    startTime: Date.now()
+  };
+  for (let i3 = 0;i3 < flow.steps.length; i3++) {
+    const step = flow.steps[i3];
+    state.currentStepIndex = i3;
+    try {
+      if (onStepStart) {
+        await onStepStart(step, state);
+      }
+      if (step.command) {
+        await executeCommand(step.command, context2);
+      }
+      if (step.files && step.files.length > 0) {
+        for (const file2 of step.files) {
+          await executeFileOperation(file2, context2);
+        }
+      }
+      state.completedSteps.push(step.id);
+      if (onStepComplete) {
+        try {
+          await onStepComplete(step, state);
+        } catch (callbackError) {
+          console.error(`onStepComplete callback failed for step "${step.id}":`, callbackError);
+        }
+      }
+    } catch (error49) {
+      state.failedSteps.push(step.id);
+      if (onStepFail) {
+        await onStepFail(step, state, error49);
+      }
+      const shouldContinue = await shouldContinueOnError(error49, step);
+      if (!shouldContinue) {
+        break;
+      }
+    }
+  }
+  if (onComplete) {
+    await onComplete(state);
+  }
+  return state;
+}
+async function executeCommand(command6, context2) {
+  if (context2?.bridge?.runCommand) {
+    await context2.bridge.runCommand(command6);
+    return;
+  }
+  throw new Error("No bridge.runCommand available to execute: " + command6);
+}
+async function executeFileOperation(file2, context2) {
+  if (context2?.bridge?.editFile) {
+    await context2.bridge.editFile(file2);
+    return;
+  }
+  throw new Error("No bridge.editFile available to edit: " + file2);
+}
+async function shouldContinueOnError(error49, step) {
+  const errorMessages2 = [
+    "EACCES",
+    "ENOENT",
+    "ETIMEDOUT"
+  ];
+  return errorMessages2.some((msg) => error49.message.includes(msg));
+}
+
+// src/commands/flow.ts
+function getPromptContent3(args) {
+  const { flow: flowAttribution } = getAttributionTexts();
+  const flows = getAllFlows();
+  if (!args.trim()) {
+    return `## Available Flows
+
+${flows.map((flow2) => `- **${flow2.name}**: ${flow2.description}`).join(`
+`)}
+
+Please specify a flow name to execute, e.g., "/flow docker-setup"`;
+  }
+  const flow = getFlowByName(args.trim());
+  if (!flow) {
+    return `## Flow Not Found
+
+Could not find a flow named "${args.trim()}".
+
+Available flows:
+${flows.map((f) => `- ${f.name}: ${f.description}`).join(`
+`)}`;
+  }
+  return `## Flow: ${flow.name}
+
+**Description**: ${flow.description}
+
+## Execution Plan
+
+${flow.steps.map((step, index) => `${index + 1}. **${step.id}**: ${step.description}${step.reasoning ? ` - ${step.reasoning}` : ""}`).join(`
+`)}
+
+## Your Task
+
+Execute the flow step by step:
+
+1. Start with step 1 and work through all steps sequentially
+2. For each step, follow the description and reasoning provided
+3. Use the available tools (Edit, Run commands, etc.) to complete each step
+4. Report progress after each step
+5. If a step fails, analyze the error and determine if it's recoverable
+6. Continue to the next step unless the error is critical
+
+## Important Rules
+
+- Execute steps in order
+- Report progress after each step
+- Handle errors gracefully
+- Verify each step completes successfully before moving to the next
+${flowAttribution ? `
+
+${flowAttribution}` : ""}`;
+}
+var ALLOWED_TOOLS3, command6, flow_default;
+var init_flow = __esm(() => {
+  init_attribution();
+  init_definitions();
+  ALLOWED_TOOLS3 = [
+    "Bash(*)",
+    "Edit(*)",
+    "Read(*)",
+    "List(*)",
+    "Create(*)"
+  ];
+  command6 = {
+    type: "prompt",
+    name: "flow",
+    description: "Execute pre-built workflows (flows)",
+    allowedTools: ALLOWED_TOOLS3,
+    contentLength: 0,
+    progressMessage: "executing flow",
+    source: "builtin",
+    async getPromptForCommand(args, context2) {
+      return getPromptContent3(args);
+    },
+    async executeFlow(args, context2) {
+      const flow = getFlowByName(args.trim());
+      if (!flow) {
+        throw new Error(`Flow not found: ${args}`);
+      }
+      const state = await executeFlow(flow, context2, async (step, state2) => {
+        console.log(`
+▶️  Starting step ${state2.currentStepIndex + 1}/${state2.totalSteps}: ${step.description}`);
+      }, async (step, state2) => {
+        console.log(`✅ Step ${state2.currentStepIndex}/${state2.totalSteps} completed: ${step.description}`);
+      }, async (step, state2, error49) => {
+        console.error(`❌ Step ${state2.currentStepIndex}/${state2.totalSteps} failed: ${step.description}`);
+        console.error(`Error: ${error49.message}`);
+      }, async (state2) => {
+        console.log(`
+\uD83C\uDF89 Flow execution complete!`);
+        console.log(`Completed: ${state2.completedSteps.length}/${state2.totalSteps}`);
+        console.log(`Failed: ${state2.failedSteps.length}/${state2.totalSteps}`);
+      });
+      return state;
+    }
+  };
+  flow_default = command6;
+});
+
 // src/commands/thinkback/thinkback.tsx
 var exports_thinkback = {};
 __export(exports_thinkback, {
@@ -483906,11 +484423,11 @@ var init_sandbox_toggle = __esm(() => {
 });
 
 // src/commands/sandbox-toggle/index.ts
-var command6, sandbox_toggle_default;
+var command7, sandbox_toggle_default;
 var init_sandbox_toggle2 = __esm(() => {
   init_figures();
   init_sandbox_adapter();
-  command6 = {
+  command7 = {
     name: "sandbox",
     get description() {
       const currentlyEnabled = SandboxManager2.isSandboxingEnabled();
@@ -483942,7 +484459,7 @@ var init_sandbox_toggle2 = __esm(() => {
     type: "local-jsx",
     load: () => Promise.resolve().then(() => (init_sandbox_toggle(), exports_sandbox_toggle))
   };
-  sandbox_toggle_default = command6;
+  sandbox_toggle_default = command7;
 });
 
 // src/utils/claudeInChrome/setupPortable.ts
@@ -484155,18 +484672,18 @@ function registerWindowsNativeHosts(manifestPath) {
     });
   }
 }
-async function createWrapperScript(command7) {
+async function createWrapperScript(command8) {
   const platform5 = getPlatform();
   const chromeDir = join131(getClaudeConfigHomeDir(), "chrome");
   const wrapperPath = platform5 === "windows" ? join131(chromeDir, "chrome-native-host.bat") : join131(chromeDir, "chrome-native-host");
   const scriptContent = platform5 === "windows" ? `@echo off
 REM Chrome native host wrapper script
 REM Generated by Claude Code - do not edit manually
-${command7}
+${command8}
 ` : `#!/bin/sh
 # Chrome native host wrapper script
 # Generated by Claude Code - do not edit manually
-exec ${command7}
+exec ${command8}
 `;
   const existingContent = await readFile46(wrapperPath, "utf-8").catch(() => null);
   if (existingContent === scriptContent) {
@@ -484621,10 +485138,10 @@ var init_chrome = __esm(() => {
 });
 
 // src/commands/chrome/index.ts
-var command7, chrome_default;
+var command8, chrome_default;
 var init_chrome2 = __esm(() => {
   init_state();
-  command7 = {
+  command8 = {
     name: "chrome",
     description: "Claude in Chrome (Beta) settings",
     availability: ["claude-ai"],
@@ -484632,7 +485149,7 @@ var init_chrome2 = __esm(() => {
     type: "local-jsx",
     load: () => Promise.resolve().then(() => (init_chrome(), exports_chrome))
   };
-  chrome_default = command7;
+  chrome_default = command8;
 });
 
 // src/commands/stickers/stickers.ts
@@ -485116,6 +485633,206 @@ var init_frontend_tdd = __esm(() => {
   frontend_tdd_default = frontendTdd;
 });
 
+// src/commands/agentic-tdd.ts
+function getPrompt11(args) {
+  const featureDesc = args.trim() || "(no description provided)";
+  return `You are practicing **Agentic TDD (Test-Driven Development) with automated test-fix-rerun loop**.
+
+## User's Request
+
+${featureDesc}
+
+## Agentic TDD Workflow
+
+You are in full autonomous mode. Follow the **Red-Green-Refactor** cycle strictly, and execute tests automatically after each change.
+
+### Phase 1: Baseline
+1. First, run the existing test suite to establish a baseline: \`bun test\`
+2. Note which tests pass and fail before you start
+
+### Phase 2: \uD83D\uDD34 Red — Write the Failing Test First
+1. Understand the requirement and identify the expected behavior
+2. Write a test that captures the requirement — this test MUST fail initially
+3. The test should cover:
+   - Normal expected behavior (happy path)
+   - Edge cases (empty state, error state, boundary values)
+   - User interactions (click, input, submit, navigation)
+   - Accessibility (ARIA labels, keyboard navigation, focus management)
+4. Use the project's existing test framework and conventions (Bun test, Vitest, Jest, etc.)
+5. Run the test to verify it fails: \`bun test\`
+6. If the test passes unexpectedly, it's a buggy test — fix the test
+
+### Phase 3: \uD83D\uDFE2 Green — Minimum Code to Pass
+1. Write ONLY the code needed to make the failing test pass
+2. No speculative features, no future-proofing, no "while I'm here" additions
+3. After writing code, run the tests: \`bun test\`
+4. If tests fail, analyze the error output and iterate:
+   - Read the error message and stack trace
+   - Identify what's broken
+   - Fix the implementation
+   - Re-run tests
+   - Repeat until all tests pass (up to 5 iterations)
+
+### Phase 4: \uD83D\uDD35 Refactor — Clean Up Safely
+1. Once the test is green, refactor for clarity and maintainability
+2. Run tests after each refactor step: \`bun test\`
+3. The test MUST stay green after every refactor step
+4. If the test turns red during refactor, the refactor broke something — revert
+
+### Phase 5: Final Verification
+1. Run the full test suite one final time: \`bun test\`
+2. Report the results to the user
+
+## Automated Test-Fix-Rerun Loop Rules
+
+- After EVERY code change, run \`bun test\` immediately
+- If tests fail, parse the error output and fix the code
+- Do NOT modify tests to make them pass — fix the implementation instead
+- Maximum 5 fix iterations per Red or Green phase
+- If after 5 iterations the tests still fail, report the failure to the user with the error details
+
+## Testing Guidelines
+
+- **Component tests**: Test behavior, not implementation details
+- **User interactions**: Use \`@testing-library/user-event\` over \`fireEvent\`
+- **Accessibility**: Prefer queries by role (\`getByRole\`) over test IDs
+- **Async**: Use \`waitFor\` or \`findBy*\` queries for async operations
+- **Mocking**: Mock external APIs at the network level (MSW) or module level (vi.mock)
+- **Style**: Test visual outcomes (is the element visible/disabled?), not CSS class names
+- **Snapshots**: Use sparingly — prefer assertion-based tests
+
+## Project Context
+
+- Test framework: Bun test (\`bun test\`)
+- Check \`package.json\` for test framework and scripts
+- Check existing test files in \`__tests__/\`, \`*.test.tsx\`, \`*.spec.tsx\` for conventions
+
+## Important Rules
+
+- NEVER skip the Red phase — a passing test without implementation is a buggy test
+- NEVER modify a test to make it pass — fix the implementation instead
+- Run the test suite after each change to ensure nothing is broken
+- If multiple test files exist, run only the relevant test file during development for speed, but run the full suite for final verification
+- Report each phase completion to the user`;
+}
+var agenticTdd, agentic_tdd_default;
+var init_agentic_tdd = __esm(() => {
+  agenticTdd = {
+    type: "prompt",
+    name: "agentic-tdd",
+    description: "Agentic TDD with automated test-fix-rerun loop — write tests, run, fix, repeat autonomously",
+    argumentHint: "<feature description or bug fix description>",
+    progressMessage: "running agentic TDD loop",
+    contentLength: 0,
+    source: "builtin",
+    async getPromptForCommand(args) {
+      return [{ type: "text", text: getPrompt11(args) }];
+    }
+  };
+  agentic_tdd_default = agenticTdd;
+});
+
+// src/commands/agent.ts
+function getPlanPrompt(args) {
+  const taskDesc = args.trim() || "(no description provided)";
+  return `You are an autonomous coding agent. Your goal is to complete the user's request by breaking it down into concrete steps and executing them.
+
+## User's Request
+
+${taskDesc}
+
+## Your Task
+
+1. **Analyze the request** and understand what needs to be done
+2. **Create a plan** with 3-7 concrete steps. Each step should be:
+   - Specific and actionable
+   - Can be executed using available tools (edit files, run commands, etc.)
+   - Logical order (start with setup, then core changes, then verification)
+3. **For each step**, provide:
+   - A clear description of what to do
+   - The specific command or file changes needed
+   - Brief reasoning for why this step is important
+   - How to verify the step was successful (run tests, check output, etc.)
+
+## Planning Guidelines
+
+- Break down complex tasks into smaller, manageable steps
+- Include setup steps (install dependencies, create files, etc.)
+- Include verification steps (run tests, build, check output)
+- Consider edge cases and potential issues
+- Keep the plan realistic and achievable
+
+## Example Plan Structure
+
+1. **Setup**: Install dependencies, set up environment
+2. **Create files**: Generate necessary files based on requirements
+3. **Implement core logic**: Write the main functionality
+4. **Add tests**: Write tests to verify the implementation
+5. **Run verification**: Execute tests and build to ensure everything works
+6. **Cleanup**: Remove temporary files or unnecessary changes
+
+## Important Rules
+
+- Always provide a clear, numbered plan
+- Each step should be independent and executable
+- Include verification steps to ensure the task is complete
+- Be realistic about what can be done in a single step
+- If the request is too vague, ask for clarification before planning
+
+After creating the plan, ask the user to confirm it before proceeding to execution.`;
+}
+var agent, agent_default;
+var init_agent2 = __esm(() => {
+  agent = {
+    type: "prompt",
+    name: "agent",
+    description: "Autonomous agent mode - plan and execute tasks step-by-step",
+    argumentHint: "<task description>",
+    progressMessage: "agent mode executing",
+    contentLength: 0,
+    source: "builtin",
+    async getPromptForCommand(args, context2) {
+      const taskDesc = args.trim() || "(no description provided)";
+      return [
+        { type: "text", text: getPlanPrompt(taskDesc) },
+        {
+          type: "text",
+          text: `
+## Execution Instructions
+
+After you receive this plan, you will execute each step one by one. For each step:
+1. Read the step description carefully
+2. Use the available tools to execute it
+3. Verify the step completed successfully (run tests, check output, etc.)
+4. Report the results
+5. Only move to the next step after completing the current one
+
+## Self-Correction
+
+If a step fails:
+1. Analyze the error message
+2. Determine the root cause
+3. Apply a fix (revert changes, re-edit, or try alternative approach)
+4. Re-verify the step
+5. If it still fails after 3 attempts, report the failure and move on
+
+## User Approval
+
+Before starting execution, present the plan to the user and ask for confirmation:
+- "Here is my plan for completing this task:"
+- List the steps
+- "Shall I proceed with this plan?"
+
+Wait for user confirmation before executing the first step.
+
+**Important**: You are in autonomous mode. Execute the plan step-by-step. Report progress after each step and a summary at the end.`
+        }
+      ];
+    }
+  };
+  agent_default = agent;
+});
+
 // src/commands/remember.ts
 import { appendFile as appendFile5, mkdir as mkdir36 } from "fs/promises";
 import { join as join133 } from "path";
@@ -485176,7 +485893,7 @@ var init_remember = __esm(() => {
 // src/skills/bundledSkills.ts
 import { constants as fsConstants5 } from "fs";
 import { mkdir as mkdir37, open as open14 } from "fs/promises";
-import { dirname as dirname59, isAbsolute as isAbsolute28, join as join134, normalize as normalize13, sep as pathSep3 } from "path";
+import { dirname as dirname59, isAbsolute as isAbsolute28, join as join134, normalize as normalize13, sep as pathSep2 } from "path";
 function registerBundledSkill(definition) {
   const { files: files3 } = definition;
   let skillRoot;
@@ -485194,7 +485911,7 @@ function registerBundledSkill(definition) {
       return prependBaseDir(blocks, extractedDir);
     };
   }
-  const command8 = {
+  const command9 = {
     type: "prompt",
     name: definition.name,
     description: definition.description,
@@ -485218,7 +485935,7 @@ function registerBundledSkill(definition) {
     progressMessage: "running",
     getPromptForCommand
   };
-  bundledSkills.push(command8);
+  bundledSkills.push(command9);
 }
 function getBundledSkills() {
   return [...bundledSkills];
@@ -485263,7 +485980,7 @@ async function safeWriteFile(p, content) {
 }
 function resolveSkillFilePath(baseDir, relPath) {
   const normalized = normalize13(relPath);
-  if (isAbsolute28(normalized) || normalized.split(pathSep3).includes("..") || normalized.split("/").includes("..")) {
+  if (isAbsolute28(normalized) || normalized.split(pathSep2).includes("..") || normalized.split("/").includes("..")) {
     throw new Error(`bundled skill file path escapes skill dir: ${relPath}`);
   }
   return join134(baseDir, normalized);
@@ -487764,8 +488481,8 @@ async function withStatsCacheLock(fn) {
     await statsCacheLockPromise;
   }
   let releaseLock2;
-  statsCacheLockPromise = new Promise((resolve48) => {
-    releaseLock2 = resolve48;
+  statsCacheLockPromise = new Promise((resolve47) => {
+    releaseLock2 = resolve47;
   });
   try {
     return await fn();
@@ -487843,7 +488560,7 @@ async function loadStatsCache() {
     return getEmptyCache();
   }
 }
-async function saveStatsCache(cache4) {
+async function saveStatsCache(cache5) {
   const fs14 = getFsImplementation();
   const cachePath = getStatsCachePath();
   const tempPath = `${cachePath}.${randomBytes18(8).toString("hex")}.tmp`;
@@ -487852,7 +488569,7 @@ async function saveStatsCache(cache4) {
     try {
       await fs14.mkdir(configDir);
     } catch {}
-    const content = jsonStringify(cache4, null, 2);
+    const content = jsonStringify(cache5, null, 2);
     const handle = await open15(tempPath, "w", 384);
     try {
       await handle.writeFile(content, { encoding: "utf-8" });
@@ -487861,7 +488578,7 @@ async function saveStatsCache(cache4) {
       await handle.close();
     }
     await fs14.rename(tempPath, cachePath);
-    logForDebugging(`Stats cache saved successfully (lastComputedDate: ${cache4.lastComputedDate})`);
+    logForDebugging(`Stats cache saved successfully (lastComputedDate: ${cache5.lastComputedDate})`);
   } catch (error49) {
     logError2(error49);
     try {
@@ -488519,7 +489236,7 @@ var init_screenshotClipboard = __esm(() => {
 
 // src/utils/stats.ts
 import { open as open16 } from "fs/promises";
-import { basename as basename44, join as join139, sep as sep36 } from "path";
+import { basename as basename43, join as join139, sep as sep36 } from "path";
 async function processSessionFiles(sessionFiles, options = {}) {
   const { fromDate, toDate } = options;
   const fs14 = getFsImplementation();
@@ -488577,7 +489294,7 @@ async function processSessionFiles(sessionFiles, options = {}) {
         logForDebugging(`Failed to read session file ${sessionFile}: ${errorMessage(error49)}`);
         continue;
       }
-      const sessionId = basename44(sessionFile, ".jsonl");
+      const sessionId = basename43(sessionFile, ".jsonl");
       const messages = [];
       for (const entry of entries) {
         if (isTranscriptMessage(entry)) {
@@ -488720,9 +489437,9 @@ async function getAllSessionFiles() {
   }));
   return projectResults.flat();
 }
-function cacheToStats(cache4, todayStats) {
+function cacheToStats(cache5, todayStats) {
   const dailyActivityMap = new Map;
-  for (const day of cache4.dailyActivity) {
+  for (const day of cache5.dailyActivity) {
     dailyActivityMap.set(day.date, { ...day });
   }
   if (todayStats) {
@@ -488738,7 +489455,7 @@ function cacheToStats(cache4, todayStats) {
     }
   }
   const dailyModelTokensMap = new Map;
-  for (const day of cache4.dailyModelTokens) {
+  for (const day of cache5.dailyModelTokens) {
     dailyModelTokensMap.set(day.date, { ...day.tokensByModel });
   }
   if (todayStats) {
@@ -488753,7 +489470,7 @@ function cacheToStats(cache4, todayStats) {
       }
     }
   }
-  const modelUsage = { ...cache4.modelUsage };
+  const modelUsage = { ...cache5.modelUsage };
   if (todayStats) {
     for (const [model, usage] of Object.entries(todayStats.modelUsage)) {
       if (modelUsage[model]) {
@@ -488773,7 +489490,7 @@ function cacheToStats(cache4, todayStats) {
     }
   }
   const hourCountsMap = new Map;
-  for (const [hour, count4] of Object.entries(cache4.hourCounts)) {
+  for (const [hour, count4] of Object.entries(cache5.hourCounts)) {
     hourCountsMap.set(parseInt(hour, 10), count4);
   }
   if (todayStats) {
@@ -488785,9 +489502,9 @@ function cacheToStats(cache4, todayStats) {
   const dailyActivityArray = Array.from(dailyActivityMap.values()).sort((a2, b3) => a2.date.localeCompare(b3.date));
   const streaks = calculateStreaks(dailyActivityArray);
   const dailyModelTokens = Array.from(dailyModelTokensMap.entries()).map(([date6, tokensByModel]) => ({ date: date6, tokensByModel })).sort((a2, b3) => a2.date.localeCompare(b3.date));
-  const totalSessions = cache4.totalSessions + (todayStats?.sessionStats.length || 0);
-  const totalMessages = cache4.totalMessages + (todayStats?.totalMessages || 0);
-  let longestSession = cache4.longestSession;
+  const totalSessions = cache5.totalSessions + (todayStats?.sessionStats.length || 0);
+  const totalMessages = cache5.totalMessages + (todayStats?.totalMessages || 0);
+  let longestSession = cache5.longestSession;
   if (todayStats) {
     for (const session2 of todayStats.sessionStats) {
       if (!longestSession || session2.duration > longestSession.duration) {
@@ -488795,7 +489512,7 @@ function cacheToStats(cache4, todayStats) {
       }
     }
   }
-  let firstSessionDate = cache4.firstSessionDate;
+  let firstSessionDate = cache5.firstSessionDate;
   let lastSessionDate = null;
   if (todayStats) {
     for (const session2 of todayStats.sessionStats) {
@@ -488813,7 +489530,7 @@ function cacheToStats(cache4, todayStats) {
   const peakActivityDay = dailyActivityArray.length > 0 ? dailyActivityArray.reduce((max2, d) => d.messageCount > max2.messageCount ? d : max2).date : null;
   const peakActivityHour = hourCountsMap.size > 0 ? Array.from(hourCountsMap.entries()).reduce((max2, [hour, count4]) => count4 > max2[1] ? [hour, count4] : max2)[0] : null;
   const totalDays = firstSessionDate && lastSessionDate ? Math.ceil((new Date(lastSessionDate).getTime() - new Date(firstSessionDate).getTime()) / (1000 * 60 * 60 * 24)) + 1 : 0;
-  const totalSpeculationTimeSavedMs = cache4.totalSpeculationTimeSavedMs + (todayStats?.totalSpeculationTimeSavedMs || 0);
+  const totalSpeculationTimeSavedMs = cache5.totalSpeculationTimeSavedMs + (todayStats?.totalSpeculationTimeSavedMs || 0);
   const result = {
     totalSessions,
     totalMessages,
@@ -488839,30 +489556,30 @@ async function aggregateClaudeCodeStats() {
     return getEmptyStats();
   }
   const updatedCache = await withStatsCacheLock(async () => {
-    const cache4 = await loadStatsCache();
+    const cache5 = await loadStatsCache();
     const yesterday = getYesterdayDateString();
-    let result = cache4;
-    if (!cache4.lastComputedDate) {
+    let result = cache5;
+    if (!cache5.lastComputedDate) {
       logForDebugging("Stats cache empty, processing all historical data");
       const historicalStats = await processSessionFiles(allSessionFiles, {
         toDate: yesterday
       });
       if (historicalStats.sessionStats.length > 0 || historicalStats.dailyActivity.length > 0) {
-        result = mergeCacheWithNewStats(cache4, historicalStats, yesterday);
+        result = mergeCacheWithNewStats(cache5, historicalStats, yesterday);
         await saveStatsCache(result);
       }
-    } else if (isDateBefore(cache4.lastComputedDate, yesterday)) {
-      const nextDay = getNextDay(cache4.lastComputedDate);
-      logForDebugging(`Stats cache stale (${cache4.lastComputedDate}), processing ${nextDay} to ${yesterday}`);
+    } else if (isDateBefore(cache5.lastComputedDate, yesterday)) {
+      const nextDay = getNextDay(cache5.lastComputedDate);
+      logForDebugging(`Stats cache stale (${cache5.lastComputedDate}), processing ${nextDay} to ${yesterday}`);
       const newStats = await processSessionFiles(allSessionFiles, {
         fromDate: nextDay,
         toDate: yesterday
       });
       if (newStats.sessionStats.length > 0 || newStats.dailyActivity.length > 0) {
-        result = mergeCacheWithNewStats(cache4, newStats, yesterday);
+        result = mergeCacheWithNewStats(cache5, newStats, yesterday);
         await saveStatsCache(result);
       } else {
-        result = { ...cache4, lastComputedDate: yesterday };
+        result = { ...cache5, lastComputedDate: yesterday };
         await saveStatsCache(result);
       }
     }
@@ -491502,10 +492219,10 @@ function extractToolStats(log2) {
 `) + 1;
                 }
               }
-              const command8 = input.command || "";
-              if (command8.includes("git commit"))
+              const command9 = input.command || "";
+              if (command9.includes("git commit"))
                 gitCommits++;
-              if (command8.includes("git push"))
+              if (command9.includes("git push"))
                 gitPushes++;
             }
           }
@@ -492925,7 +493642,7 @@ async function scanAllSessions() {
       });
     }
     if (i3 % 10 === 9) {
-      await new Promise((resolve48) => setImmediate(resolve48));
+      await new Promise((resolve47) => setImmediate(resolve47));
     }
   }
   allSessions.sort((a2, b3) => b3.mtime - a2.mtime);
@@ -493710,14 +494427,14 @@ function hasCommand(commandName, commands) {
   return findCommand(commandName, commands) !== undefined;
 }
 function getCommand(commandName, commands) {
-  const command8 = findCommand(commandName, commands);
-  if (!command8) {
+  const command9 = findCommand(commandName, commands);
+  if (!command9) {
     throw ReferenceError(`Command ${commandName} not found. Available commands: ${commands.map((_2) => {
       const name = getCommandName(_2);
       return _2.aliases ? `${name} (aliases: ${_2.aliases.join(", ")})` : name;
     }).sort((a2, b3) => a2.localeCompare(b3)).join(", ")}`);
   }
-  return command8;
+  return command9;
 }
 function formatDescriptionWithSource(cmd) {
   if (cmd.type !== "prompt") {
@@ -493794,6 +494511,7 @@ var init_commands2 = __esm(() => {
   init_usage3();
   init_theme4();
   init_vim2();
+  init_flow();
   init_thinkback2();
   init_thinkback_play2();
   init_permissions4();
@@ -493826,6 +494544,8 @@ var init_commands2 = __esm(() => {
   init_artifact();
   init_git_flow();
   init_frontend_tdd();
+  init_agentic_tdd();
+  init_agent2();
   init_remember();
   init_log3();
   init_errors();
@@ -493957,6 +494677,8 @@ var init_commands2 = __esm(() => {
     newHotfixCmd,
     finishHotfixCmd,
     frontend_tdd_default,
+    agentic_tdd_default,
+    agent_default,
     tag_default,
     theme_default,
     feedback_default,
@@ -493990,6 +494712,7 @@ var init_commands2 = __esm(() => {
     hooks_default,
     export_default,
     sandbox_toggle_default,
+    flow_default,
     ...!isUsing3PServices() ? [logout_default, login_default()] : [],
     passes_default,
     ...peersCmd ? [peersCmd] : [],
@@ -494167,7 +494890,7 @@ import {
   unlink as unlink19,
   writeFile as writeFile41
 } from "fs/promises";
-import { basename as basename45, dirname as dirname61, join as join141 } from "path";
+import { basename as basename44, dirname as dirname61, join as join141 } from "path";
 function isTranscriptMessage(entry) {
   return entry.type === "user" || entry.type === "assistant" || entry.type === "attachment" || entry.type === "system";
 }
@@ -494381,8 +495104,8 @@ class Project {
   decrementPendingWrites() {
     this.pendingWriteCount--;
     if (this.pendingWriteCount === 0) {
-      for (const resolve48 of this.flushResolvers) {
-        resolve48();
+      for (const resolve47 of this.flushResolvers) {
+        resolve47();
       }
       this.flushResolvers = [];
     }
@@ -494396,13 +495119,13 @@ class Project {
     }
   }
   enqueueWrite(filePath, entry) {
-    return new Promise((resolve48) => {
+    return new Promise((resolve47) => {
       let queue2 = this.writeQueues.get(filePath);
       if (!queue2) {
         queue2 = [];
         this.writeQueues.set(filePath, queue2);
       }
-      queue2.push({ entry, resolve: resolve48 });
+      queue2.push({ entry, resolve: resolve47 });
       this.scheduleDrain();
     });
   }
@@ -494436,7 +495159,7 @@ class Project {
       const batch = queue2.splice(0);
       let content = "";
       const resolvers3 = [];
-      for (const { entry, resolve: resolve48 } of batch) {
+      for (const { entry, resolve: resolve47 } of batch) {
         const line = jsonStringify(entry) + `
 `;
         if (content.length + line.length >= this.MAX_CHUNK_BYTES) {
@@ -494448,7 +495171,7 @@ class Project {
           content = "";
         }
         content += line;
-        resolvers3.push(resolve48);
+        resolvers3.push(resolve47);
       }
       if (content.length > 0) {
         await this.appendToFile(filePath, content);
@@ -494571,8 +495294,8 @@ class Project {
     if (this.pendingWriteCount === 0) {
       return;
     }
-    return new Promise((resolve48) => {
-      this.flushResolvers.push(resolve48);
+    return new Promise((resolve47) => {
+      this.flushResolvers.push(resolve47);
     });
   }
   async removeMessageByUuid(targetUuid) {
@@ -495222,7 +495945,7 @@ function applySnipRemovals(messages) {
     messages.delete(uuid5);
     removedCount++;
   }
-  const resolve48 = (start) => {
+  const resolve47 = (start) => {
     const path25 = [];
     let cur = start;
     while (cur && toDelete.has(cur)) {
@@ -495241,7 +495964,7 @@ function applySnipRemovals(messages) {
   for (const [uuid5, msg] of messages) {
     if (!msg.parentUuid || !toDelete.has(msg.parentUuid))
       continue;
-    messages.set(uuid5, { ...msg, parentUuid: resolve48(msg.parentUuid) });
+    messages.set(uuid5, { ...msg, parentUuid: resolve47(msg.parentUuid) });
     relinkedCount++;
   }
   logEvent("tengu_snip_resume_filtered", {
@@ -496601,7 +497324,7 @@ async function getSessionFilesWithMtime(projectDir) {
   for (const dirent of dirents) {
     if (!dirent.isFile() || !dirent.name.endsWith(".jsonl"))
       continue;
-    const sessionId = validateUuid2(basename45(dirent.name, ".jsonl"));
+    const sessionId = validateUuid2(basename44(dirent.name, ".jsonl"));
     if (!sessionId)
       continue;
     candidates.push({ sessionId, filePath: join141(projectDir, dirent.name) });
@@ -498253,8 +498976,8 @@ class DiskTaskOutput {
       this.#queue.push(content);
     }
     if (!this.#flushPromise) {
-      this.#flushPromise = new Promise((resolve48) => {
-        this.#flushResolve = resolve48;
+      this.#flushPromise = new Promise((resolve47) => {
+        this.#flushResolve = resolve47;
       });
       track(this.#drain());
     }
@@ -498320,10 +499043,10 @@ class DiskTaskOutput {
         }
       }
     } finally {
-      const resolve48 = this.#flushResolve;
+      const resolve47 = this.#flushResolve;
       this.#flushPromise = null;
       this.#flushResolve = null;
-      resolve48();
+      resolve47();
     }
   }
 }
@@ -498611,11 +499334,11 @@ class ShellCommandImpl {
     this.#childProcess.once("exit", this.#exitHandler.bind(this));
     this.#childProcess.once("error", this.#errorHandler.bind(this));
     this.#timeoutId = setTimeout(ShellCommandImpl.#handleTimeout, this.#timeout, this);
-    const exitPromise = new Promise((resolve48) => {
-      this.#exitCodeResolver = resolve48;
+    const exitPromise = new Promise((resolve47) => {
+      this.#exitCodeResolver = resolve47;
     });
-    return new Promise((resolve48) => {
-      this.#resultResolver = resolve48;
+    return new Promise((resolve47) => {
+      this.#resultResolver = resolve47;
       exitPromise.then(this.#handleExit.bind(this));
     });
   }
@@ -499640,7 +500363,7 @@ __export(exports_hooks2, {
   executeConfigChangeHooks: () => executeConfigChangeHooks,
   createBaseHookInput: () => createBaseHookInput
 });
-import { basename as basename46 } from "path";
+import { basename as basename45 } from "path";
 import { spawn as spawn11 } from "child_process";
 import { randomUUID as randomUUID30 } from "crypto";
 function getSessionEndHookTimeoutMs() {
@@ -499655,13 +500378,13 @@ function executeInBackground({
   asyncResponse,
   hookEvent,
   hookName,
-  command: command8,
+  command: command9,
   asyncRewake,
   pluginId
 }) {
   if (asyncRewake) {
     shellCommand.result.then(async (result) => {
-      await new Promise((resolve48) => setImmediate(resolve48));
+      await new Promise((resolve47) => setImmediate(resolve47));
       const stdout = await shellCommand.taskOutput.getStdout();
       const stderr = shellCommand.taskOutput.getStderr();
       shellCommand.cleanup();
@@ -499693,7 +500416,7 @@ function executeInBackground({
     asyncResponse,
     hookEvent,
     hookName,
-    command: command8,
+    command: command9,
     shellCommand,
     pluginId
   });
@@ -499810,7 +500533,7 @@ function parseHttpHookOutput(body) {
 }
 function processHookJSONOutput({
   json: json2,
-  command: command8,
+  command: command9,
   hookName,
   toolUseID,
   hookEvent,
@@ -499837,7 +500560,7 @@ function processHookJSONOutput({
         result.permissionBehavior = "deny";
         result.blockingError = {
           blockingError: json2.reason || "Blocked by hook",
-          command: command8
+          command: command9
         };
         break;
       default:
@@ -499856,7 +500579,7 @@ function processHookJSONOutput({
         result.permissionBehavior = "deny";
         result.blockingError = {
           blockingError: json2.reason || "Blocked by hook",
-          command: command8
+          command: command9
         };
         break;
       case "ask":
@@ -499884,7 +500607,7 @@ function processHookJSONOutput({
               result.permissionBehavior = "deny";
               result.blockingError = {
                 blockingError: json2.hookSpecificOutput.permissionDecisionReason || json2.reason || "Blocked by hook",
-                command: command8
+                command: command9
               };
               break;
             case "ask":
@@ -499944,7 +500667,7 @@ function processHookJSONOutput({
           if (json2.hookSpecificOutput.action === "decline") {
             result.blockingError = {
               blockingError: json2.reason || "Elicitation denied by hook",
-              command: command8
+              command: command9
             };
           }
         }
@@ -499958,7 +500681,7 @@ function processHookJSONOutput({
           if (json2.hookSpecificOutput.action === "decline") {
             result.blockingError = {
               blockingError: json2.reason || "Elicitation result blocked by hook",
-              command: command8
+              command: command9
             };
           }
         }
@@ -499982,7 +500705,7 @@ function processHookJSONOutput({
       stdout,
       stderr,
       exitCode,
-      command: command8,
+      command: command9,
       durationMs
     })
   };
@@ -499997,29 +500720,29 @@ async function execCommandHook(hook, hookEvent, hookName, jsonInput, signal, hoo
   const isPowerShell = shellType === "powershell";
   const toHookPath = isWindows2 && !isPowerShell ? (p) => windowsPathToPosixPath(p) : (p) => p;
   const projectDir = getProjectRoot();
-  let command8 = hook.command;
+  let command9 = hook.command;
   let pluginOpts;
   if (pluginRoot) {
     if (!await pathExists(pluginRoot)) {
       throw new Error(`Plugin directory does not exist: ${pluginRoot}` + (pluginId ? ` (${pluginId} — run /plugin to reinstall)` : ""));
     }
     const rootPath = toHookPath(pluginRoot);
-    command8 = command8.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, () => rootPath);
+    command9 = command9.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, () => rootPath);
     if (pluginId) {
       const dataPath = toHookPath(getPluginDataDir(pluginId));
-      command8 = command8.replace(/\$\{CLAUDE_PLUGIN_DATA\}/g, () => dataPath);
+      command9 = command9.replace(/\$\{CLAUDE_PLUGIN_DATA\}/g, () => dataPath);
     }
     if (pluginId) {
       pluginOpts = loadPluginOptions(pluginId);
-      command8 = substituteUserConfigVariables(command8, pluginOpts);
+      command9 = substituteUserConfigVariables(command9, pluginOpts);
     }
   }
-  if (isWindows2 && !isPowerShell && command8.trim().match(/\.sh(\s|$|")/)) {
-    if (!command8.trim().startsWith("bash ")) {
-      command8 = `bash ${command8}`;
+  if (isWindows2 && !isPowerShell && command9.trim().match(/\.sh(\s|$|")/)) {
+    if (!command9.trim().startsWith("bash ")) {
+      command9 = `bash ${command9}`;
     }
   }
-  const finalCommand = !isPowerShell && process.env.CLAUDE_CODE_SHELL_PREFIX ? formatShellPrefixCommand(process.env.CLAUDE_CODE_SHELL_PREFIX, command8) : command8;
+  const finalCommand = !isPowerShell && process.env.CLAUDE_CODE_SHELL_PREFIX ? formatShellPrefixCommand(process.env.CLAUDE_CODE_SHELL_PREFIX, command9) : command9;
   const hookTimeoutMs = hook.timeout ? hook.timeout * 1000 : TOOL_HOOK_EXECUTION_TIMEOUT_MS;
   const envVars = {
     ...subprocessEnv(),
@@ -500107,8 +500830,8 @@ async function execCommandHook(hook, hookEvent, hookName, jsonInput, signal, hoo
   child.stderr.setEncoding("utf8");
   let initialResponseChecked = false;
   let asyncResolve = null;
-  const childIsAsyncPromise = new Promise((resolve48) => {
-    asyncResolve = resolve48;
+  const childIsAsyncPromise = new Promise((resolve47) => {
+    asyncResolve = resolve47;
   });
   const processedPromptLines = new Set;
   let promptChain = Promise.resolve();
@@ -500199,13 +500922,13 @@ async function execCommandHook(hook, hookEvent, hookName, jsonInput, signal, hoo
     hookEvent,
     getOutput: async () => ({ stdout, stderr, output })
   });
-  const stdoutEndPromise = new Promise((resolve48) => {
-    child.stdout.on("end", () => resolve48());
+  const stdoutEndPromise = new Promise((resolve47) => {
+    child.stdout.on("end", () => resolve47());
   });
-  const stderrEndPromise = new Promise((resolve48) => {
-    child.stderr.on("end", () => resolve48());
+  const stderrEndPromise = new Promise((resolve47) => {
+    child.stderr.on("end", () => resolve47());
   });
-  const stdinWritePromise = stdinWritten ? Promise.resolve() : new Promise((resolve48, reject2) => {
+  const stdinWritePromise = stdinWritten ? Promise.resolve() : new Promise((resolve47, reject2) => {
     child.stdin.on("error", (err2) => {
       if (!requestPrompt) {
         reject2(err2);
@@ -500218,12 +500941,12 @@ async function execCommandHook(hook, hookEvent, hookName, jsonInput, signal, hoo
     if (!requestPrompt) {
       child.stdin.end();
     }
-    resolve48();
+    resolve47();
   });
   const childErrorPromise = new Promise((_2, reject2) => {
     child.on("error", reject2);
   });
-  const childClosePromise = new Promise((resolve48) => {
+  const childClosePromise = new Promise((resolve47) => {
     let exitCode = null;
     child.on("close", (code) => {
       exitCode = code ?? 1;
@@ -500231,7 +500954,7 @@ async function execCommandHook(hook, hookEvent, hookName, jsonInput, signal, hoo
         const finalStdout = processedPromptLines.size === 0 ? stdout : stdout.split(`
 `).filter((line) => !processedPromptLines.has(line.trim())).join(`
 `);
-        resolve48({
+        resolve47({
           stdout: finalStdout,
           stderr,
           output,
@@ -500471,7 +501194,7 @@ async function getMatchingHooks(appState, sessionId, hookEvent, hookInput, tools
         matchQuery = hookInput.load_reason;
         break;
       case "FileChanged":
-        matchQuery = basename46(hookInput.file_path);
+        matchQuery = basename45(hookInput.file_path);
         break;
       default:
         break;
@@ -502262,12 +502985,12 @@ async function executeFunctionHook({
         hook
       };
     }
-    const passed = await new Promise((resolve48, reject2) => {
+    const passed = await new Promise((resolve47, reject2) => {
       const onAbort = () => reject2(new Error("Function hook cancelled"));
       abortSignal.addEventListener("abort", onAbort);
       Promise.resolve(hook.callback(messages, abortSignal)).then((result) => {
         abortSignal.removeEventListener("abort", onAbort);
-        resolve48(result);
+        resolve47(result);
       }).catch((error49) => {
         abortSignal.removeEventListener("abort", onAbort);
         reject2(error49);
@@ -502502,7 +503225,7 @@ import {
   symlink as symlink5,
   utimes as utimes2
 } from "fs/promises";
-import { basename as basename47, dirname as dirname62, join as join145 } from "path";
+import { basename as basename46, dirname as dirname62, join as join145 } from "path";
 function validateWorktreeSlug(slug) {
   if (slug.length > MAX_WORKTREE_SLUG_LENGTH) {
     throw new Error(`Invalid worktree name: must be ${MAX_WORKTREE_SLUG_LENGTH} characters or fewer (got ${slug.length})`);
@@ -502545,7 +503268,7 @@ function restoreWorktreeSession(session2) {
   currentWorktreeSession = session2;
 }
 function generateTmuxSessionName(repoPath, branch2) {
-  const repoName = basename47(repoPath);
+  const repoName = basename46(repoPath);
   const combined = `${repoName}_${branch2}`;
   return combined.replace(/[/.]/g, "_");
 }
@@ -503121,7 +503844,7 @@ async function execIntoTmuxWorktree(args) {
         error: `Error: ${errorMessage(error49)}`
       };
     }
-    repoName = basename47(findCanonicalGitRoot(getCwd()) ?? getCwd());
+    repoName = basename46(findCanonicalGitRoot(getCwd()) ?? getCwd());
     console.log(`Using worktree via hook: ${worktreeDir}`);
   } else {
     const repoRoot = findCanonicalGitRoot(getCwd());
@@ -503131,7 +503854,7 @@ async function execIntoTmuxWorktree(args) {
         error: "Error: --worktree requires a git repository"
       };
     }
-    repoName = basename47(repoRoot);
+    repoName = basename46(repoRoot);
     worktreeDir = worktreePathFor(repoRoot, worktreeName);
     try {
       const result = await getOrCreateWorktree(repoRoot, worktreeName, prNumber !== null ? { prNumber } : undefined);
@@ -503792,8 +504515,8 @@ function filterSwarmFieldsFromSchema(toolName2, schema) {
 }
 async function toolToAPISchema(tool, options) {
   const cacheKey = "inputJSONSchema" in tool && tool.inputJSONSchema ? `${tool.name}:${jsonStringify(tool.inputJSONSchema)}` : tool.name;
-  const cache4 = getToolSchemaCache();
-  let base2 = cache4.get(cacheKey);
+  const cache5 = getToolSchemaCache();
+  let base2 = cache5.get(cacheKey);
   if (!base2) {
     const strictToolsEnabled = checkStatsigFeatureGate_CACHED_MAY_BE_STALE("tengu_tool_pear");
     let input_schema = "inputJSONSchema" in tool && tool.inputJSONSchema ? tool.inputJSONSchema : zodToJsonSchema3(tool.inputSchema);
@@ -503816,7 +504539,7 @@ async function toolToAPISchema(tool, options) {
     if (getAPIProvider() === "firstParty" && isFirstPartyAnthropicBaseUrl() && (getFeatureValue_CACHED_MAY_BE_STALE("tengu_fgts", false) || isEnvTruthy(process.env.CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING))) {
       base2.eager_input_streaming = true;
     }
-    cache4.set(cacheKey, base2);
+    cache5.set(cacheKey, base2);
   }
   const schema = {
     name: base2.name,
@@ -504068,9 +504791,9 @@ function normalizeToolInput(tool, input, agentId) {
     }
     case BashTool.name: {
       const parsed = BashTool.inputSchema.parse(input);
-      const { command: command8, timeout, description } = parsed;
+      const { command: command9, timeout, description } = parsed;
       const cwd2 = getCwd();
-      let normalizedCommand = command8.replace(`cd ${cwd2} && `, "");
+      let normalizedCommand = command9.replace(`cd ${cwd2} && `, "");
       if (getPlatform() === "windows") {
         normalizedCommand = normalizedCommand.replace(`cd ${windowsPathToPosixPath(cwd2)} && `, "");
       }
@@ -506435,11 +507158,11 @@ class ChromeNativeHost {
     }
     log2(`Creating socket listener: ${this.socketPath}`);
     this.server = createServer7((socket) => this.handleMcpClient(socket));
-    await new Promise((resolve48, reject2) => {
+    await new Promise((resolve47, reject2) => {
       this.server.listen(this.socketPath, () => {
         log2("Socket server listening for connections");
         this.running = true;
-        resolve48();
+        resolve47();
       });
       this.server.on("error", (err2) => {
         log2("Socket server error:", err2);
@@ -506464,8 +507187,8 @@ class ChromeNativeHost {
     }
     this.mcpClients.clear();
     if (this.server) {
-      await new Promise((resolve48) => {
-        this.server.close(() => resolve48());
+      await new Promise((resolve47) => {
+        this.server.close(() => resolve47());
       });
       this.server = null;
     }
@@ -506686,8 +507409,8 @@ class ChromeMessageReader {
         return messageBytes.toString("utf-8");
       }
     }
-    return new Promise((resolve48) => {
-      this.pendingResolve = resolve48;
+    return new Promise((resolve47) => {
+      this.pendingResolve = resolve47;
       this.tryProcessMessage();
     });
   }
@@ -506895,8 +507618,8 @@ var require_help = __commonJS((exports) => {
       return argument.name();
     }
     longestSubcommandTermLength(cmd, helper) {
-      return helper.visibleCommands(cmd).reduce((max2, command8) => {
-        return Math.max(max2, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command8))));
+      return helper.visibleCommands(cmd).reduce((max2, command9) => {
+        return Math.max(max2, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command9))));
       }, 0);
     }
     longestOptionTermLength(cmd, helper) {
@@ -507488,8 +508211,8 @@ var require_command = __commonJS((exports) => {
     }
     _getCommandAndAncestors() {
       const result = [];
-      for (let command8 = this;command8; command8 = command8.parent) {
-        result.push(command8);
+      for (let command9 = this;command9; command9 = command9.parent) {
+        result.push(command9);
       }
       return result;
     }
@@ -507699,17 +508422,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       this.options.push(option);
     }
-    _registerCommand(command8) {
+    _registerCommand(command9) {
       const knownBy = (cmd) => {
         return [cmd.name()].concat(cmd.aliases());
       };
-      const alreadyUsed = knownBy(command8).find((name) => this._findCommand(name));
+      const alreadyUsed = knownBy(command9).find((name) => this._findCommand(name));
       if (alreadyUsed) {
         const existingCmd = knownBy(this._findCommand(alreadyUsed)).join("|");
-        const newCmd = knownBy(command8).join("|");
+        const newCmd = knownBy(command9).join("|");
         throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
       }
-      this.commands.push(command8);
+      this.commands.push(command9);
     }
     addOption(option) {
       this._registerOption(option);
@@ -508436,12 +509159,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
       let suggestion = "";
       if (flag.startsWith("--") && this._showSuggestionAfterError) {
         let candidateFlags = [];
-        let command8 = this;
+        let command9 = this;
         do {
-          const moreFlags = command8.createHelp().visibleOptions(command8).filter((option) => option.long).map((option) => option.long);
+          const moreFlags = command9.createHelp().visibleOptions(command9).filter((option) => option.long).map((option) => option.long);
           candidateFlags = candidateFlags.concat(moreFlags);
-          command8 = command8.parent;
-        } while (command8 && !command8._enablePositionalOptions);
+          command9 = command9.parent;
+        } while (command9 && !command9._enablePositionalOptions);
         suggestion = suggestSimilar(flag, candidateFlags);
       }
       const message = `error: unknown option '${flag}'${suggestion}`;
@@ -508461,10 +509184,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
       let suggestion = "";
       if (this._showSuggestionAfterError) {
         const candidateNames = [];
-        this.createHelp().visibleCommands(this).forEach((command8) => {
-          candidateNames.push(command8.name());
-          if (command8.alias())
-            candidateNames.push(command8.alias());
+        this.createHelp().visibleCommands(this).forEach((command9) => {
+          candidateNames.push(command9.name());
+          if (command9.alias())
+            candidateNames.push(command9.alias());
         });
         suggestion = suggestSimilar(unknownName, candidateNames);
       }
@@ -508505,18 +509228,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
     alias(alias) {
       if (alias === undefined)
         return this._aliases[0];
-      let command8 = this;
+      let command9 = this;
       if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
-        command8 = this.commands[this.commands.length - 1];
+        command9 = this.commands[this.commands.length - 1];
       }
-      if (alias === command8._name)
+      if (alias === command9._name)
         throw new Error("Command alias can't be the same as its name");
       const matchingCommand = this.parent?._findCommand(alias);
       if (matchingCommand) {
         const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
         throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
       }
-      command8._aliases.push(alias);
+      command9._aliases.push(alias);
       return this;
     }
     aliases(aliases) {
@@ -508600,7 +509323,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         write: outputContext.write,
         command: this
       };
-      this._getCommandAndAncestors().reverse().forEach((command8) => command8.emit("beforeAllHelp", eventContext));
+      this._getCommandAndAncestors().reverse().forEach((command9) => command9.emit("beforeAllHelp", eventContext));
       this.emit("beforeHelp", eventContext);
       let helpInformation = this.helpInformation({ error: outputContext.error });
       if (deprecatedCallback) {
@@ -508614,7 +509337,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this.emit(this._getHelpOption().long);
       }
       this.emit("afterHelp", eventContext);
-      this._getCommandAndAncestors().forEach((command8) => command8.emit("afterAllHelp", eventContext));
+      this._getCommandAndAncestors().forEach((command9) => command9.emit("afterAllHelp", eventContext));
     }
     helpOption(flags, description) {
       if (typeof flags === "boolean") {
@@ -509217,7 +509940,7 @@ async function startNodeRelay(wsUrl, authHeader, wsAuthHeader) {
       cleanupConn(states.get(sock));
     });
   });
-  return new Promise((resolve48, reject2) => {
+  return new Promise((resolve47, reject2) => {
     server.once("error", reject2);
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
@@ -509225,7 +509948,7 @@ async function startNodeRelay(wsUrl, authHeader, wsAuthHeader) {
         reject2(new Error("upstreamproxy: server has no TCP address"));
         return;
       }
-      resolve48({
+      resolve47({
         port: addr.port,
         stop: () => server.close()
       });
@@ -509730,7 +510453,7 @@ async function showInvalidConfigDialog({
     ...getBaseRenderOptions(false),
     theme: SAFE_ERROR_THEME_NAME
   };
-  await new Promise(async (resolve48) => {
+  await new Promise(async (resolve47) => {
     const {
       unmount
     } = await render(/* @__PURE__ */ jsx_dev_runtime356.jsxDEV(AppStateProvider, {
@@ -509740,7 +510463,7 @@ async function showInvalidConfigDialog({
           errorDescription: error49.message,
           onExit: () => {
             unmount();
-            resolve48();
+            resolve47();
             process.exit(1);
           },
           onReset: () => {
@@ -509749,7 +510472,7 @@ async function showInvalidConfigDialog({
               encoding: "utf8"
             });
             unmount();
-            resolve48();
+            resolve47();
             process.exit(0);
           }
         }, undefined, false, undefined, this)
@@ -511034,6 +511757,13 @@ var init_useLogMessages = __esm(() => {
 // src/bridge/bridgePermissionCallbacks.ts
 var init_bridgePermissionCallbacks = () => {};
 
+// src/bridge/bridgeUrlBuilder.ts
+function buildBridgeConnectUrl(environmentId, ingressUrl) {
+  const baseUrl = getClaudeAiBaseUrl(undefined, ingressUrl);
+  return `${baseUrl}/code?bridge=${environmentId}`;
+}
+var init_bridgeUrlBuilder = () => {};
+
 // src/bridge/inboundMessages.ts
 function extractInboundMessageFields(msg) {
   if (msg.type !== "user")
@@ -511101,7 +511831,7 @@ function buildSystemInitMessage(inputs) {
     betas: getSdkBetas(),
     claude_code_version: MACRO.VERSION,
     output_style: outputStyle2,
-    agents: inputs.agents.map((agent) => agent.agentType),
+    agents: inputs.agents.map((agent2) => agent2.agentType),
     skills: inputs.skills.filter((s) => s.userInvocable !== false).map((skill) => skill.name),
     plugins: inputs.plugins.map((plugin2) => ({
       name: plugin2.name,
@@ -511166,7 +511896,7 @@ var import_react199, jsx_dev_runtime364;
 var init_useReplBridge = __esm(() => {
   init_state();
   init_bridgePermissionCallbacks();
-  init_bridgeStatusUtil();
+  init_bridgeUrlBuilder();
   init_inboundMessages();
   init_replBridgeHandle();
   init_commands2();
@@ -515056,9 +515786,9 @@ function findFirstSubcommand(args, spec) {
   }
   return;
 }
-async function buildPrefix(command8, args, spec) {
-  const maxDepth = await calculateDepth(command8, args, spec);
-  const parts = [command8];
+async function buildPrefix(command9, args, spec) {
+  const maxDepth = await calculateDepth(command9, args, spec);
+  const parts = [command9];
   const hasSubcommands = !!spec?.subcommands?.length;
   let foundSubcommand = false;
   for (let i3 = 0;i3 < args.length; i3++) {
@@ -515066,7 +515796,7 @@ async function buildPrefix(command8, args, spec) {
     if (!arg || parts.length >= maxDepth)
       break;
     if (arg.startsWith("-")) {
-      if (arg === "-c" && ["python", "python3"].includes(command8.toLowerCase()))
+      if (arg === "-c" && ["python", "python3"].includes(command9.toLowerCase()))
         break;
       if (spec?.options) {
         const option = spec.options.find((opt) => Array.isArray(opt.name) ? opt.name.includes(arg) : opt.name === arg);
@@ -515091,9 +515821,9 @@ async function buildPrefix(command8, args, spec) {
   }
   return parts.join(" ");
 }
-async function calculateDepth(command8, args, spec) {
+async function calculateDepth(command9, args, spec) {
   const firstSubcommand = findFirstSubcommand(args, spec);
-  const commandLower = command8.toLowerCase();
+  const commandLower = command9.toLowerCase();
   const key2 = firstSubcommand ? `${commandLower} ${firstSubcommand.toLowerCase()}` : commandLower;
   if (DEPTH_RULES[key2])
     return DEPTH_RULES[key2];
@@ -515408,15 +516138,15 @@ var init_specs = __esm(() => {
 });
 
 // src/utils/bash/registry.ts
-async function loadFigSpec(command8) {
-  if (!command8 || command8.includes("/") || command8.includes("\\"))
+async function loadFigSpec(command9) {
+  if (!command9 || command9.includes("/") || command9.includes("\\"))
     return null;
-  if (command8.includes(".."))
+  if (command9.includes(".."))
     return null;
-  if (command8.startsWith("-") && command8 !== "-")
+  if (command9.startsWith("-") && command9 !== "-")
     return null;
   try {
-    const module = await import(`@withfig/autocomplete/build/${command8}.js`);
+    const module = await import(`@withfig/autocomplete/build/${command9}.js`);
     return module.default || module;
   } catch {
     return null;
@@ -515426,10 +516156,10 @@ var getCommandSpec;
 var init_registry2 = __esm(() => {
   init_memoize2();
   init_specs();
-  getCommandSpec = memoizeWithLRU(async (command8) => {
-    const spec = specs_default.find((s) => s.name === command8) || await loadFigSpec(command8) || null;
+  getCommandSpec = memoizeWithLRU(async (command9) => {
+    const spec = specs_default.find((s) => s.name === command9) || await loadFigSpec(command9) || null;
     return spec;
-  }, (command8) => command8);
+  }, (command9) => command9);
 });
 
 // src/utils/bash/prefix.ts
@@ -515438,10 +516168,10 @@ function isKnownSubcommand2(arg, spec) {
     return false;
   return spec.subcommands.some((sub) => Array.isArray(sub.name) ? sub.name.includes(arg) : sub.name === arg);
 }
-async function getCommandPrefixStatic(command8, recursionDepth = 0, wrapperCount = 0) {
+async function getCommandPrefixStatic(command9, recursionDepth = 0, wrapperCount = 0) {
   if (wrapperCount > 2 || recursionDepth > 10)
     return null;
-  const parsed = await parseCommand2(command8);
+  const parsed = await parseCommand2(command9);
   if (!parsed)
     return null;
   if (!parsed.commandNode) {
@@ -515464,12 +516194,12 @@ async function getCommandPrefixStatic(command8, recursionDepth = 0, wrapperCount
   const envPrefix = envVars.length ? `${envVars.join(" ")} ` : "";
   return { commandPrefix: prefix ? envPrefix + prefix : null };
 }
-async function handleWrapper(command8, args, recursionDepth, wrapperCount) {
-  const spec = await getCommandSpec(command8);
+async function handleWrapper(command9, args, recursionDepth, wrapperCount) {
+  const spec = await getCommandSpec(command9);
   if (spec?.args) {
     const commandArgIndex = toArray4(spec.args).findIndex((arg) => arg?.isCommand);
     if (commandArgIndex !== -1) {
-      const parts = [command8];
+      const parts = [command9];
       for (let i3 = 0;i3 < args.length && i3 <= commandArgIndex; i3++) {
         if (i3 === commandArgIndex) {
           const result2 = await getCommandPrefixStatic(args.slice(i3).join(" "), recursionDepth + 1, wrapperCount + 1);
@@ -515486,14 +516216,14 @@ async function handleWrapper(command8, args, recursionDepth, wrapperCount) {
   }
   const wrapped = args.find((arg) => !arg.startsWith("-") && !NUMERIC.test(arg) && !ENV_VAR.test(arg));
   if (!wrapped)
-    return command8;
+    return command9;
   const result = await getCommandPrefixStatic(args.slice(args.indexOf(wrapped)).join(" "), recursionDepth + 1, wrapperCount + 1);
-  return !result?.commandPrefix ? null : `${command8} ${result.commandPrefix}`;
+  return !result?.commandPrefix ? null : `${command9} ${result.commandPrefix}`;
 }
-async function getCompoundCommandPrefixesStatic(command8, excludeSubcommand) {
-  const subcommands = splitCommand_DEPRECATED(command8);
+async function getCompoundCommandPrefixesStatic(command9, excludeSubcommand) {
+  const subcommands = splitCommand_DEPRECATED(command9);
   if (subcommands.length <= 1) {
-    const result = await getCommandPrefixStatic(command8);
+    const result = await getCommandPrefixStatic(command9);
     return result?.commandPrefix ? [result.commandPrefix] : [];
   }
   const prefixes = [];
@@ -517174,7 +517904,7 @@ var init_FileEditToolDiff = __esm(() => {
 
 // src/hooks/useDiffInIDE.ts
 import { randomUUID as randomUUID34 } from "crypto";
-import { basename as basename49 } from "path";
+import { basename as basename48 } from "path";
 function useDiffInIDE({
   onChange,
   toolUseContext,
@@ -517185,7 +517915,7 @@ function useDiffInIDE({
   const isUnmounted = import_react211.useRef(false);
   const [hasError, setHasError] = import_react211.useState(false);
   const sha = import_react211.useMemo(() => randomUUID34().slice(0, 6), []);
-  const tabName = import_react211.useMemo(() => `✻ [Claude Code] ${basename49(filePath)} (${sha}) ⧉`, [filePath, sha]);
+  const tabName = import_react211.useMemo(() => `✻ [Claude Code] ${basename48(filePath)} (${sha}) ⧉`, [filePath, sha]);
   const shouldShowDiffInIDE = hasAccessToIDEExtensionDiffFeature(toolUseContext.options.mcpClients) && getGlobalConfig().diffTool === "auto" && !filePath.endsWith(".ipynb");
   const ideName = getConnectedIdeName(toolUseContext.options.mcpClients) ?? "IDE";
   async function showDiff() {
@@ -517367,7 +518097,7 @@ var init_useDiffInIDE = __esm(() => {
 });
 
 // src/components/ShowInIDEPrompt.tsx
-import { basename as basename50, relative as relative30 } from "path";
+import { basename as basename49, relative as relative30 } from "path";
 function ShowInIDEPrompt(t0) {
   const $3 = import_compiler_runtime295.c(36);
   const {
@@ -517424,7 +518154,7 @@ function ShowInIDEPrompt(t0) {
   }
   let t4;
   if ($3[5] !== filePath) {
-    t4 = basename50(filePath);
+    t4 = basename49(filePath);
     $3[5] = filePath;
     $3[6] = t4;
   } else {
@@ -517585,7 +518315,7 @@ var init_ShowInIDEPrompt = __esm(() => {
 
 // src/components/permissions/FilePermissionDialog/permissionOptions.tsx
 import { homedir as homedir36 } from "os";
-import { basename as basename51, join as join148, sep as sep39 } from "path";
+import { basename as basename50, join as join148, sep as sep39 } from "path";
 function isInClaudeFolder(filePath) {
   const absolutePath = expandPath(filePath);
   const claudeFolderPath = expandPath(`${getOriginalCwd()}/.claude`);
@@ -517667,7 +518397,7 @@ function getFilePermissionOptions({
       }
     } else {
       const dirPath = getDirectoryForPath(filePath);
-      const dirName = basename51(dirPath) || "this directory";
+      const dirName = basename50(dirPath) || "this directory";
       if (operationType === "read") {
         sessionLabel = /* @__PURE__ */ jsx_dev_runtime379.jsxDEV(ThemedText, {
           children: [
@@ -518166,7 +518896,7 @@ var init_FilePermissionDialog = __esm(() => {
 });
 
 // src/components/permissions/SedEditPermissionRequest/SedEditPermissionRequest.tsx
-import { basename as basename52, relative as relative32 } from "path";
+import { basename as basename51, relative as relative32 } from "path";
 function SedEditPermissionRequest(t0) {
   const $3 = import_compiler_runtime296.c(9);
   let props;
@@ -518342,7 +519072,7 @@ function SedEditPermissionRequestInner(t0) {
   }
   let t10;
   if ($3[16] !== filePath) {
-    t10 = basename52(filePath);
+    t10 = basename51(filePath);
     $3[16] = filePath;
     $3[17] = t10;
   } else {
@@ -518554,7 +519284,7 @@ var init_useShellPermissionFeedback = __esm(() => {
 });
 
 // src/components/permissions/shellPermissionHelpers.tsx
-import { basename as basename53, sep as sep40 } from "path";
+import { basename as basename52, sep as sep40 } from "path";
 function commandListDisplay(commands) {
   switch (commands.length) {
     case 0:
@@ -518605,7 +519335,7 @@ function commandListDisplayTruncated(commands) {
 function formatPathList(paths2) {
   if (paths2.length === 0)
     return "";
-  const names = paths2.map((p) => basename53(p) || p);
+  const names = paths2.map((p) => basename52(p) || p);
   if (names.length === 1) {
     return /* @__PURE__ */ jsx_dev_runtime382.jsxDEV(ThemedText, {
       children: [
@@ -518662,8 +519392,8 @@ function generateShellSuggestionsLabel(suggestions, shellToolName, commandTransf
   const shellCommands = [...new Set(shellRules.flatMap((rule) => {
     if (!rule.ruleContent)
       return [];
-    const command8 = permissionRuleExtractPrefix2(rule.ruleContent) ?? rule.ruleContent;
-    return commandTransform ? commandTransform(command8) : command8;
+    const command9 = permissionRuleExtractPrefix2(rule.ruleContent) ?? rule.ruleContent;
+    return commandTransform ? commandTransform(command9) : command9;
   }))];
   const hasDirectories = directories.length > 0;
   const hasReadPaths = readPaths.length > 0;
@@ -518671,7 +519401,7 @@ function generateShellSuggestionsLabel(suggestions, shellToolName, commandTransf
   if (hasReadPaths && !hasDirectories && !hasCommands) {
     if (readPaths.length === 1) {
       const firstPath = readPaths[0];
-      const dirName = basename53(firstPath) || firstPath;
+      const dirName = basename52(firstPath) || firstPath;
       return /* @__PURE__ */ jsx_dev_runtime382.jsxDEV(ThemedText, {
         children: [
           "Yes, allow reading from ",
@@ -518695,7 +519425,7 @@ function generateShellSuggestionsLabel(suggestions, shellToolName, commandTransf
   if (hasDirectories && !hasReadPaths && !hasCommands) {
     if (directories.length === 1) {
       const firstDir = directories[0];
-      const dirName = basename53(firstDir) || firstDir;
+      const dirName = basename52(firstDir) || firstDir;
       return /* @__PURE__ */ jsx_dev_runtime382.jsxDEV(ThemedText, {
         children: [
           "Yes, and always allow access to ",
@@ -518778,12 +519508,12 @@ var init_shellPermissionHelpers = __esm(() => {
 });
 
 // src/components/permissions/BashPermissionRequest/bashToolUseOptions.tsx
-function stripBashRedirections(command8) {
+function stripBashRedirections(command9) {
   const {
     commandWithoutRedirections,
     redirections
-  } = extractOutputRedirections(command8);
-  return redirections.length > 0 ? commandWithoutRedirections : command8;
+  } = extractOutputRedirections(command9);
+  return redirections.length > 0 ? commandWithoutRedirections : command9;
 }
 function bashToolUseOptions({
   suggestions = [],
@@ -518876,21 +519606,21 @@ function BashPermissionRequest(props) {
     verbose,
     workerBadge
   } = props;
-  let command8;
+  let command9;
   let description;
   let t0;
   if ($3[0] !== toolUseConfirm.input) {
     ({
-      command: command8,
+      command: command9,
       description
     } = BashTool.inputSchema.parse(toolUseConfirm.input));
-    t0 = parseSedEditCommand(command8);
+    t0 = parseSedEditCommand(command9);
     $3[0] = toolUseConfirm.input;
-    $3[1] = command8;
+    $3[1] = command9;
     $3[2] = description;
     $3[3] = t0;
   } else {
-    command8 = $3[1];
+    command9 = $3[1];
     description = $3[2];
     t0 = $3[3];
   }
@@ -518921,7 +519651,7 @@ function BashPermissionRequest(props) {
     return t12;
   }
   let t1;
-  if ($3[12] !== command8 || $3[13] !== description || $3[14] !== onDone || $3[15] !== onReject || $3[16] !== toolUseConfirm || $3[17] !== toolUseContext || $3[18] !== verbose || $3[19] !== workerBadge) {
+  if ($3[12] !== command9 || $3[13] !== description || $3[14] !== onDone || $3[15] !== onReject || $3[16] !== toolUseConfirm || $3[17] !== toolUseContext || $3[18] !== verbose || $3[19] !== workerBadge) {
     t1 = /* @__PURE__ */ jsx_dev_runtime383.jsxDEV(BashPermissionRequestInner, {
       toolUseConfirm,
       toolUseContext,
@@ -518929,10 +519659,10 @@ function BashPermissionRequest(props) {
       onReject,
       verbose,
       workerBadge,
-      command: command8,
+      command: command9,
       description
     }, undefined, false, undefined, this);
-    $3[12] = command8;
+    $3[12] = command9;
     $3[13] = description;
     $3[14] = onDone;
     $3[15] = onReject;
@@ -518953,7 +519683,7 @@ function BashPermissionRequestInner({
   onReject,
   verbose: _verbose,
   workerBadge,
-  command: command8,
+  command: command9,
   description
 }) {
   const [theme2] = useTheme();
@@ -518990,27 +519720,27 @@ function BashPermissionRequestInner({
     if (!isClassifierPermissionsEnabled())
       return;
     const abortController = new AbortController;
-    generateGenericDescription(command8, description, abortController.signal).then((generic) => {
+    generateGenericDescription(command9, description, abortController.signal).then((generic) => {
       if (generic && !abortController.signal.aborted) {
         setClassifierDescription(generic);
         setInitialClassifierDescriptionEmpty(false);
       }
     }).catch(() => {});
     return () => abortController.abort();
-  }, [command8, description]);
+  }, [command9, description]);
   const isCompound = toolUseConfirm.permissionResult.decisionReason?.type === "subcommandResults";
   const [editablePrefix, setEditablePrefix] = import_react216.useState(() => {
     if (isCompound) {
       const backendBashRules = extractRules("suggestions" in toolUseConfirm.permissionResult ? toolUseConfirm.permissionResult.suggestions : undefined).filter((r) => r.toolName === BashTool.name && r.ruleContent);
       return backendBashRules.length === 1 ? backendBashRules[0].ruleContent : undefined;
     }
-    const two = getSimpleCommandPrefix(command8);
+    const two = getSimpleCommandPrefix(command9);
     if (two)
       return `${two}:*`;
-    const one = getFirstWordPrefix(command8);
+    const one = getFirstWordPrefix(command9);
     if (one)
       return `${one}:*`;
-    return command8;
+    return command9;
   });
   const hasUserEditedPrefix = import_react216.useRef(false);
   const onEditablePrefixChange = import_react216.useCallback((value) => {
@@ -519021,7 +519751,7 @@ function BashPermissionRequestInner({
     if (isCompound)
       return;
     let cancelled = false;
-    getCompoundCommandPrefixesStatic(command8, (subcmd) => BashTool.isReadOnly({
+    getCompoundCommandPrefixesStatic(command9, (subcmd) => BashTool.isReadOnly({
       command: subcmd
     })).then((prefixes) => {
       if (cancelled || hasUserEditedPrefix.current)
@@ -519033,14 +519763,14 @@ function BashPermissionRequestInner({
     return () => {
       cancelled = true;
     };
-  }, [command8, isCompound]);
+  }, [command9, isCompound]);
   const [classifierWasChecking] = import_react216.useState(false);
   const {
     destructiveWarning: destructiveWarning_0,
     sandboxingEnabled: sandboxingEnabled_0,
     isSandboxed: isSandboxed_0
   } = import_react216.useMemo(() => {
-    const destructiveWarning = getFeatureValue_CACHED_MAY_BE_STALE("tengu_destructive_command_warning", false) ? getDestructiveCommandWarning(command8) : null;
+    const destructiveWarning = getFeatureValue_CACHED_MAY_BE_STALE("tengu_destructive_command_warning", false) ? getDestructiveCommandWarning(command9) : null;
     const sandboxingEnabled = SandboxManager2.isSandboxingEnabled();
     const isSandboxed = sandboxingEnabled && shouldUseSandbox(toolUseConfirm.input);
     return {
@@ -519048,7 +519778,7 @@ function BashPermissionRequestInner({
       sandboxingEnabled,
       isSandboxed
     };
-  }, [command8, toolUseConfirm.input]);
+  }, [command9, toolUseConfirm.input]);
   const unaryEvent = import_react216.useMemo(() => ({
     completion_type: "tool_use_single",
     language_name: "none"
@@ -519166,7 +519896,7 @@ function BashPermissionRequestInner({
           /* @__PURE__ */ jsx_dev_runtime383.jsxDEV(ThemedText, {
             dimColor: explainerState.visible,
             children: BashTool.renderToolUseMessage({
-              command: command8,
+              command: command9,
               description
             }, {
               theme: theme2,
@@ -520935,7 +521665,7 @@ function createSingleEditDiffConfig(filePath, oldString, newString, replaceAll)
 }
 
 // src/components/permissions/FileEditPermissionRequest/FileEditPermissionRequest.tsx
-import { basename as basename54, relative as relative33 } from "path";
+import { basename as basename53, relative as relative33 } from "path";
 function FileEditPermissionRequest(props) {
   const $3 = import_compiler_runtime301.c(51);
   const parseInput = _temp178;
@@ -520978,7 +521708,7 @@ function FileEditPermissionRequest(props) {
     t3 = " ";
     T0 = ThemedText;
     t0 = true;
-    t1 = basename54(file_path);
+    t1 = basename53(file_path);
     $3[0] = props.onDone;
     $3[1] = props.onReject;
     $3[2] = props.toolUseConfirm;
@@ -521405,7 +522135,7 @@ var init_FileWriteToolDiff = __esm(() => {
 });
 
 // src/components/permissions/FileWritePermissionRequest/FileWritePermissionRequest.tsx
-import { basename as basename55, relative as relative34 } from "path";
+import { basename as basename54, relative as relative34 } from "path";
 function FileWritePermissionRequest(props) {
   const $3 = import_compiler_runtime304.c(30);
   const parseInput = _temp181;
@@ -521472,7 +522202,7 @@ function FileWritePermissionRequest(props) {
   }
   let t9;
   if ($3[7] !== file_path) {
-    t9 = basename55(file_path);
+    t9 = basename54(file_path);
     $3[7] = file_path;
     $3[8] = t9;
   } else {
@@ -521877,7 +522607,7 @@ var init_NotebookEditToolDiff = __esm(() => {
 });
 
 // src/components/permissions/NotebookEditPermissionRequest/NotebookEditPermissionRequest.tsx
-import { basename as basename56 } from "path";
+import { basename as basename55 } from "path";
 function NotebookEditPermissionRequest(props) {
   const $3 = import_compiler_runtime306.c(52);
   const parseInput = _temp185;
@@ -521921,7 +522651,7 @@ function NotebookEditPermissionRequest(props) {
     t4 = " ";
     T0 = ThemedText;
     t0 = true;
-    t1 = basename56(notebook_path);
+    t1 = basename55(notebook_path);
     $3[0] = props.onDone;
     $3[1] = props.onReject;
     $3[2] = props.toolUseConfirm;
@@ -522076,9 +522806,9 @@ var init_NotebookEditPermissionRequest = __esm(() => {
 });
 
 // src/tools/PowerShellTool/destructiveCommandWarning.ts
-function getDestructiveCommandWarning2(command8) {
+function getDestructiveCommandWarning2(command9) {
   for (const { pattern, warning } of DESTRUCTIVE_PATTERNS2) {
-    if (pattern.test(command8)) {
+    if (pattern.test(command9)) {
       return warning;
     }
   }
@@ -522207,8 +522937,8 @@ async function extractPrefixFromElement(cmd) {
   }
   return prefix;
 }
-async function getCompoundCommandPrefixesStatic2(command8, excludeSubcommand) {
-  const parsed = await parsePowerShellCommandCached(command8);
+async function getCompoundCommandPrefixesStatic2(command9, excludeSubcommand) {
+  const parsed = await parsePowerShellCommandCached(command9);
   if (!parsed.valid) {
     return [];
   }
@@ -522365,7 +523095,7 @@ function PowerShellPermissionRequest(props) {
     workerBadge
   } = props;
   const {
-    command: command8,
+    command: command9,
     description
   } = PowerShellTool.inputSchema.parse(toolUseConfirm.input);
   const [theme2] = useTheme();
@@ -522394,14 +523124,14 @@ function PowerShellPermissionRequest(props) {
     onReject,
     explainerVisible: explainerState.visible
   });
-  const destructiveWarning = getFeatureValue_CACHED_MAY_BE_STALE("tengu_destructive_command_warning", false) ? getDestructiveCommandWarning2(command8) : null;
+  const destructiveWarning = getFeatureValue_CACHED_MAY_BE_STALE("tengu_destructive_command_warning", false) ? getDestructiveCommandWarning2(command9) : null;
   const [showPermissionDebug, setShowPermissionDebug] = import_react220.useState(false);
-  const [editablePrefix, setEditablePrefix] = import_react220.useState(command8.includes(`
-`) ? undefined : command8);
+  const [editablePrefix, setEditablePrefix] = import_react220.useState(command9.includes(`
+`) ? undefined : command9);
   const hasUserEditedPrefix = import_react220.useRef(false);
   import_react220.useEffect(() => {
     let cancelled = false;
-    getCompoundCommandPrefixesStatic2(command8, (element) => isAllowlistedCommand(element, element.text)).then((prefixes) => {
+    getCompoundCommandPrefixesStatic2(command9, (element) => isAllowlistedCommand(element, element.text)).then((prefixes) => {
       if (cancelled || hasUserEditedPrefix.current)
         return;
       if (prefixes.length > 0) {
@@ -522411,7 +523141,7 @@ function PowerShellPermissionRequest(props) {
     return () => {
       cancelled = true;
     };
-  }, [command8]);
+  }, [command9]);
   const onEditablePrefixChange = import_react220.useCallback((value) => {
     hasUserEditedPrefix.current = true;
     setEditablePrefix(value);
@@ -522516,7 +523246,7 @@ function PowerShellPermissionRequest(props) {
           /* @__PURE__ */ jsx_dev_runtime394.jsxDEV(ThemedText, {
             dimColor: explainerState.visible,
             children: PowerShellTool.renderToolUseMessage({
-              command: command8,
+              command: command9,
               description
             }, {
               theme: theme2,
@@ -526399,7 +527129,7 @@ var init_AutoUpdaterWrapper = __esm(() => {
 });
 
 // src/components/IdeStatusIndicator.tsx
-import { basename as basename57 } from "path";
+import { basename as basename56 } from "path";
 function IdeStatusIndicator(t0) {
   const $3 = import_compiler_runtime316.c(7);
   const {
@@ -526439,7 +527169,7 @@ function IdeStatusIndicator(t0) {
   if (ideSelection.filePath) {
     let t1;
     if ($3[3] !== ideSelection.filePath) {
-      t1 = basename57(ideSelection.filePath);
+      t1 = basename56(ideSelection.filePath);
       $3[3] = ideSelection.filePath;
       $3[4] = t1;
     } else {
@@ -527736,15 +528466,15 @@ function getZshCompletionCommand(prefix, completionType) {
   }
 }
 async function getCompletionsForShell(shellType, prefix, completionType, abortSignal) {
-  let command8;
+  let command9;
   if (shellType === "bash") {
-    command8 = getBashCompletionCommand(prefix, completionType);
+    command9 = getBashCompletionCommand(prefix, completionType);
   } else if (shellType === "zsh") {
-    command8 = getZshCompletionCommand(prefix, completionType);
+    command9 = getZshCompletionCommand(prefix, completionType);
   } else {
     return [];
   }
-  const shellCommand = await exec3(command8, abortSignal, "bash", {
+  const shellCommand = await exec3(command9, abortSignal, "bash", {
     timeout: SHELL_COMPLETION_TIMEOUT_MS
   });
   const result = await shellCommand.result;
@@ -527917,21 +528647,21 @@ function get2(obj, path26) {
   return arr ? list : list[0];
 }
 function norm(weight = 1, mantissa = 3) {
-  const cache4 = new Map;
+  const cache5 = new Map;
   const m2 = Math.pow(10, mantissa);
   return {
     get(value) {
       const numTokens = value.match(SPACE).length;
-      if (cache4.has(numTokens)) {
-        return cache4.get(numTokens);
+      if (cache5.has(numTokens)) {
+        return cache5.get(numTokens);
       }
       const norm2 = 1 / Math.pow(numTokens, 0.5 * weight);
       const n3 = parseFloat(Math.round(norm2 * m2) / m2);
-      cache4.set(numTokens, n3);
+      cache5.set(numTokens, n3);
       return n3;
     },
     clear() {
-      cache4.clear();
+      cache5.clear();
     }
   };
 }
@@ -529168,8 +529898,8 @@ function hasCommandArgs(input) {
     return false;
   return true;
 }
-function formatCommand(command8) {
-  return `/${command8} `;
+function formatCommand(command9) {
+  return `/${command9} `;
 }
 function getCommandId2(cmd) {
   const commandName = getCommandName(cmd);
@@ -529369,7 +530099,7 @@ var init_commandSuggestions = __esm(() => {
 // src/utils/suggestions/shellHistoryCompletion.ts
 async function getShellHistoryCommands() {
   const now2 = Date.now();
-  if (shellHistoryCache && now2 - shellHistoryCacheTimestamp < CACHE_TTL_MS5) {
+  if (shellHistoryCache && now2 - shellHistoryCacheTimestamp < CACHE_TTL_MS6) {
     return shellHistoryCache;
   }
   const commands = [];
@@ -529377,10 +530107,10 @@ async function getShellHistoryCommands() {
   try {
     for await (const entry of getHistory()) {
       if (entry.display && entry.display.startsWith("!")) {
-        const command8 = entry.display.slice(1).trim();
-        if (command8 && !seen.has(command8)) {
-          seen.add(command8);
-          commands.push(command8);
+        const command9 = entry.display.slice(1).trim();
+        if (command9 && !seen.has(command9)) {
+          seen.add(command9);
+          commands.push(command9);
         }
       }
       if (commands.length >= 50) {
@@ -529394,15 +530124,15 @@ async function getShellHistoryCommands() {
   shellHistoryCacheTimestamp = now2;
   return commands;
 }
-function prependToShellHistoryCache(command8) {
+function prependToShellHistoryCache(command9) {
   if (!shellHistoryCache) {
     return;
   }
-  const idx = shellHistoryCache.indexOf(command8);
+  const idx = shellHistoryCache.indexOf(command9);
   if (idx !== -1) {
     shellHistoryCache.splice(idx, 1);
   }
-  shellHistoryCache.unshift(command8);
+  shellHistoryCache.unshift(command9);
 }
 async function getShellHistoryCompletion(input) {
   if (!input || input.length < 2) {
@@ -529413,17 +530143,17 @@ async function getShellHistoryCompletion(input) {
     return null;
   }
   const commands = await getShellHistoryCommands();
-  for (const command8 of commands) {
-    if (command8.startsWith(input) && command8 !== input) {
+  for (const command9 of commands) {
+    if (command9.startsWith(input) && command9 !== input) {
       return {
-        fullCommand: command8,
-        suffix: command8.slice(input.length)
+        fullCommand: command9,
+        suffix: command9.slice(input.length)
       };
     }
   }
   return null;
 }
-var shellHistoryCache = null, shellHistoryCacheTimestamp = 0, CACHE_TTL_MS5 = 60000;
+var shellHistoryCache = null, shellHistoryCacheTimestamp = 0, CACHE_TTL_MS6 = 60000;
 var init_shellHistoryCompletion = __esm(() => {
   init_history();
   init_debug();
@@ -529507,7 +530237,7 @@ function mcpQueryFor(searchToken) {
 function findReusableCacheEntry(mcpQuery, searchToken) {
   let best;
   let bestLen = 0;
-  for (const [key2, channels] of cache4) {
+  for (const [key2, channels] of cache5) {
     if (mcpQuery.startsWith(key2) && key2.length > bestLen && channels.some((c6) => c6.startsWith(searchToken))) {
       best = channels;
       bestLen = key2.length;
@@ -529520,7 +530250,7 @@ async function getSlackChannelSuggestions(clients, searchToken) {
     return [];
   const mcpQuery = mcpQueryFor(searchToken);
   const lower = searchToken.toLowerCase();
-  let channels = cache4.get(mcpQuery) ?? findReusableCacheEntry(mcpQuery, lower);
+  let channels = cache5.get(mcpQuery) ?? findReusableCacheEntry(mcpQuery, lower);
   if (!channels) {
     if (inflightQuery === mcpQuery && inflightPromise) {
       channels = await inflightPromise;
@@ -529528,7 +530258,7 @@ async function getSlackChannelSuggestions(clients, searchToken) {
       inflightQuery = mcpQuery;
       inflightPromise = fetchChannels(clients, mcpQuery);
       channels = await inflightPromise;
-      cache4.set(mcpQuery, channels);
+      cache5.set(mcpQuery, channels);
       const before = knownChannels.size;
       for (const c6 of channels)
         knownChannels.add(c6);
@@ -529536,8 +530266,8 @@ async function getSlackChannelSuggestions(clients, searchToken) {
         knownChannelsVersion++;
         knownChannelsChanged.emit();
       }
-      if (cache4.size > 50) {
-        cache4.delete(cache4.keys().next().value);
+      if (cache5.size > 50) {
+        cache5.delete(cache5.keys().next().value);
       }
       if (inflightQuery === mcpQuery) {
         inflightQuery = null;
@@ -529550,12 +530280,12 @@ async function getSlackChannelSuggestions(clients, searchToken) {
     displayText: `#${c6}`
   }));
 }
-var SLACK_SEARCH_TOOL = "slack_search_channels", cache4, knownChannels, knownChannelsVersion = 0, knownChannelsChanged, subscribeKnownChannels, inflightQuery = null, inflightPromise = null, resultsEnvelopeSchema;
+var SLACK_SEARCH_TOOL = "slack_search_channels", cache5, knownChannels, knownChannelsVersion = 0, knownChannelsChanged, subscribeKnownChannels, inflightQuery = null, inflightPromise = null, resultsEnvelopeSchema;
 var init_slackChannelSuggestions = __esm(() => {
   init_zod3();
   init_debug();
   init_slowOperations();
-  cache4 = new Map;
+  cache5 = new Map;
   knownChannels = new Set;
   knownChannelsChanged = createSignal();
   subscribeKnownChannels = knownChannelsChanged.subscribe;
@@ -529563,7 +530293,7 @@ var init_slackChannelSuggestions = __esm(() => {
 });
 
 // src/hooks/unifiedSuggestions.ts
-import { basename as basename58 } from "path";
+import { basename as basename57 } from "path";
 function createSuggestionFromSource(source) {
   switch (source.type) {
     case "file":
@@ -529595,18 +530325,18 @@ function generateAgentSuggestions(agents2, query3, showOnEmpty = false) {
     return [];
   }
   try {
-    const agentSources = agents2.map((agent) => ({
+    const agentSources = agents2.map((agent2) => ({
       type: "agent",
-      displayText: `${agent.agentType} (agent)`,
-      description: truncateDescription(agent.whenToUse),
-      agentType: agent.agentType,
-      color: getAgentColor(agent.agentType)
+      displayText: `${agent2.agentType} (agent)`,
+      description: truncateDescription(agent2.whenToUse),
+      agentType: agent2.agentType,
+      color: getAgentColor(agent2.agentType)
     }));
     if (!query3) {
       return agentSources;
     }
     const queryLower = query3.toLowerCase();
-    return agentSources.filter((agent) => agent.agentType.toLowerCase().includes(queryLower) || agent.displayText.toLowerCase().includes(queryLower));
+    return agentSources.filter((agent2) => agent2.agentType.toLowerCase().includes(queryLower) || agent2.displayText.toLowerCase().includes(queryLower));
   } catch (error49) {
     logError2(error49);
     return [];
@@ -529625,7 +530355,7 @@ async function generateUnifiedSuggestions(query3, mcpResources, agents2, showOnE
     displayText: suggestion.displayText,
     description: suggestion.description,
     path: suggestion.displayText,
-    filename: basename58(suggestion.displayText),
+    filename: basename57(suggestion.displayText),
     score: suggestion.metadata?.score
   }));
   const mcpSources = Object.values(mcpResources).flat().map((resource) => ({
@@ -530839,7 +531569,7 @@ var init_AutoModeOptInDialog = __esm(() => {
 });
 
 // src/components/BridgeDialog.tsx
-import { basename as basename59 } from "path";
+import { basename as basename58 } from "path";
 function BridgeDialog(t0) {
   const $3 = import_compiler_runtime321.c(87);
   const {
@@ -530862,7 +531592,7 @@ function BridgeDialog(t0) {
   const [branchName, setBranchName] = import_react243.useState("");
   let t1;
   if ($3[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = basename59(getOriginalCwd());
+    t1 = basename58(getOriginalCwd());
     $3[0] = t1;
   } else {
     t1 = $3[0];
@@ -536013,7 +536743,7 @@ var init_standaloneAgent = __esm(() => {
 function useSwarmBanner() {
   const teamContext = useAppState((s) => s.teamContext);
   const standaloneAgentContext = useAppState((s) => s.standaloneAgentContext);
-  const agent = useAppState((s) => s.agent);
+  const agent2 = useAppState((s) => s.agent);
   useAppState((s) => s.viewingAgentTaskId);
   const store = useAppStateStore();
   const [insideTmux, setInsideTmux] = React141.useState(null);
@@ -536072,10 +536802,10 @@ function useSwarmBanner() {
       bgColor: toThemeColor(standaloneColor)
     };
   }
-  if (agent) {
-    const agentDef = state2.agentDefinitions.activeAgents.find((a2) => a2.agentType === agent);
+  if (agent2) {
+    const agentDef = state2.agentDefinitions.activeAgents.find((a2) => a2.agentType === agent2);
     return {
-      text: agent,
+      text: agent2,
       bgColor: toThemeColor(agentDef?.color, "promptBorder")
     };
   }
@@ -541353,7 +542083,7 @@ var init_coordinatorHandler = __esm(() => {
 });
 
 // src/hooks/toolPermission/PermissionContext.ts
-function createResolveOnce(resolve48) {
+function createResolveOnce(resolve47) {
   let claimed = false;
   let delivered = false;
   return {
@@ -541362,7 +542092,7 @@ function createResolveOnce(resolve48) {
         return;
       delivered = true;
       claimed = true;
-      resolve48(value);
+      resolve47(value);
     },
     isResolved() {
       return claimed;
@@ -541407,11 +542137,11 @@ function createPermissionContext(tool, input, toolUseContext, assistantMessage,
       setToolPermissionContext(applyPermissionUpdates(appState.toolPermissionContext, updates));
       return updates.some((update) => supportsPersistence(update.destination));
     },
-    resolveIfAborted(resolve48) {
+    resolveIfAborted(resolve47) {
       if (!toolUseContext.abortController.signal.aborted)
         return false;
       this.logCancelled();
-      resolve48(this.cancelAndAbort(undefined, true));
+      resolve47(this.cancelAndAbort(undefined, true));
       return true;
     },
     cancelAndAbort(feedback2, isAbort, contentBlocks) {
@@ -541527,7 +542257,7 @@ var init_PermissionContext = __esm(() => {
 
 // src/hooks/toolPermission/handlers/interactiveHandler.ts
 import { randomUUID as randomUUID40 } from "crypto";
-function handleInteractivePermission(params, resolve48) {
+function handleInteractivePermission(params, resolve47) {
   const {
     ctx,
     description,
@@ -541536,7 +542266,7 @@ function handleInteractivePermission(params, resolve48) {
     bridgeCallbacks,
     channelCallbacks
   } = params;
-  const { resolve: resolveOnce, isResolved, claim } = createResolveOnce(resolve48);
+  const { resolve: resolveOnce, isResolved, claim } = createResolveOnce(resolve47);
   let userInteracted = false;
   let checkmarkTransitionTimer;
   let checkmarkAbortHandler;
@@ -541723,8 +542453,8 @@ async function handleSwarmWorkerPermission(params) {
       ...prev,
       pendingWorkerRequest: null
     }));
-    const decision = await new Promise((resolve48) => {
-      const { resolve: resolveOnce, claim } = createResolveOnce(resolve48);
+    const decision = await new Promise((resolve47) => {
+      const { resolve: resolveOnce, claim } = createResolveOnce(resolve47);
       const request = createPermissionRequest({
         toolName: ctx.tool.name,
         toolUseId: ctx.toolUseID,
@@ -541790,15 +542520,15 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
   const $3 = import_compiler_runtime339.c(3);
   let t0;
   if ($3[0] !== setToolPermissionContext || $3[1] !== setToolUseConfirmQueue) {
-    t0 = async (tool, input, toolUseContext, assistantMessage, toolUseID, forceDecision) => new Promise((resolve48) => {
+    t0 = async (tool, input, toolUseContext, assistantMessage, toolUseID, forceDecision) => new Promise((resolve47) => {
       const ctx = createPermissionContext(tool, input, toolUseContext, assistantMessage, toolUseID, setToolPermissionContext, createPermissionQueueOps(setToolUseConfirmQueue));
-      if (ctx.resolveIfAborted(resolve48)) {
+      if (ctx.resolveIfAborted(resolve47)) {
         return;
       }
       const decisionPromise = forceDecision !== undefined ? Promise.resolve(forceDecision) : hasPermissionsToUseTool(tool, input, toolUseContext, assistantMessage, toolUseID);
       return decisionPromise.then(async (result) => {
         if (result.behavior === "allow") {
-          if (ctx.resolveIfAborted(resolve48)) {
+          if (ctx.resolveIfAborted(resolve47)) {
             return;
           }
           if (false) {}
@@ -541806,7 +542536,7 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
             decision: "accept",
             source: "config"
           });
-          resolve48(ctx.buildAllow(result.updatedInput ?? input, {
+          resolve47(ctx.buildAllow(result.updatedInput ?? input, {
             decisionReason: result.decisionReason
           }));
           return;
@@ -541817,7 +542547,7 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
           toolPermissionContext: appState.toolPermissionContext,
           tools: toolUseContext.options.tools
         });
-        if (ctx.resolveIfAborted(resolve48)) {
+        if (ctx.resolveIfAborted(resolve47)) {
           return;
         }
         switch (result.behavior) {
@@ -541833,7 +542563,7 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
               source: "config"
             });
             if (false) {}
-            resolve48(result);
+            resolve47(result);
             return;
           }
           case "ask": {
@@ -541846,11 +542576,11 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
                 permissionMode: appState.toolPermissionContext.mode
               });
               if (coordinatorDecision) {
-                resolve48(coordinatorDecision);
+                resolve47(coordinatorDecision);
                 return;
               }
             }
-            if (ctx.resolveIfAborted(resolve48)) {
+            if (ctx.resolveIfAborted(resolve47)) {
               return;
             }
             const swarmDecision = await handleSwarmWorkerPermission({
@@ -541861,7 +542591,7 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
               suggestions: result.suggestions
             });
             if (swarmDecision) {
-              resolve48(swarmDecision);
+              resolve47(swarmDecision);
               return;
             }
             if (false) {}
@@ -541872,7 +542602,7 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
               awaitAutomatedChecksBeforeDialog: appState.toolPermissionContext.awaitAutomatedChecksBeforeDialog,
               bridgeCallbacks: undefined,
               channelCallbacks: undefined
-            }, resolve48);
+            }, resolve47);
             return;
           }
         }
@@ -541880,10 +542610,10 @@ function useCanUseTool(setToolUseConfirmQueue, setToolPermissionContext) {
         if (error49 instanceof AbortError || error49 instanceof APIUserAbortError) {
           logForDebugging(`Permission check threw ${error49.constructor.name} for tool=${tool.name}: ${error49.message}`);
           ctx.logCancelled();
-          resolve48(ctx.cancelAndAbort(undefined, true));
+          resolve47(ctx.cancelAndAbort(undefined, true));
         } else {
           logError2(error49);
-          resolve48(ctx.cancelAndAbort(undefined, true));
+          resolve47(ctx.cancelAndAbort(undefined, true));
         }
       }).finally(() => {
         clearClassifierChecking(toolUseID);
@@ -543555,7 +544285,7 @@ __export(exports_asciicast, {
   _resetRecordingStateForTesting: () => _resetRecordingStateForTesting
 });
 import { appendFile as appendFile7, rename as rename12 } from "fs/promises";
-import { basename as basename60, dirname as dirname63, join as join151 } from "path";
+import { basename as basename59, dirname as dirname63, join as join151 } from "path";
 function getRecordFilePath() {
   if (recordingState.filePath !== null) {
     return recordingState.filePath;
@@ -543601,8 +544331,8 @@ async function renameRecordingForSession() {
     return;
   }
   await recorder?.flush();
-  const oldName = basename60(oldPath);
-  const newName = basename60(newPath);
+  const oldName = basename59(oldPath);
+  const newName = basename59(newPath);
   try {
     await rename12(oldPath, newPath);
     recordingState.filePath = newPath;
@@ -543763,7 +544493,7 @@ function restoreAgentFromSession(agentSetting, currentAgentDefinition, agentDefi
     setMainThreadAgentType(undefined);
     return { agentDefinition: undefined, agentType: undefined };
   }
-  const resumedAgent = agentDefinitions.activeAgents.find((agent) => agent.agentType === agentSetting);
+  const resumedAgent = agentDefinitions.activeAgents.find((agent2) => agent2.agentType === agentSetting);
   if (!resumedAgent) {
     logForDebugging(`Resumed session had agent "${agentSetting}" but it is no longer available. Using default behavior.`);
     setMainThreadAgentType(undefined);
@@ -548359,7 +549089,7 @@ class StructuredIO {
       });
     }
     try {
-      return await new Promise((resolve49, reject2) => {
+      return await new Promise((resolve48, reject2) => {
         this.pendingRequests.set(requestId, {
           request: {
             type: "control_request",
@@ -548367,7 +549097,7 @@ class StructuredIO {
             request
           },
           resolve: (result) => {
-            resolve49(result);
+            resolve48(result);
           },
           reject: reject2,
           schema
@@ -549278,12 +550008,12 @@ var init_useLspInitializationNotification = __esm(() => {
 });
 
 // src/utils/binaryCheck.ts
-async function isBinaryInstalled(command8) {
-  if (!command8 || !command8.trim()) {
+async function isBinaryInstalled(command9) {
+  if (!command9 || !command9.trim()) {
     logForDebugging("[binaryCheck] Empty command provided, returning false");
     return false;
   }
-  const trimmedCommand = command8.trim();
+  const trimmedCommand = command9.trim();
   const cached3 = binaryCache.get(trimmedCommand);
   if (cached3 !== undefined) {
     logForDebugging(`[binaryCheck] Cache hit for '${trimmedCommand}': ${cached3}`);
@@ -549336,13 +550066,13 @@ function isRecord2(value) {
 }
 function extractFromServerConfigRecord(serverConfigs) {
   const extensions = new Set;
-  let command8 = null;
+  let command9 = null;
   for (const [_serverName, config5] of Object.entries(serverConfigs)) {
     if (!isRecord2(config5)) {
       continue;
     }
-    if (!command8 && typeof config5.command === "string") {
-      command8 = config5.command;
+    if (!command9 && typeof config5.command === "string") {
+      command9 = config5.command;
     }
     const extMapping = config5.extensionToLanguage;
     if (isRecord2(extMapping)) {
@@ -549351,10 +550081,10 @@ function extractFromServerConfigRecord(serverConfigs) {
       }
     }
   }
-  if (!command8 || extensions.size === 0) {
+  if (!command9 || extensions.size === 0) {
     return null;
   }
-  return { extensions, command: command8 };
+  return { extensions, command: command9 };
 }
 async function getLspPluginsFromMarketplaces() {
   const result = new Map;
@@ -549490,7 +550220,7 @@ function usePluginRecommendationBase() {
   const isCheckingRef = React148.useRef(false);
   let t0;
   if ($3[0] !== recommendation) {
-    t0 = (resolve49) => {
+    t0 = (resolve48) => {
       if (getIsRemoteMode()) {
         return;
       }
@@ -549501,7 +550231,7 @@ function usePluginRecommendationBase() {
         return;
       }
       isCheckingRef.current = true;
-      resolve49().then((rec) => {
+      resolve48().then((rec) => {
         if (rec) {
           setRecommendation(rec);
         }
@@ -550377,7 +551107,7 @@ var init_usePluginAutoupdateNotification = __esm(() => {
 });
 
 // src/utils/plugins/reconciler.ts
-import { isAbsolute as isAbsolute29, resolve as resolve49 } from "path";
+import { isAbsolute as isAbsolute29, resolve as resolve48 } from "path";
 function diffMarketplaces(declared, materialized, opts) {
   const missing = [];
   const sourceChanged = [];
@@ -550490,7 +551220,7 @@ function normalizeSource(source, projectRoot) {
     const canonicalRoot = findCanonicalGitRoot(base2);
     return {
       ...source,
-      path: resolve49(canonicalRoot ?? base2, source.path)
+      path: resolve48(canonicalRoot ?? base2, source.path)
     };
   }
   return source;
@@ -551703,8 +552433,8 @@ function isSessionContainerCompatible(messages) {
       }
       if (toolName2 === BASH_TOOL_NAME) {
         const input = block.input;
-        const command8 = input?.command || "";
-        if (EXTERNAL_COMMAND_PATTERNS.some((p) => p.test(command8))) {
+        const command9 = input?.command || "";
+        if (EXTERNAL_COMMAND_PATTERNS.some((p) => p.test(command9))) {
           return false;
         }
       }
@@ -553768,12 +554498,12 @@ Error: sandbox required but unavailable: ${reason}
     return () => unregisterLeaderSetToolPermissionContext();
   }, [setToolPermissionContext]);
   const canUseTool = useCanUseTool_default(setToolUseConfirmQueue, setToolPermissionContext);
-  const requestPrompt = import_react319.useCallback((title, toolInputSummary) => (request) => new Promise((resolve50, reject2) => {
+  const requestPrompt = import_react319.useCallback((title, toolInputSummary) => (request) => new Promise((resolve49, reject2) => {
     setPromptQueue((prev) => [...prev, {
       request,
       title,
       toolInputSummary,
-      resolve: resolve50,
+      resolve: resolve49,
       reject: reject2
     }]);
   }), []);
@@ -554566,22 +555296,22 @@ Error: sandbox required but unavailable: ${reason}
     helpers2.clearBuffer();
   }, [setAppState, setInputValue, getToolUseContext, canUseTool, mainLoopModel, addNotification]);
   const handleAutoRunIssue = import_react319.useCallback(() => {
-    const command8 = autoRunIssueReason ? getAutoRunCommand(autoRunIssueReason) : "/issue";
+    const command9 = autoRunIssueReason ? getAutoRunCommand(autoRunIssueReason) : "/issue";
     setAutoRunIssueReason(null);
-    onSubmit(command8, {
+    onSubmit(command9, {
       setCursorOffset: () => {},
       clearBuffer: () => {},
       resetHistory: () => {}
     }).catch((err2) => {
-      logForDebugging(`Auto-run ${command8} failed: ${errorMessage(err2)}`);
+      logForDebugging(`Auto-run ${command9} failed: ${errorMessage(err2)}`);
     });
   }, [onSubmit, autoRunIssueReason]);
   const handleCancelAutoRunIssue = import_react319.useCallback(() => {
     setAutoRunIssueReason(null);
   }, []);
   const handleSurveyRequestFeedback = import_react319.useCallback(() => {
-    const command8 = "/feedback";
-    onSubmit(command8, {
+    const command9 = "/feedback";
+    onSubmit(command9, {
       setCursorOffset: () => {},
       clearBuffer: () => {},
       resetHistory: () => {}
@@ -556665,8 +557395,8 @@ async function handleMcpjsonServerApprovals(root2) {
   if (pendingServers.length === 0) {
     return;
   }
-  await new Promise((resolve50) => {
-    const done = () => void resolve50();
+  await new Promise((resolve49) => {
+    const done = () => void resolve49();
     if (pendingServers.length === 1 && pendingServers[0] !== undefined) {
       const serverName = pendingServers[0];
       root2.render(/* @__PURE__ */ jsx_dev_runtime470.jsxDEV(AppStateProvider, {
@@ -559104,8 +559834,8 @@ function _temp443(command_0) {
 function _temp359(tool_0) {
   return tool_0 === BASH_TOOL_NAME || tool_0.startsWith(BASH_TOOL_NAME + "(");
 }
-function _temp2102(command8) {
-  return command8.type === "prompt" && command8.loadedFrom === "commands_DEPRECATED" && (command8.source === "projectSettings" || command8.source === "localSettings") && command8.allowedTools?.some(_temp303);
+function _temp2102(command9) {
+  return command9.type === "prompt" && command9.loadedFrom === "commands_DEPRECATED" && (command9.source === "projectSettings" || command9.source === "localSettings") && command9.allowedTools?.some(_temp303);
 }
 function _temp303(tool) {
   return tool === BASH_TOOL_NAME || tool.startsWith(BASH_TOOL_NAME + "(");
@@ -559445,8 +560175,8 @@ function completeOnboarding() {
   }));
 }
 function showDialog(root2, renderer) {
-  return new Promise((resolve50) => {
-    const done = (result) => void resolve50(result);
+  return new Promise((resolve49) => {
+    const done = (result) => void resolve49(result);
     root2.render(renderer(done));
   });
 }
@@ -560901,7 +561631,7 @@ function _temp307() {
 function CrossProjectMessage(t0) {
   const $3 = import_compiler_runtime384.c(8);
   const {
-    command: command8
+    command: command9
   } = t0;
   let t1;
   if ($3[0] === Symbol.for("react.memo_cache_sentinel")) {
@@ -560930,7 +561660,7 @@ function CrossProjectMessage(t0) {
     t3 = $3[2];
   }
   let t4;
-  if ($3[3] !== command8) {
+  if ($3[3] !== command9) {
     t4 = /* @__PURE__ */ jsx_dev_runtime485.jsxDEV(ThemedBox_default, {
       flexDirection: "column",
       children: [
@@ -560938,12 +561668,12 @@ function CrossProjectMessage(t0) {
         /* @__PURE__ */ jsx_dev_runtime485.jsxDEV(ThemedText, {
           children: [
             " ",
-            command8
+            command9
           ]
         }, undefined, true, undefined, this)
       ]
     }, undefined, true, undefined, this);
-    $3[3] = command8;
+    $3[3] = command9;
     $3[4] = t4;
   } else {
     t4 = $3[4];
@@ -561073,11 +561803,11 @@ async function isCodeGraphInstalled() {
   if (cachedResult !== null)
     return cachedResult;
   if (checkStarted) {
-    await new Promise((resolve50) => {
+    await new Promise((resolve49) => {
       const check3 = setInterval(() => {
         if (cachedResult !== null) {
           clearInterval(check3);
-          resolve50();
+          resolve49();
         }
       }, 50);
     });
@@ -561103,7 +561833,7 @@ var init_codegraphCheck = __esm(() => {
 
 // src/plugins/bundled/eccBuiltin.ts
 import { readdirSync as readdirSync6, readFileSync as readFileSync18, existsSync as existsSync11 } from "fs";
-import { join as join155, dirname as dirname67, basename as basename61, extname as extname17 } from "path";
+import { join as join155, dirname as dirname67, basename as basename60, extname as extname17 } from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 function resolveSeedDir() {
   if (process.env.CLAUDE_CODE_PLUGIN_SEED_DIR) {
@@ -561161,7 +561891,7 @@ var init_eccBuiltin = __esm(() => {
         for (const file2 of files3) {
           if (extname17(file2) !== ".md")
             continue;
-          const name = basename61(file2, ".md");
+          const name = basename60(file2, ".md");
           const content = readFileSync18(join155(ECC_COMMANDS_DIR, file2), "utf-8");
           registerMarkdownSkill(name, join155(ECC_COMMANDS_DIR, file2), content, "Custom command");
           count4++;
@@ -561214,9 +561944,9 @@ var init_bundled = __esm(() => {
 });
 
 // src/services/plugins/pluginCliCommands.ts
-function handlePluginCommandError(error49, command8, plugin2) {
+function handlePluginCommandError(error49, command9, plugin2) {
   logError2(error49);
-  const operation = plugin2 ? `${command8} plugin "${plugin2}"` : command8 === "disable-all" ? "disable all plugins" : `${command8} plugins`;
+  const operation = plugin2 ? `${command9} plugin "${plugin2}"` : command9 === "disable-all" ? "disable all plugins" : `${command9} plugins`;
   console.error(`${figures_default.cross} Failed to ${operation}: ${errorMessage(error49)}`);
   const telemetryFields = plugin2 ? (() => {
     const { name, marketplace } = parsePluginIdentifier(plugin2);
@@ -561229,7 +561959,7 @@ function handlePluginCommandError(error49, command8, plugin2) {
     };
   })() : {};
   logEvent("tengu_plugin_command_failed", {
-    command: command8,
+    command: command9,
     error_category: classifyPluginCommandError(error49),
     ...telemetryFields
   });
@@ -563713,23 +564443,25 @@ var init_migrateAutoUpdatesToSettings = __esm(() => {
 });
 
 // src/migrations/migrateBypassPermissionsAcceptedToSettings.ts
-function migrateBypassPermissionsAcceptedToSettings() {
+async function migrateBypassPermissionsAcceptedToSettings() {
   const globalConfig2 = getGlobalConfig();
   if (!globalConfig2.bypassPermissionsModeAccepted) {
     return;
   }
   try {
     if (!hasSkipDangerousModePermissionPrompt()) {
-      const effectiveSkip = ["userSettings", "localSettings"].map((source) => getSettingsForSource(source)?.skipDangerousModePermissionPrompt).find((value) => value !== undefined);
-      const userExplicitlyOptedOut = effectiveSkip === false;
+      const userExplicitlyOptedOut = getSettingsForSource("userSettings")?.skipDangerousModePermissionPrompt === false || getSettingsForSource("projectSettings")?.skipDangerousModePermissionPrompt === false || getSettingsForSource("localSettings")?.skipDangerousModePermissionPrompt === false || getSettingsForSource("flagSettings")?.skipDangerousModePermissionPrompt === false || getSettingsForSource("policySettings")?.skipDangerousModePermissionPrompt === false;
       if (!userExplicitlyOptedOut) {
-        updateSettingsForSource("userSettings", {
+        const result = await updateSettingsForSource("userSettings", {
           skipDangerousModePermissionPrompt: true
         });
+        if (result.error) {
+          throw result.error;
+        }
       }
     }
     logEvent("tengu_migrate_bypass_permissions_accepted", {});
-    saveGlobalConfig((current) => {
+    await saveGlobalConfig((current) => {
       if (!("bypassPermissionsModeAccepted" in current))
         return current;
       const { bypassPermissionsModeAccepted: _2, ...updatedConfig } = current;
@@ -563748,7 +564480,8 @@ var init_migrateBypassPermissionsAcceptedToSettings = __esm(() => {
 });
 
 // src/migrations/migrateEnableAllProjectMcpServersToSettings.ts
-function migrateEnableAllProjectMcpServersToSettings() {
+import { createHash as createHash21 } from "crypto";
+async function migrateEnableAllProjectMcpServersToSettings() {
   const globalConfig2 = getGlobalConfig();
   if (globalConfig2.hasCompletedMcpServerMigration) {
     return;
@@ -563758,83 +564491,89 @@ function migrateEnableAllProjectMcpServersToSettings() {
   const hasEnabledServers = Array.isArray(projectConfig.enabledMcpjsonServers);
   const hasDisabledServers = Array.isArray(projectConfig.disabledMcpjsonServers);
   if (!hasEnableAll && !hasEnabledServers && !hasDisabledServers) {
-    saveGlobalConfig((c6) => ({ ...c6, hasCompletedMcpServerMigration: true }));
+    await saveGlobalConfig((c6) => ({ ...c6, hasCompletedMcpServerMigration: true }));
     return;
   }
-  const updates = {};
   const existingSettings = getSettingsForSource("localSettings") || {};
+  const updates = Object.create(null);
+  for (const key2 of Object.keys(existingSettings)) {
+    updates[key2] = existingSettings[key2];
+  }
   if (hasEnableAll) {
     updates.enableAllProjectMcpServers = projectConfig.enableAllProjectMcpServers;
   }
-  const existingEnabledServers = Array.isArray(existingSettings.enabledMcpjsonServers) ? [...existingSettings.enabledMcpjsonServers] : [];
+  let existingEnabledServers = Array.isArray(existingSettings.enabledMcpjsonServers) ? [...existingSettings.enabledMcpjsonServers] : [];
   const existingDisabledServers = Array.isArray(existingSettings.disabledMcpjsonServers) ? [...existingSettings.disabledMcpjsonServers] : [];
-  if (hasEnabledServers) {
-    if (Array.isArray(projectConfig.enabledMcpjsonServers)) {
-      if (projectConfig.enabledMcpjsonServers.length === 0) {
-        existingEnabledServers.length = 0;
-      } else {
-        const seen = new Set(existingEnabledServers);
-        for (const server of projectConfig.enabledMcpjsonServers) {
-          if (!seen.has(server)) {
-            existingEnabledServers.push(server);
-            seen.add(server);
-          }
-        }
+  if (hasEnabledServers && Array.isArray(projectConfig.enabledMcpjsonServers) && projectConfig.enabledMcpjsonServers.length > 0) {
+    const seen = new Set(existingEnabledServers);
+    for (const server of projectConfig.enabledMcpjsonServers) {
+      if (!seen.has(server)) {
+        existingEnabledServers.push(server);
+        seen.add(server);
       }
     }
   }
-  if (hasDisabledServers) {
-    if (Array.isArray(projectConfig.disabledMcpjsonServers)) {
-      if (projectConfig.disabledMcpjsonServers.length === 0) {
-        existingDisabledServers.length = 0;
-      } else {
-        const seen = new Set(existingDisabledServers);
-        for (const server of projectConfig.disabledMcpjsonServers) {
-          if (!seen.has(server)) {
-            existingDisabledServers.push(server);
-            seen.add(server);
-          }
-        }
+  if (hasDisabledServers && Array.isArray(projectConfig.disabledMcpjsonServers) && projectConfig.disabledMcpjsonServers.length > 0) {
+    const seen = new Set(existingDisabledServers);
+    for (const server of projectConfig.disabledMcpjsonServers) {
+      if (!seen.has(server)) {
+        existingDisabledServers.push(server);
+        seen.add(server);
       }
     }
   }
   const overlappingServers = existingEnabledServers.filter((server) => existingDisabledServers.includes(server));
   if (overlappingServers.length > 0) {
-    logEvent("tengu_migrate_mcp_server_conflict_resolved", {
-      overlappingServerCount: overlappingServers.length,
-      conflictResolution: "removed_from_disabled"
-    });
+    existingEnabledServers = existingEnabledServers.filter((server) => !existingDisabledServers.includes(server));
+    const existingDisabledServersFromSettings = Array.isArray(existingSettings.disabledMcpjsonServers) ? existingSettings.disabledMcpjsonServers : [];
+    const isDuplicateConflict = overlappingServers.every((server) => existingDisabledServersFromSettings.includes(server));
+    if (!isDuplicateConflict) {
+      const hashedOverlappingServers = overlappingServers.map((server) => createHash21("sha256").update(server).digest("hex"));
+      logEvent("tengu_migrate_mcp_server_conflict_resolved", {
+        overlappingServers: hashedOverlappingServers.join(","),
+        conflictResolution: "removed_from_enabled_list"
+      });
+    }
   }
-  const finalDisabledServers = existingDisabledServers.filter((server) => !existingEnabledServers.includes(server));
-  if (hasEnabledServers) {
+  if (hasEnabledServers || existingSettings.enabledMcpjsonServers !== undefined) {
     updates.enabledMcpjsonServers = existingEnabledServers;
   }
   if (hasDisabledServers || existingSettings.disabledMcpjsonServers !== undefined) {
-    updates.disabledMcpjsonServers = finalDisabledServers;
+    updates.disabledMcpjsonServers = existingDisabledServers;
   }
   try {
-    const updateResult = updateSettingsForSource("localSettings", updates);
-    if (updateResult?.error) {
-      throw updateResult.error;
+    const result = await updateSettingsForSource("localSettings", updates);
+    if (result.error) {
+      throw result.error;
     }
   } catch (error49) {
     logError2(new Error(`Failed to migrate MCP server settings to local config: ${error49}`));
     throw error49;
   }
-  saveCurrentProjectConfig((config5) => {
-    const updated = { ...config5 };
-    delete updated.enableAllProjectMcpServers;
-    delete updated.enabledMcpjsonServers;
-    delete updated.disabledMcpjsonServers;
-    return updated;
-  });
-  saveGlobalConfig((c6) => ({ ...c6, hasCompletedMcpServerMigration: true }));
+  try {
+    await saveCurrentProjectConfig((config5) => {
+      const updated = { ...config5 };
+      delete updated.enableAllProjectMcpServers;
+      delete updated.enabledMcpjsonServers;
+      delete updated.disabledMcpjsonServers;
+      return updated;
+    });
+  } catch (error49) {
+    logError2(new Error(`Failed to remove migrated MCP server fields from project config: ${error49}`));
+    throw error49;
+  }
+  try {
+    await saveGlobalConfig((c6) => ({ ...c6, hasCompletedMcpServerMigration: true }));
+  } catch (error49) {
+    logError2(new Error(`Failed to mark MCP server migration as completed: ${error49}`));
+    throw error49;
+  }
   logEvent("tengu_migrate_enable_all_project_mcp_servers_to_settings", {
     migration: "enableAllProjectMcpServersToSettings",
     fieldsMigrated: [
-      hasEnableAll && "enableAllProjectMcpServers",
-      hasEnabledServers && "enabledMcpjsonServers",
-      hasDisabledServers && "disabledMcpjsonServers"
+      hasEnableAll ? "enableAllProjectMcpServers" : undefined,
+      hasEnabledServers ? "enabledMcpjsonServers" : undefined,
+      hasDisabledServers ? "disabledMcpjsonServers" : undefined
     ].filter(Boolean).join(",")
   });
 }
@@ -563848,7 +564587,6 @@ var init_migrateEnableAllProjectMcpServersToSettings = __esm(() => {
 // src/migrations/migrateFennecToOpus.ts
 var init_migrateFennecToOpus = __esm(() => {
   init_log3();
-  init_config();
   init_providers();
   init_settings2();
 });
@@ -563903,21 +564641,41 @@ var init_migrateOpusToOpus1m = __esm(() => {
 });
 
 // src/migrations/migrateReplBridgeEnabledToRemoteControlAtStartup.ts
-function migrateReplBridgeEnabledToRemoteControlAtStartup() {
-  saveGlobalConfig((prev) => {
-    const oldValue = prev["replBridgeEnabled"];
+async function migrateReplBridgeEnabledToRemoteControlAtStartup() {
+  await saveGlobalConfig((prev) => {
+    const legacy = prev;
+    const oldValue = legacy.replBridgeEnabled;
     if (oldValue === undefined)
       return prev;
     if (prev.remoteControlAtStartup !== undefined)
       return prev;
-    const newValue = typeof oldValue === "string" ? !["false", "0", "no", ""].includes(oldValue.toLowerCase().trim()) : Boolean(oldValue);
-    const next = { ...prev, remoteControlAtStartup: newValue };
-    delete next.replBridgeEnabled;
+    const truthyValues = ["true", "1", "yes", "on", "enabled"];
+    const falsyValues = ["false", "0", "no", "off", "disabled", ""];
+    const normalizedString = typeof oldValue === "string" ? oldValue.toLowerCase().trim() : "";
+    let newValue;
+    if (typeof oldValue === "boolean") {
+      newValue = oldValue;
+    } else if (typeof oldValue === "string") {
+      if (truthyValues.includes(normalizedString)) {
+        newValue = true;
+      } else if (falsyValues.includes(normalizedString)) {
+        newValue = false;
+      } else {
+        logForDebugging(`Unknown replBridgeEnabled value "${oldValue}" during migration to remoteControlAtStartup; defaulting to false. Please review this value manually.`, { level: "warn" });
+        newValue = false;
+      }
+    } else {
+      logForDebugging(`Unknown replBridgeEnabled value of type "${typeof oldValue}" during migration to remoteControlAtStartup; defaulting to false. Please review this value manually.`, { level: "warn" });
+      newValue = false;
+    }
+    const { replBridgeEnabled: _unused, ...rest } = legacy;
+    const next = { ...rest, remoteControlAtStartup: newValue };
     return next;
   });
 }
 var init_migrateReplBridgeEnabledToRemoteControlAtStartup = __esm(() => {
   init_config();
+  init_debug();
 });
 
 // src/migrations/migrateSonnet1mToSonnet45.ts
@@ -563926,6 +564684,8 @@ function migrateSonnet1mToSonnet45() {
   if (config5.sonnet1m45MigrationComplete) {
     return;
   }
+  const sonnet45Model = CLAUDE_SONNET_4_5_CONFIG.firstParty;
+  const sonnet45Model1m = `${sonnet45Model}[1m]`;
   try {
     const sources = ["userSettings", "projectSettings", "localSettings"];
     let anyMigrated = false;
@@ -563933,21 +564693,21 @@ function migrateSonnet1mToSonnet45() {
       const model = getSettingsForSource(source)?.model;
       if (model === "sonnet[1m]") {
         updateSettingsForSource(source, {
-          model: "sonnet-4-5-20250929[1m]"
+          model: sonnet45Model1m
         });
         anyMigrated = true;
       }
     }
     const override = getMainLoopModelOverride();
     if (override === "sonnet[1m]") {
-      setMainLoopModelOverride("sonnet-4-5-20250929[1m]");
+      setMainLoopModelOverride(sonnet45Model1m);
     }
     saveGlobalConfig((current) => ({
       ...current,
       sonnet1m45MigrationComplete: true
     }));
   } catch (error49) {
-    logError2(new Error(`Failed to migrate sonnet[1m] to sonnet-4-5-20250929[1m]: ${error49}`));
+    logError2(new Error(`Failed to migrate sonnet[1m] to ${sonnet45Model1m}: ${error49}`));
   }
 }
 var init_migrateSonnet1mToSonnet45 = __esm(() => {
@@ -563955,6 +564715,7 @@ var init_migrateSonnet1mToSonnet45 = __esm(() => {
   init_state();
   init_config();
   init_settings2();
+  init_configs();
 });
 
 // src/migrations/migrateSonnet45ToSonnet46.ts
@@ -564005,6 +564766,7 @@ var init_resetAutoModeOptInForDefaultOffer = __esm(() => {
   init_log3();
   init_permissionSetup();
   init_settings2();
+  init_settingsCache();
 });
 
 // src/migrations/resetProToOpusDefault.ts
@@ -564053,6 +564815,248 @@ var init_resetProToOpusDefault = __esm(() => {
   init_settings2();
 });
 
+// src/migrations/migrationRunner.ts
+function topologicalSort(migrations) {
+  const nameToMigration = new Map;
+  for (const m2 of migrations) {
+    if (nameToMigration.has(m2.name)) {
+      throw new Error(`Duplicate migration name '${m2.name}'. Migration names must be unique.`);
+    }
+    nameToMigration.set(m2.name, m2);
+  }
+  for (const m2 of migrations) {
+    if (m2.dependsOn?.includes(m2.name)) {
+      throw new Error(`Self-dependency detected in migration '${m2.name}'. ` + `A migration cannot depend on itself.`);
+    }
+  }
+  const dependsOnMap = new Map;
+  for (const m2 of migrations) {
+    if (m2.dependsOn) {
+      const deps = new Set;
+      for (const dep of m2.dependsOn) {
+        if (!nameToMigration.has(dep)) {
+          throw new Error(`Unknown dependency '${dep}' in migration '${m2.name}'. ` + `Dependency must be included in the migration list.`);
+        }
+        deps.add(dep);
+      }
+      dependsOnMap.set(m2.name, deps);
+    }
+  }
+  const inDegree = new Map;
+  const adjacency = new Map;
+  for (const m2 of migrations) {
+    inDegree.set(m2.name, 0);
+    adjacency.set(m2.name, []);
+  }
+  for (const m2 of migrations) {
+    const deps = dependsOnMap.get(m2.name);
+    if (deps) {
+      for (const dep of deps) {
+        adjacency.get(dep).push(m2.name);
+        inDegree.set(m2.name, (inDegree.get(m2.name) || 0) + 1);
+      }
+    }
+  }
+  const queue2 = [];
+  for (const m2 of migrations) {
+    if (inDegree.get(m2.name) === 0) {
+      queue2.push(m2.name);
+    }
+  }
+  const sorted = [];
+  let queueIndex = 0;
+  while (queueIndex < queue2.length) {
+    const name = queue2[queueIndex];
+    queueIndex++;
+    const migration = nameToMigration.get(name);
+    sorted.push(migration);
+    for (const neighbour of adjacency.get(name) || []) {
+      const newDegree = (inDegree.get(neighbour) || 1) - 1;
+      inDegree.set(neighbour, newDegree);
+      if (newDegree === 0) {
+        queue2.push(neighbour);
+      }
+    }
+  }
+  if (sorted.length !== migrations.length) {
+    const unsorted = new Set(migrations.map((m2) => m2.name));
+    for (const name of sorted) {
+      unsorted.delete(name);
+    }
+    const hasIndirectSelfDependency = () => {
+      for (const node of unsorted) {
+        const visited = new Set;
+        const stack = [node];
+        while (stack.length > 0) {
+          const current = stack.pop();
+          if (current === node && visited.size > 0) {
+            return true;
+          }
+          if (visited.has(current))
+            continue;
+          visited.add(current);
+          const deps = dependsOnMap.get(current);
+          if (deps) {
+            for (const dep of deps) {
+              if (dep === node) {
+                return true;
+              }
+              if (!visited.has(dep)) {
+                stack.push(dep);
+              }
+            }
+          }
+        }
+      }
+      return false;
+    };
+    if (hasIndirectSelfDependency()) {
+      const selfDepNames = Array.from(unsorted).join(", ");
+      throw new Error(`Self-dependency detected in migration(s): ${selfDepNames}. ` + `A migration cannot depend on itself, directly or indirectly.`);
+    }
+    const cycleNames = Array.from(unsorted).join(", ");
+    throw new Error(`Circular dependency detected in migrations: ${cycleNames}. ` + `Each migration must have a valid dependency chain.`);
+  }
+  return sorted;
+}
+async function runMigrationsSafe(migrations, completedMigrationNames) {
+  const completedSet = new Set(completedMigrationNames);
+  const allMigrationNames = new Set(migrations.map((m2) => m2.name));
+  const missingDepMigrations = [];
+  const missingDepNames = new Set;
+  for (const m2 of migrations) {
+    const missingDeps = [];
+    if (m2.dependsOn) {
+      for (const dep of m2.dependsOn) {
+        if (!allMigrationNames.has(dep) && !completedSet.has(dep)) {
+          missingDeps.push(dep);
+        }
+      }
+    }
+    if (missingDeps.length > 0) {
+      missingDepMigrations.push({ migration: m2, missingDeps });
+      missingDepNames.add(m2.name);
+    }
+  }
+  const sanitizedMigrations = migrations.map((m2) => {
+    const sanitizedDeps = m2.dependsOn?.filter((dep) => allMigrationNames.has(dep) && !completedSet.has(dep));
+    return {
+      ...m2,
+      dependsOn: sanitizedDeps && sanitizedDeps.length > 0 ? sanitizedDeps : undefined
+    };
+  });
+  let sortedMigrations;
+  try {
+    sortedMigrations = topologicalSort(sanitizedMigrations);
+  } catch (error49) {
+    const errorMessage4 = error49 instanceof Error ? error49.message : String(error49);
+    const results2 = migrations.map((m2) => {
+      const missingDep = missingDepMigrations.find((md) => md.migration.name === m2.name);
+      if (missingDep) {
+        return {
+          success: false,
+          error: `Missing dependency${missingDep.missingDeps.length > 1 ? "ies" : ""}: ${missingDep.missingDeps.join(", ")}. ` + `Dependency must be included in the migration list or already completed.`,
+          migrationName: m2.name
+        };
+      }
+      return {
+        success: false,
+        error: errorMessage4,
+        migrationName: m2.name
+      };
+    });
+    return {
+      total: migrations.length,
+      successful: 0,
+      failed: migrations.length,
+      skipped: 0,
+      results: results2,
+      newlyCompleted: []
+    };
+  }
+  const results = [];
+  let successful = 0;
+  let failed = 0;
+  let skipped = 0;
+  const newlyCompleted = [];
+  const succeededSet = new Set(completedSet);
+  const failedMigrationNames = new Set;
+  for (const { migration: m2, missingDeps } of missingDepMigrations) {
+    const errorMessage4 = `Missing dependency${missingDeps.length > 1 ? "ies" : ""}: ${missingDeps.join(", ")}. ` + `Dependency must be included in the migration list or already completed.`;
+    results.push({
+      success: false,
+      error: errorMessage4,
+      migrationName: m2.name
+    });
+    failed++;
+    failedMigrationNames.add(m2.name);
+  }
+  for (const { name, migration, dependsOn } of sortedMigrations) {
+    if (missingDepNames.has(name)) {
+      continue;
+    }
+    if (completedSet.has(name)) {
+      results.push({
+        success: true,
+        migrationName: name,
+        skipped: true
+      });
+      skipped++;
+      continue;
+    }
+    let dependencyFailed = false;
+    let dependencyError = "";
+    if (dependsOn) {
+      for (const dep of dependsOn) {
+        if (!succeededSet.has(dep) || failedMigrationNames.has(dep)) {
+          dependencyFailed = true;
+          dependencyError = `Dependency ${dep} failed or was skipped`;
+          break;
+        }
+      }
+    }
+    if (dependencyFailed) {
+      results.push({
+        success: false,
+        error: dependencyError,
+        migrationName: name
+      });
+      failed++;
+      continue;
+    }
+    try {
+      const result = migration();
+      await Promise.resolve(result);
+      results.push({ success: true, migrationName: name });
+      successful++;
+      newlyCompleted.push(name);
+      succeededSet.add(name);
+    } catch (error49) {
+      const errorMessage4 = error49 instanceof Error ? error49.message : String(error49);
+      logError2(new Error(`Migration '${name}' failed: ${errorMessage4}`));
+      logEvent("tengu_migration_failed", { migration: name, error: errorMessage4 });
+      results.push({
+        success: false,
+        error: errorMessage4,
+        migrationName: name
+      });
+      failed++;
+    }
+  }
+  return {
+    total: migrations.length,
+    successful,
+    failed,
+    skipped,
+    results,
+    newlyCompleted
+  };
+}
+var init_migrationRunner = __esm(() => {
+  init_log3();
+  init_analytics();
+});
+
 // src/server/types.ts
 var connectResponseSchema;
 var init_types17 = __esm(() => {
@@ -564894,8 +565898,8 @@ class SerialBatchEventUploader {
     if (items.length === 0)
       return;
     while (this.pending.length + items.length > this.config.maxQueueSize && !this.closed) {
-      await new Promise((resolve50) => {
-        this.backpressureResolvers.push(resolve50);
+      await new Promise((resolve49) => {
+        this.backpressureResolvers.push(resolve49);
       });
     }
     if (this.closed)
@@ -564908,8 +565912,8 @@ class SerialBatchEventUploader {
       return Promise.resolve();
     }
     this.drain();
-    return new Promise((resolve50) => {
-      this.flushResolvers.push(resolve50);
+    return new Promise((resolve49) => {
+      this.flushResolvers.push(resolve49);
     });
   }
   close() {
@@ -564920,11 +565924,11 @@ class SerialBatchEventUploader {
     this.pending = [];
     this.sleepResolve?.();
     this.sleepResolve = null;
-    for (const resolve50 of this.backpressureResolvers)
-      resolve50();
+    for (const resolve49 of this.backpressureResolvers)
+      resolve49();
     this.backpressureResolvers = [];
-    for (const resolve50 of this.flushResolvers)
-      resolve50();
+    for (const resolve49 of this.flushResolvers)
+      resolve49();
     this.flushResolvers = [];
   }
   async drain() {
@@ -564959,8 +565963,8 @@ class SerialBatchEventUploader {
     } finally {
       this.draining = false;
       if (this.pending.length === 0) {
-        for (const resolve50 of this.flushResolvers)
-          resolve50();
+        for (const resolve49 of this.flushResolvers)
+          resolve49();
         this.flushResolvers = [];
       }
     }
@@ -564999,16 +566003,16 @@ class SerialBatchEventUploader {
   releaseBackpressure() {
     const resolvers3 = this.backpressureResolvers;
     this.backpressureResolvers = [];
-    for (const resolve50 of resolvers3)
-      resolve50();
+    for (const resolve49 of resolvers3)
+      resolve49();
   }
   sleep(ms) {
-    return new Promise((resolve50) => {
-      this.sleepResolve = resolve50;
-      setTimeout((self2, resolve51) => {
+    return new Promise((resolve49) => {
+      this.sleepResolve = resolve49;
+      setTimeout((self2, resolve50) => {
         self2.sleepResolve = null;
-        resolve51();
-      }, ms, this, resolve50);
+        resolve50();
+      }, ms, this, resolve49);
     });
   }
 }
@@ -567800,7 +568804,7 @@ var init_idleTimeout = __esm(() => {
 // src/bridge/inboundAttachments.ts
 import { randomUUID as randomUUID50 } from "crypto";
 import { mkdir as mkdir45, writeFile as writeFile46 } from "fs/promises";
-import { basename as basename62, join as join158 } from "path";
+import { basename as basename61, join as join158 } from "path";
 function debug3(msg) {
   logForDebugging(`[bridge:inbound-attach] ${msg}`);
 }
@@ -567812,7 +568816,7 @@ function extractInboundAttachments(msg) {
   return parsed.success ? parsed.data : [];
 }
 function sanitizeFileName(name) {
-  const base2 = basename62(name).replace(/[^a-zA-Z0-9._-]/g, "_");
+  const base2 = basename61(name).replace(/[^a-zA-Z0-9._-]/g, "_");
   return base2 || "attachment";
 }
 function uploadsDir() {
@@ -570221,7 +571225,13 @@ async function initReplBridge(options) {
       logForDebugging(`[bridge:repl] Skipping: cross-process backoff (dead token seen ${cfg.bridgeOauthDeadFailCount} times)`);
       return null;
     }
-    await checkAndRefreshOAuthTokenIfNeeded();
+    try {
+      await checkAndRefreshOAuthTokenIfNeeded();
+    } catch (error49) {
+      logBridgeSkip("oauth_refresh_failed", `[bridge:repl] Skipping: OAuth token refresh failed - ${errorMessage(error49)}`);
+      onStateChange?.("failed", errorMessage(error49));
+      return null;
+    }
     const tokens = getClaudeAIOAuthTokens();
     if (tokens && tokens.expiresAt !== null && tokens.expiresAt <= Date.now()) {
       logBridgeSkip("oauth_expired_unrefreshable", "[bridge:repl] Skipping: OAuth token expired and refresh failed (re-login required)");
@@ -570310,7 +571320,14 @@ async function initReplBridge(options) {
     return userMessageCount >= 3;
   };
   const initialHistoryCap = getFeatureValue_CACHED_WITH_REFRESH("tengu_bridge_initial_history_cap", 200, 5 * 60 * 1000);
-  const orgUUID = await getOrganizationUUID();
+  let orgUUID;
+  try {
+    orgUUID = await getOrganizationUUID();
+  } catch (error49) {
+    logBridgeSkip("get_org_uuid_failed", `[bridge:repl] Skipping: failed to get organization UUID - ${errorMessage(error49)}`);
+    onStateChange?.("failed", errorMessage(error49));
+    return null;
+  }
   if (!orgUUID) {
     logBridgeSkip("no_org_uuid", "[bridge:repl] Skipping: no org UUID");
     onStateChange?.("failed", "/login");
@@ -571200,30 +572217,30 @@ function runHeadlessStreaming(structuredIO, mcpClients, commands, tools, initial
     }
     const isMainThread = (cmd) => cmd.agentId === undefined;
     try {
-      let command8;
+      let command9;
       let waitingForAgents = false;
       const drainCommandQueue = async () => {
-        while (command8 = dequeue(isMainThread)) {
-          if (command8.mode !== "prompt" && command8.mode !== "orphaned-permission" && command8.mode !== "task-notification") {
+        while (command9 = dequeue(isMainThread)) {
+          if (command9.mode !== "prompt" && command9.mode !== "orphaned-permission" && command9.mode !== "task-notification") {
             throw new Error("only prompt commands are supported in streaming mode");
           }
-          const batch = [command8];
-          if (command8.mode === "prompt") {
-            while (canBatchWith(command8, peek(isMainThread))) {
+          const batch = [command9];
+          if (command9.mode === "prompt") {
+            while (canBatchWith(command9, peek(isMainThread))) {
               batch.push(dequeue(isMainThread));
             }
             if (batch.length > 1) {
-              command8 = {
-                ...command8,
+              command9 = {
+                ...command9,
                 value: joinPromptValues(batch.map((c6) => c6.value)),
-                uuid: batch.findLast((c6) => c6.uuid)?.uuid ?? command8.uuid
+                uuid: batch.findLast((c6) => c6.uuid)?.uuid ?? command9.uuid
               };
             }
           }
           const batchUuids = batch.map((c6) => c6.uuid).filter((u4) => u4 !== undefined);
           if (options.replayUserMessages && batch.length > 1) {
             for (const c6 of batch) {
-              if (c6.uuid && c6.uuid !== command8.uuid) {
+              if (c6.uuid && c6.uuid !== command9.uuid) {
                 output.enqueue({
                   type: "user",
                   message: { role: "user", content: c6.value },
@@ -571249,8 +572266,8 @@ function runHeadlessStreaming(structuredIO, mcpClients, commands, tools, initial
           for (const uuid5 of batchUuids) {
             notifyCommandLifecycle(uuid5, "started");
           }
-          if (command8.mode === "task-notification") {
-            const notificationText = typeof command8.value === "string" ? command8.value : "";
+          if (command9.mode === "task-notification") {
+            const notificationText = typeof command9.value === "string" ? command9.value : "";
             const taskIdMatch = notificationText.match(/<task-id>([^<]+)<\/task-id>/);
             const toolUseIdMatch = notificationText.match(/<tool-use-id>([^<]+)<\/tool-use-id>/);
             const outputFileMatch = notificationText.match(/<output-file>([^<]+)<\/output-file>/);
@@ -571283,8 +572300,8 @@ function runHeadlessStreaming(structuredIO, mcpClients, commands, tools, initial
               });
             }
           }
-          const input = command8.value;
-          if (structuredIO instanceof RemoteIO && command8.mode === "prompt") {
+          const input = command9.value;
+          if (structuredIO instanceof RemoteIO && command9.mode === "prompt") {
             logEvent("tengu_bridge_message_received", {
               is_repl: false
             });
@@ -571294,7 +572311,7 @@ function runHeadlessStreaming(structuredIO, mcpClients, commands, tools, initial
           suggestionState.pendingSuggestion = null;
           suggestionState.pendingLastEmittedEntry = null;
           if (suggestionState.lastEmitted) {
-            if (command8.mode === "prompt") {
+            if (command9.mode === "prompt") {
               const inputText = typeof input === "string" ? input : input.find((b3) => b3.type === "text")?.text;
               if (typeof inputText === "string") {
                 logSuggestionOutcome(suggestionState.lastEmitted.text, inputText, suggestionState.lastEmitted.emittedAt, suggestionState.lastEmitted.promptId, suggestionState.lastEmitted.generationRequestId);
@@ -571306,7 +572323,7 @@ function runHeadlessStreaming(structuredIO, mcpClients, commands, tools, initial
           const turnStartTime = undefined;
           headlessProfilerCheckpoint("before_ask");
           startQueryProfile();
-          const cmd = command8;
+          const cmd = command9;
           await runWithWorkload(cmd.workload ?? options.workload, async () => {
             for await (const message of ask({
               commands: uniqBy_default([...currentCommands, ...appState.mcp.commands], "name"),
@@ -571327,8 +572344,8 @@ function runHeadlessStreaming(structuredIO, mcpClients, commands, tools, initial
               jsonSchema: getInitJsonSchema() ?? options.jsonSchema,
               mutableMessages,
               getReadFileCache: () => pendingSeeds.size === 0 ? readFileState : mergeFileStateCaches(readFileState, pendingSeeds),
-              setReadFileCache: (cache5) => {
-                readFileState = cache5;
+              setReadFileCache: (cache6) => {
+                readFileState = cache6;
                 for (const [path27, seed] of pendingSeeds.entries()) {
                   const existing = readFileState.get(path27);
                   if (!existing || seed.timestamp > existing.timestamp) {
@@ -571987,8 +573004,8 @@ ${m2.text}
               const controller = new AbortController;
               activeOAuthFlows.set(serverName, controller);
               let resolveAuthUrl;
-              const authUrlPromise = new Promise((resolve50) => {
-                resolveAuthUrl = resolve50;
+              const authUrlPromise = new Promise((resolve49) => {
+                resolveAuthUrl = resolve49;
               });
               const oauthPromise = performMCPOAuthFlow(serverName, config5, (url3) => resolveAuthUrl(url3), controller.signal, {
                 skipBrowserOpen: true,
@@ -572101,8 +573118,8 @@ ${m2.text}
           });
           const service = new OAuthService;
           let urlResolver;
-          const urlPromise = new Promise((resolve50) => {
-            urlResolver = resolve50;
+          const urlPromise = new Promise((resolve49) => {
+            urlResolver = resolve49;
           });
           const flow = service.startOAuthFlow(async (manualUrl, automaticUrl) => {
             urlResolver({ manualUrl, automaticUrl });
@@ -572490,8 +573507,8 @@ function createCanUseToolWithPermissionPrompt(permissionPromptTool) {
         }
       };
     }
-    const abortPromise = new Promise((resolve50) => {
-      combinedSignal.addEventListener("abort", () => resolve50("aborted"), {
+    const abortPromise = new Promise((resolve49) => {
+      combinedSignal.addEventListener("abort", () => resolve49("aborted"), {
         once: true
       });
     });
@@ -572629,10 +573646,10 @@ async function handleInitializeRequest(request, requestId, initialized5, output,
       description: formatDescriptionWithSource(cmd),
       argumentHint: cmd.argumentHint || ""
     })),
-    agents: agents2.map((agent) => ({
-      name: agent.agentType,
-      description: agent.whenToUse,
-      model: agent.model === "inherit" ? undefined : agent.model
+    agents: agents2.map((agent2) => ({
+      name: agent2.agentType,
+      description: agent2.whenToUse,
+      model: agent2.model === "inherit" ? undefined : agent2.model
     })),
     output_style: outputStyle2,
     available_output_styles: Object.keys(availableOutputStyles),
@@ -573290,7 +574307,7 @@ var init_print = __esm(() => {
   init_cwd2();
   init_omit();
   init_reject2();
-  init_bridgeStatusUtil();
+  init_bridgeUrlBuilder();
   init_inboundMessages();
   init_inboundAttachments();
   init_permissions2();
@@ -574798,7 +575815,7 @@ __export(exports_plugins, {
   VALID_UPDATE_SCOPES: () => VALID_UPDATE_SCOPES,
   VALID_INSTALLABLE_SCOPES: () => VALID_INSTALLABLE_SCOPES
 });
-import { basename as basename63, dirname as dirname71 } from "path";
+import { basename as basename62, dirname as dirname71 } from "path";
 function handleMarketplaceError(error49, action2) {
   logError2(error49);
   cliError(`${figures_default.cross} Failed to ${action2}: ${errorMessage(error49)}`);
@@ -574832,7 +575849,7 @@ async function pluginValidateHandler(manifestPath, options) {
     let contentResults = [];
     if (result.fileType === "plugin") {
       const manifestDir = dirname71(result.filePath);
-      if (basename63(manifestDir) === ".claude-plugin") {
+      if (basename62(manifestDir) === ".claude-plugin") {
         contentResults = await validatePluginContents(dirname71(manifestDir));
         for (const r of contentResults) {
           console.log(`Validating ${r.fileType}: ${r.filePath}
@@ -575677,7 +576694,7 @@ async function setupTokenHandler(root2) {
   const {
     ConsoleOAuthFlow: ConsoleOAuthFlow2
   } = await Promise.resolve().then(() => (init_ConsoleOAuthFlow(), exports_ConsoleOAuthFlow));
-  await new Promise((resolve50) => {
+  await new Promise((resolve49) => {
     root2.render(/* @__PURE__ */ jsx_dev_runtime491.jsxDEV(AppStateProvider, {
       onChangeAppState,
       children: /* @__PURE__ */ jsx_dev_runtime491.jsxDEV(KeybindingSetup, {
@@ -575701,7 +576718,7 @@ async function setupTokenHandler(root2) {
             }, undefined, true, undefined, this),
             /* @__PURE__ */ jsx_dev_runtime491.jsxDEV(ConsoleOAuthFlow2, {
               onDone: () => {
-                resolve50();
+                resolve49();
               },
               mode: "setup-token",
               startingMessage: "This will guide you through long-lived (1-year) auth token setup for your Claude account. Claude subscription required."
@@ -575737,7 +576754,7 @@ function DoctorWithPlugins(t0) {
 }
 async function doctorHandler(root2) {
   logEvent("tengu_doctor_command", {});
-  await new Promise((resolve50) => {
+  await new Promise((resolve49) => {
     root2.render(/* @__PURE__ */ jsx_dev_runtime491.jsxDEV(AppStateProvider, {
       children: /* @__PURE__ */ jsx_dev_runtime491.jsxDEV(KeybindingSetup, {
         children: /* @__PURE__ */ jsx_dev_runtime491.jsxDEV(MCPConnectionManager, {
@@ -575745,7 +576762,7 @@ async function doctorHandler(root2) {
           isStrictMcpConfig: false,
           children: /* @__PURE__ */ jsx_dev_runtime491.jsxDEV(DoctorWithPlugins, {
             onDone: () => {
-              resolve50();
+              resolve49();
             }
           }, undefined, false, undefined, this)
         }, undefined, false, undefined, this)
@@ -575763,14 +576780,14 @@ async function installHandler(target, options) {
   const {
     install: install2
   } = await Promise.resolve().then(() => (init_install(), exports_install));
-  await new Promise((resolve50) => {
+  await new Promise((resolve49) => {
     const args = [];
     if (target)
       args.push(target);
     if (options.force)
       args.push("--force");
     install2.call((result) => {
-      resolve50();
+      resolve49();
       process.exit(result.includes("failed") ? 1 : 0);
     }, {}, args);
   });
@@ -575799,14 +576816,14 @@ var exports_agents3 = {};
 __export(exports_agents3, {
   agentsHandler: () => agentsHandler
 });
-function formatAgent(agent) {
-  const model = resolveAgentModelDisplay(agent);
-  const parts = [agent.agentType];
+function formatAgent(agent2) {
+  const model = resolveAgentModelDisplay(agent2);
+  const parts = [agent2.agentType];
   if (model) {
     parts.push(model);
   }
-  if (agent.memory) {
-    parts.push(`${agent.memory} memory`);
+  if (agent2.memory) {
+    parts.push(`${agent2.memory} memory`);
   }
   return parts.join(" · ");
 }
@@ -575822,12 +576839,12 @@ async function agentsHandler() {
     if (groupAgents.length === 0)
       continue;
     lines2.push(`${label}:`);
-    for (const agent of groupAgents) {
-      if (agent.overriddenBy) {
-        const winnerSource = getOverrideSourceLabel(agent.overriddenBy);
-        lines2.push(`  (shadowed by ${winnerSource}) ${formatAgent(agent)}`);
+    for (const agent2 of groupAgents) {
+      if (agent2.overriddenBy) {
+        const winnerSource = getOverrideSourceLabel(agent2.overriddenBy);
+        lines2.push(`  (shadowed by ${winnerSource}) ${formatAgent(agent2)}`);
       } else {
-        lines2.push(`  ${formatAgent(agent)}`);
+        lines2.push(`  ${formatAgent(agent2)}`);
         totalActive++;
       }
     }
@@ -576210,7 +577227,7 @@ __export(exports_main, {
   main: () => main
 });
 import { readFileSync as readFileSync19 } from "fs";
-import { resolve as resolve50, join as join163, dirname as dirname72 } from "path";
+import { resolve as resolve49, join as join163, dirname as dirname72 } from "path";
 import { fileURLToPath as fileURLToPath10 } from "url";
 import { existsSync as existsSync12 } from "fs";
 function logManagedSettings() {
@@ -576287,22 +577304,34 @@ async function logStartupTelemetry() {
     ...getCertEnvVarTelemetry()
   });
 }
-function runMigrations() {
-  if (getGlobalConfig().migrationVersion !== CURRENT_MIGRATION_VERSION) {
-    migrateAutoUpdatesToSettings();
-    migrateBypassPermissionsAcceptedToSettings();
-    migrateEnableAllProjectMcpServersToSettings();
-    resetProToOpusDefault();
-    migrateSonnet1mToSonnet45();
-    migrateLegacyOpusToCurrent();
-    migrateSonnet45ToSonnet46();
-    migrateOpusToOpus1m();
-    migrateReplBridgeEnabledToRemoteControlAtStartup();
+async function runMigrations() {
+  const globalConfig2 = getGlobalConfig();
+  const needsRun = globalConfig2.migrationVersion !== CURRENT_MIGRATION_VERSION || !Array.isArray(globalConfig2.completedMigrations);
+  if (needsRun) {
+    const migrations = [
+      { name: "migrateAutoUpdatesToSettings", migration: migrateAutoUpdatesToSettings },
+      { name: "migrateBypassPermissionsAcceptedToSettings", migration: migrateBypassPermissionsAcceptedToSettings },
+      { name: "migrateEnableAllProjectMcpServersToSettings", migration: migrateEnableAllProjectMcpServersToSettings, dependsOn: ["migrateReplBridgeEnabledToRemoteControlAtStartup"] },
+      { name: "resetProToOpusDefault", migration: resetProToOpusDefault },
+      { name: "migrateSonnet1mToSonnet45", migration: migrateSonnet1mToSonnet45 },
+      { name: "migrateLegacyOpusToCurrent", migration: migrateLegacyOpusToCurrent },
+      { name: "migrateSonnet45ToSonnet46", migration: migrateSonnet45ToSonnet46 },
+      { name: "migrateOpusToOpus1m", migration: migrateOpusToOpus1m },
+      { name: "migrateReplBridgeEnabledToRemoteControlAtStartup", migration: migrateReplBridgeEnabledToRemoteControlAtStartup }
+    ];
     if (false) {}
     if (false) {}
-    saveGlobalConfig((prev) => prev.migrationVersion === CURRENT_MIGRATION_VERSION ? prev : {
-      ...prev,
-      migrationVersion: CURRENT_MIGRATION_VERSION
+    const result = await runMigrationsSafe(migrations, globalConfig2.completedMigrations ?? []);
+    saveGlobalConfig((prev) => {
+      const completed = new Set(prev.completedMigrations ?? []);
+      for (const name of result.newlyCompleted) {
+        completed.add(name);
+      }
+      return {
+        ...prev,
+        migrationVersion: CURRENT_MIGRATION_VERSION,
+        completedMigrations: [...completed]
+      };
     });
   }
   migrateChangelogFromConfig().catch(() => {});
@@ -576554,7 +577583,7 @@ async function run() {
       setInlinePlugins(pluginDir);
       clearPluginCache("preAction: --plugin-dir inline plugins");
     }
-    runMigrations();
+    await runMigrations();
     profileCheckpoint("preAction_after_migrations");
     loadRemoteManagedSettings();
     loadPolicyLimits();
@@ -576774,12 +577803,12 @@ ${getTmuxInstallInstructions2()}
         process.exit(1);
       }
       try {
-        const filePath = resolve50(options.systemPromptFile);
+        const filePath = resolve49(options.systemPromptFile);
         systemPrompt = readFileSync19(filePath, "utf8");
       } catch (error49) {
         const code = getErrnoCode(error49);
         if (code === "ENOENT") {
-          process.stderr.write(source_default.red(`Error: System prompt file not found: ${resolve50(options.systemPromptFile)}
+          process.stderr.write(source_default.red(`Error: System prompt file not found: ${resolve49(options.systemPromptFile)}
 `));
           process.exit(1);
         }
@@ -576796,12 +577825,12 @@ ${getTmuxInstallInstructions2()}
         process.exit(1);
       }
       try {
-        const filePath = resolve50(options.appendSystemPromptFile);
+        const filePath = resolve49(options.appendSystemPromptFile);
         appendSystemPrompt = readFileSync19(filePath, "utf8");
       } catch (error49) {
         const code = getErrnoCode(error49);
         if (code === "ENOENT") {
-          process.stderr.write(source_default.red(`Error: Append system prompt file not found: ${resolve50(options.appendSystemPromptFile)}
+          process.stderr.write(source_default.red(`Error: Append system prompt file not found: ${resolve49(options.appendSystemPromptFile)}
 `));
           process.exit(1);
         }
@@ -576847,7 +577876,7 @@ ${addendum}` : addendum;
             errors6 = result.errors;
           }
         } else {
-          const configPath = resolve50(configItem);
+          const configPath = resolve49(configItem);
           const result = parseMcpConfigFromFilePath({
             filePath: configPath,
             expandVars: true,
@@ -577137,7 +578166,7 @@ ${hint}` : hint;
     const agentSetting = agentCli ?? getInitialSettings().agent;
     let mainThreadAgentDefinition;
     if (agentSetting) {
-      mainThreadAgentDefinition = agentDefinitions.activeAgents.find((agent) => agent.agentType === agentSetting);
+      mainThreadAgentDefinition = agentDefinitions.activeAgents.find((agent2) => agent2.agentType === agentSetting);
       if (!mainThreadAgentDefinition) {
         logForDebugging(`Warning: agent "${agentSetting}" not found. Available agents: ${agentDefinitions.activeAgents.map((a2) => a2.agentType).join(", ")}. Using default behavior.`);
       }
@@ -577481,7 +578510,7 @@ ${customInstructions}` : customInstructions;
 `);
         process.exit(1);
       }
-      const commandsHeadless = disableSlashCommands ? [] : commands.filter((command8) => command8.type === "prompt" && !command8.disableNonInteractive || command8.type === "local" && command8.supportsNonInteractive);
+      const commandsHeadless = disableSlashCommands ? [] : commands.filter((command9) => command9.type === "prompt" && !command9.disableNonInteractive || command9.type === "local" && command9.supportsNonInteractive);
       const defaultState = getDefaultAppState();
       const headlessInitialState = {
         ...defaultState,
@@ -577601,8 +578630,8 @@ ${customInstructions}` : customInstructions;
         return connectMcpBatch(dedupedClaudeAi, "claudeai");
       });
       let claudeaiTimer;
-      const claudeaiTimedOut = await Promise.race([claudeaiConnect.then(() => false), new Promise((resolve51) => {
-        claudeaiTimer = setTimeout((r) => r(true), CLAUDE_AI_MCP_TIMEOUT_MS, resolve51);
+      const claudeaiTimedOut = await Promise.race([claudeaiConnect.then(() => false), new Promise((resolve50) => {
+        claudeaiTimer = setTimeout((r) => r(true), CLAUDE_AI_MCP_TIMEOUT_MS, resolve50);
       })]);
       if (claudeaiTimer)
         clearTimeout(claudeaiTimer);
@@ -578530,7 +579559,7 @@ function extractTeammateOptions(options) {
     agentType: typeof opts.agentType === "string" ? opts.agentType : undefined
   };
 }
-var getTeammateUtils = () => (init_teammate(), __toCommonJS(exports_teammate)), getTeammatePromptAddendum = () => __toCommonJS(exports_teammatePromptAddendum), getTeammateModeSnapshot = () => (init_teammateModeSnapshot(), __toCommonJS(exports_teammateModeSnapshot)), coordinatorModeModule = null, CURRENT_MIGRATION_VERSION = 11;
+var getTeammateUtils = () => (init_teammate(), __toCommonJS(exports_teammate)), getTeammatePromptAddendum = () => __toCommonJS(exports_teammatePromptAddendum), getTeammateModeSnapshot = () => (init_teammateModeSnapshot(), __toCommonJS(exports_teammateModeSnapshot)), coordinatorModeModule = null, CURRENT_MIGRATION_VERSION = 12;
 var init_main3 = __esm(() => {
   init_startupProfiler();
   init_rawRead();
@@ -578655,6 +579684,7 @@ var init_main3 = __esm(() => {
   init_migrateSonnet45ToSonnet46();
   init_resetAutoModeOptInForDefaultOffer();
   init_resetProToOpusDefault();
+  init_migrationRunner();
   init_RemoteSessionManager();
   init_createDirectConnectSession();
   init_manager();