adhdev 0.9.50 → 0.9.52

package/dist/cli/index.js

@@ -1410,17 +1410,17 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs(providerLoader) {
-  const os30 = (0, import_os2.platform)();
+  const os31 = (0, import_os2.platform)();
   const results = [];
   for (const def of getMergedDefinitions()) {
     const cliPath = findCliCommand(providerLoader?.getIdeCliCommand(def.id, def.cli) || def.cli);
-    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os30] || []) || []);
+    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os31] || []) || []);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os30 === "darwin") {
+    if (!resolvedCli && appPath && os31 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if ((0, import_fs3.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os30 === "win32") {
+    if (!resolvedCli && appPath && os31 === "win32") {
       const { dirname: dirname11 } = await import("path");
       const appDir = dirname11(appPath);
       const candidates = [
@@ -1437,7 +1437,7 @@ async function detectIDEs(providerLoader) {
         }
       }
     }
-    const installed = os30 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
+    const installed = os31 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
     const version2 = resolvedCli ? getIdeVersion(resolvedCli) : null;
     results.push({
       id: def.id,
@@ -8228,6 +8228,50 @@ function buildDebugBundleText(bundle) {
     "```"
   ].join("\n");
 }
+function getChatDebugBundleDir() {
+  const override = typeof process.env.ADHDEV_DEBUG_BUNDLE_DIR === "string" ? process.env.ADHDEV_DEBUG_BUNDLE_DIR.trim() : "";
+  return override || path8.join(os7.homedir(), ".adhdev", "debug-bundles", "chat");
+}
+function safeBundleIdSegment(value, fallback2) {
+  const normalized = String(value || fallback2).trim().replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+  return normalized || fallback2;
+}
+function createChatDebugBundleId(targetSessionId) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.]/g, "").replace("T", "T").replace("Z", "Z");
+  const sessionSegment = safeBundleIdSegment(targetSessionId, "unknown-session");
+  return `chat-debug-${timestamp}-${sessionSegment}-${(0, import_node_crypto.randomUUID)().slice(0, 8)}`;
+}
+function buildChatDebugBundleSummary(bundle) {
+  const target = bundle.target && typeof bundle.target === "object" ? bundle.target : {};
+  const readChat = bundle.readChat && typeof bundle.readChat === "object" ? bundle.readChat : {};
+  const cli = bundle.cli && typeof bundle.cli === "object" ? bundle.cli : null;
+  const frontend = bundle.frontend && typeof bundle.frontend === "object" ? bundle.frontend : null;
+  return {
+    createdAt: bundle.createdAt,
+    targetSessionId: target.targetSessionId,
+    providerType: target.providerType,
+    transport: target.transport,
+    readChatSuccess: readChat.success,
+    readChatStatus: readChat.status,
+    readChatTotalMessages: readChat.totalMessages,
+    cliStatus: cli?.status,
+    cliMessageCount: cli?.messageCount,
+    hasFrontendSnapshot: !!frontend
+  };
+}
+function storeChatDebugBundleOnDaemon(bundle, targetSessionId) {
+  const bundleId = createChatDebugBundleId(targetSessionId);
+  const dir = getChatDebugBundleDir();
+  fs4.mkdirSync(dir, { recursive: true });
+  const savedPath = path8.join(dir, `${bundleId}.json`);
+  const json2 = `${JSON.stringify(bundle, null, 2)}
+`;
+  fs4.writeFileSync(savedPath, json2, { encoding: "utf8", mode: 384 });
+  return { bundleId, savedPath, sizeBytes: Buffer.byteLength(json2, "utf8") };
+}
+function isDaemonFileDebugDelivery(args) {
+  return args?.delivery === "daemon_file" || args?.delivery === "file";
+}
 async function handleGetChatDebugBundle(h, args) {
   const targetSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
   if (!targetSessionId && !h.currentSession) {
@@ -8339,6 +8383,20 @@ async function handleGetChatDebugBundle(h, args) {
     recentDebugTrace: getRecentDebugTrace({ limit: 120 })
   };
   const bundle = sanitizeDebugBundleValue(rawBundle);
+  if (isDaemonFileDebugDelivery(args)) {
+    const summary = buildChatDebugBundleSummary(bundle);
+    const stored = storeChatDebugBundleOnDaemon(bundle, targetSessionId || String(summary.targetSessionId || "unknown-session"));
+    LOG.info("Command", `[get_chat_debug_bundle] saved daemon_file bundle id=${stored.bundleId} path=${stored.savedPath} sizeBytes=${stored.sizeBytes} targetSessionId=${summary.targetSessionId || ""} providerType=${summary.providerType || ""} transport=${summary.transport || ""}`);
+    return {
+      success: true,
+      delivery: "daemon_file",
+      bundleId: stored.bundleId,
+      savedPath: stored.savedPath,
+      sizeBytes: stored.sizeBytes,
+      createdAt: bundle.createdAt,
+      summary
+    };
+  }
   return {
     success: true,
     bundle,
@@ -9318,10 +9376,14 @@ async function handleResolveAction(h, args) {
   }
   return { success: false, error: "resolveAction script not available for this provider" };
 }
-var RECENT_SEND_WINDOW_MS, READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS, recentSendByTarget, DEFAULT_DEBUG_SANITIZE_OPTIONS, SECRET_KEY_PATTERN;
+var fs4, os7, path8, import_node_crypto, RECENT_SEND_WINDOW_MS, READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS, recentSendByTarget, DEFAULT_DEBUG_SANITIZE_OPTIONS, SECRET_KEY_PATTERN;
 var init_chat_commands = __esm({
   "../../oss/packages/daemon-core/src/commands/chat-commands.ts"() {
     "use strict";
+    fs4 = __toESM(require("fs"));
+    os7 = __toESM(require("os"));
+    path8 = __toESM(require("path"));
+    import_node_crypto = require("crypto");
     init_contracts();
     init_provider_input_support();
     init_read_chat_contract();
@@ -9562,27 +9624,27 @@ function normalizeWindowsRequestedPath(requestedPath) {
 function resolveSafePath(requestedPath) {
   const rawPath = typeof requestedPath === "string" ? requestedPath.trim() : "";
   const inputPath = rawPath || ".";
-  const home = os7.homedir();
+  const home = os8.homedir();
   if (inputPath.startsWith("~")) {
-    return path8.resolve(path8.join(home, inputPath.slice(1)));
+    return path9.resolve(path9.join(home, inputPath.slice(1)));
   }
   if (process.platform === "win32") {
     const normalized = normalizeWindowsRequestedPath(inputPath);
-    if (path8.win32.isAbsolute(normalized)) {
-      return path8.win32.normalize(normalized);
+    if (path9.win32.isAbsolute(normalized)) {
+      return path9.win32.normalize(normalized);
     }
-    return path8.win32.resolve(normalized);
+    return path9.win32.resolve(normalized);
   }
-  if (path8.isAbsolute(inputPath)) {
-    return path8.normalize(inputPath);
+  if (path9.isAbsolute(inputPath)) {
+    return path9.normalize(inputPath);
   }
-  return path8.resolve(inputPath);
+  return path9.resolve(inputPath);
 }
 function listDirectoryEntriesSafe(dirPath) {
-  const entries = fs4.readdirSync(dirPath, { withFileTypes: true });
+  const entries = fs5.readdirSync(dirPath, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const entryPath = path8.join(dirPath, entry.name);
+    const entryPath = path9.join(dirPath, entry.name);
     try {
       if (entry.isDirectory()) {
         files.push({ name: entry.name, type: "directory" });
@@ -9591,14 +9653,14 @@ function listDirectoryEntriesSafe(dirPath) {
       if (entry.isFile()) {
         let size;
         try {
-          size = fs4.statSync(entryPath).size;
+          size = fs5.statSync(entryPath).size;
         } catch {
           size = void 0;
         }
         files.push({ name: entry.name, type: "file", size });
         continue;
       }
-      const stat4 = fs4.statSync(entryPath);
+      const stat4 = fs5.statSync(entryPath);
       files.push({
         name: entry.name,
         type: stat4.isDirectory() ? "directory" : "file",
@@ -9616,7 +9678,7 @@ function listWindowsDriveEntries(excludePath) {
     const letter = String.fromCharCode(code);
     const root = `${letter}:\\`;
     try {
-      if (!fs4.existsSync(root)) continue;
+      if (!fs5.existsSync(root)) continue;
       if (excluded && root.toLowerCase() === excluded) continue;
       drives.push({ name: `${letter}:`, type: "directory", path: root });
     } catch {
@@ -9627,7 +9689,7 @@ function listWindowsDriveEntries(excludePath) {
 async function handleFileRead(h, args) {
   try {
     const filePath = resolveSafePath(args?.path);
-    const content = fs4.readFileSync(filePath, "utf-8");
+    const content = fs5.readFileSync(filePath, "utf-8");
     return { success: true, content, path: filePath };
   } catch (e) {
     return { success: false, error: e.message };
@@ -9636,8 +9698,8 @@ async function handleFileRead(h, args) {
 async function handleFileWrite(h, args) {
   try {
     const filePath = resolveSafePath(args?.path);
-    fs4.mkdirSync(path8.dirname(filePath), { recursive: true });
-    fs4.writeFileSync(filePath, args?.content || "", "utf-8");
+    fs5.mkdirSync(path9.dirname(filePath), { recursive: true });
+    fs5.writeFileSync(filePath, args?.content || "", "utf-8");
     return { success: true, path: filePath };
   } catch (e) {
     return { success: false, error: e.message };
@@ -9669,13 +9731,13 @@ async function handleFileListBrowse(h, args) {
     return { success: false, error: e.message };
   }
 }
-var fs4, path8, os7, KEY_TO_VK;
+var fs5, path9, os8, KEY_TO_VK;
 var init_cdp_commands = __esm({
   "../../oss/packages/daemon-core/src/commands/cdp-commands.ts"() {
     "use strict";
-    fs4 = __toESM(require("fs"));
-    path8 = __toESM(require("path"));
-    os7 = __toESM(require("os"));
+    fs5 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
+    os8 = __toESM(require("os"));
     KEY_TO_VK = {
       Backspace: 8,
       Tab: 9,
@@ -9920,12 +9982,13 @@ async function handleSetProviderSourceConfig(h, args) {
   });
   loader.reload();
   loader.registerToDetector();
+  const refreshedInstances = h.ctx.instanceManager ? h.ctx.instanceManager.refreshProviderDefinitions((providerType) => loader.resolve(providerType)) : 0;
   await h.ctx.onProviderSourceConfigChanged?.();
   LOG.info(
     "Command",
     `[set_provider_source_config] mode=${sourceConfig.sourceMode} explicitProviderDir=${sourceConfig.explicitProviderDir || "-"} userDir=${sourceConfig.userDir}`
   );
-  return { success: true, reloaded: true, ...sourceConfig };
+  return { success: true, reloaded: true, refreshedInstances, ...sourceConfig };
 }
 function normalizeProviderScriptArgs(args, scriptName) {
   const normalizedArgs = { ...args || {} };
@@ -11656,7 +11719,7 @@ function getWorkspaceLabel(workspace) {
   const trimmed = workspace.trim();
   if (!trimmed) return "workspace";
   const normalized = trimmed.replace(/[\\/]+$/, "");
-  const base = path9.basename(normalized);
+  const base = path10.basename(normalized);
   return base || normalized;
 }
 function buildRuntimeDisplayName(payload) {
@@ -11765,7 +11828,7 @@ function getDefaultSessionHostEndpoint(appName = "adhdev") {
   }
   return {
     kind: "unix",
-    path: path22.join(os9.tmpdir(), `${appName}-session-host.sock`)
+    path: path22.join(os10.tmpdir(), `${appName}-session-host.sock`)
   };
 }
 function serializeEnvelope(envelope) {
@@ -11828,27 +11891,27 @@ function applyTerminalColorEnv(env3) {
 function ensureNodePtySpawnHelperPermissions(logFn) {
   if (os22.platform() === "win32") return;
   try {
-    const fs22 = __require("fs");
+    const fs23 = __require("fs");
     const ptyDir = path32.resolve(path32.dirname(__require.resolve("node-pty")), "..");
     const platformArch = `${os22.platform()}-${os22.arch()}`;
     const helper = path32.join(ptyDir, "prebuilds", platformArch, "spawn-helper");
-    if (fs22.existsSync(helper)) {
-      const stat4 = fs22.statSync(helper);
+    if (fs23.existsSync(helper)) {
+      const stat4 = fs23.statSync(helper);
       if (!(stat4.mode & 73)) {
-        fs22.chmodSync(helper, stat4.mode | 493);
+        fs23.chmodSync(helper, stat4.mode | 493);
         logFn?.(`Fixed spawn-helper permissions: ${helper}`);
       }
     }
   } catch {
   }
 }
-var import_crypto3, path9, os9, path22, net, import_crypto4, os22, path32, __require, DEFAULT_SESSION_RING_BUFFER_MAX_BYTES, SessionRingBuffer, DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS, LIVE_LIFECYCLES2, SessionHostRegistry, SessionHostClient;
+var import_crypto3, path10, os10, path22, net, import_crypto4, os22, path32, __require, DEFAULT_SESSION_RING_BUFFER_MAX_BYTES, SessionRingBuffer, DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS, LIVE_LIFECYCLES2, SessionHostRegistry, SessionHostClient;
 var init_dist = __esm({
   "../../oss/packages/session-host-core/dist/index.mjs"() {
     "use strict";
     import_crypto3 = require("crypto");
-    path9 = __toESM(require("path"), 1);
-    os9 = __toESM(require("os"), 1);
+    path10 = __toESM(require("path"), 1);
+    os10 = __toESM(require("os"), 1);
     path22 = __toESM(require("path"), 1);
     net = __toESM(require("net"), 1);
     import_crypto4 = require("crypto");
@@ -12267,11 +12330,11 @@ function loadNodePty() {
   }
   return cachedPty;
 }
-var os10, cachedPty, NodePtyRuntimeTransport, NodePtyTransportFactory;
+var os11, cachedPty, NodePtyRuntimeTransport, NodePtyTransportFactory;
 var init_pty_transport = __esm({
   "../../oss/packages/daemon-core/src/cli-adapters/pty-transport.ts"() {
     "use strict";
-    os10 = __toESM(require("os"));
+    os11 = __toESM(require("os"));
     init_spawn_env();
     NodePtyRuntimeTransport = class {
       constructor(handle) {
@@ -12308,11 +12371,11 @@ var init_pty_transport = __esm({
         let cwd = options.cwd;
         if (cwd) {
           try {
-            const fs22 = require("fs");
-            const stat4 = fs22.statSync(cwd);
-            if (!stat4.isDirectory()) cwd = os10.homedir();
+            const fs23 = require("fs");
+            const stat4 = fs23.statSync(cwd);
+            if (!stat4.isDirectory()) cwd = os11.homedir();
           } catch {
-            cwd = os10.homedir();
+            cwd = os11.homedir();
           }
         }
         const handle = pty.spawn(command, args, {
@@ -12392,11 +12455,11 @@ function buildCliScreenSnapshot(text) {
 function findBinary(name) {
   const trimmed = String(name || "").trim();
   if (!trimmed) return trimmed;
-  const expanded = trimmed.startsWith("~") ? path10.join(os11.homedir(), trimmed.slice(1)) : trimmed;
-  if (path10.isAbsolute(expanded) || expanded.includes("/") || expanded.includes("\\")) {
-    return path10.isAbsolute(expanded) ? expanded : path10.resolve(expanded);
+  const expanded = trimmed.startsWith("~") ? path11.join(os12.homedir(), trimmed.slice(1)) : trimmed;
+  if (path11.isAbsolute(expanded) || expanded.includes("/") || expanded.includes("\\")) {
+    return path11.isAbsolute(expanded) ? expanded : path11.resolve(expanded);
   }
-  const isWin = os11.platform() === "win32";
+  const isWin = os12.platform() === "win32";
   try {
     const cmd = isWin ? `where ${trimmed}` : `which ${trimmed}`;
     return (0, import_child_process4.execSync)(cmd, {
@@ -12410,14 +12473,14 @@ function findBinary(name) {
   }
 }
 function isScriptBinary(binaryPath) {
-  if (!path10.isAbsolute(binaryPath)) return false;
+  if (!path11.isAbsolute(binaryPath)) return false;
   try {
-    const fs22 = require("fs");
-    const resolved = fs22.realpathSync(binaryPath);
+    const fs23 = require("fs");
+    const resolved = fs23.realpathSync(binaryPath);
     const head = Buffer.alloc(8);
-    const fd = fs22.openSync(resolved, "r");
-    fs22.readSync(fd, head, 0, 8, 0);
-    fs22.closeSync(fd);
+    const fd = fs23.openSync(resolved, "r");
+    fs23.readSync(fd, head, 0, 8, 0);
+    fs23.closeSync(fd);
     let i = 0;
     if (head[0] === 239 && head[1] === 187 && head[2] === 191) i = 3;
     return head[i] === 35 && head[i + 1] === 33;
@@ -12426,14 +12489,14 @@ function isScriptBinary(binaryPath) {
   }
 }
 function looksLikeMachOOrElf(filePath) {
-  if (!path10.isAbsolute(filePath)) return false;
+  if (!path11.isAbsolute(filePath)) return false;
   try {
-    const fs22 = require("fs");
-    const resolved = fs22.realpathSync(filePath);
+    const fs23 = require("fs");
+    const resolved = fs23.realpathSync(filePath);
     const buf = Buffer.alloc(8);
-    const fd = fs22.openSync(resolved, "r");
-    fs22.readSync(fd, buf, 0, 8, 0);
-    fs22.closeSync(fd);
+    const fd = fs23.openSync(resolved, "r");
+    fs23.readSync(fd, buf, 0, 8, 0);
+    fs23.closeSync(fd);
     let i = 0;
     if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
     const b = buf.subarray(i);
@@ -12449,7 +12512,7 @@ function looksLikeMachOOrElf(filePath) {
 }
 function shSingleQuote(arg) {
   if (/^[a-zA-Z0-9@%_+=:,./-]+$/.test(arg)) return arg;
-  if (os11.platform() === "win32") {
+  if (os12.platform() === "win32") {
     return `"${arg.replace(/"/g, '""')}"`;
   }
   return `'${arg.replace(/'/g, `'\\''`)}'`;
@@ -12576,12 +12639,12 @@ function normalizeCliProviderForRuntime(raw) {
     }
   };
 }
-var os11, path10, import_child_process4, buildCliSpawnEnv, COMMON_COMPARABLE_WRAP_WORDS;
+var os12, path11, import_child_process4, buildCliSpawnEnv, COMMON_COMPARABLE_WRAP_WORDS;
 var init_provider_cli_shared = __esm({
   "../../oss/packages/daemon-core/src/cli-adapters/provider-cli-shared.ts"() {
     "use strict";
-    os11 = __toESM(require("os"));
-    path10 = __toESM(require("path"));
+    os12 = __toESM(require("os"));
+    path11 = __toESM(require("path"));
     import_child_process4 = require("child_process");
     init_spawn_env();
     buildCliSpawnEnv = sanitizeSpawnEnv;
@@ -12894,13 +12957,13 @@ function resolveCliSpawnPlan(options) {
   const { spawn: spawnConfig } = provider;
   const configuredCommand = typeof runtimeSettings.executablePath === "string" && runtimeSettings.executablePath.trim() ? runtimeSettings.executablePath.trim() : spawnConfig.command;
   const binaryPath = findBinary(configuredCommand);
-  const isWin = os12.platform() === "win32";
+  const isWin = os13.platform() === "win32";
   const allArgs = [...spawnConfig.args, ...extraArgs];
   let shellCmd;
   let shellArgs;
-  const useShellUnix = !isWin && (!!spawnConfig.shell || !path11.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
+  const useShellUnix = !isWin && (!!spawnConfig.shell || !path12.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
   const isCmdShim = isWin && /\.(cmd|bat)$/i.test(binaryPath);
-  const useShellWin = !!spawnConfig.shell || isCmdShim || !path11.isAbsolute(binaryPath) || isScriptBinary(binaryPath);
+  const useShellWin = !!spawnConfig.shell || isCmdShim || !path12.isAbsolute(binaryPath) || isScriptBinary(binaryPath);
   const useShell = isWin ? useShellWin : useShellUnix;
   if (useShell) {
     shellCmd = isWin ? "cmd.exe" : process.env.SHELL || "/bin/zsh";
@@ -12976,12 +13039,12 @@ function respondToCliTerminalQueries(options) {
   }
   return "";
 }
-var os12, path11;
+var os13, path12;
 var init_provider_cli_runtime = __esm({
   "../../oss/packages/daemon-core/src/cli-adapters/provider-cli-runtime.ts"() {
     "use strict";
-    os12 = __toESM(require("os"));
-    path11 = __toESM(require("path"));
+    os13 = __toESM(require("os"));
+    path12 = __toESM(require("path"));
     init_dist();
     init_provider_cli_shared();
   }
@@ -13103,11 +13166,11 @@ function trimLastAssistantEchoForCliMessages(messages, prompt2) {
     return;
   }
 }
-var os13, COMMITTED_ACTIVITY_PREFIX_BLOCK_RE, ProviderCliAdapter;
+var os14, COMMITTED_ACTIVITY_PREFIX_BLOCK_RE, ProviderCliAdapter;
 var init_provider_cli_adapter = __esm({
   "../../oss/packages/daemon-core/src/cli-adapters/provider-cli-adapter.ts"() {
     "use strict";
-    os13 = __toESM(require("os"));
+    os14 = __toESM(require("os"));
     init_logger();
     init_debug_config();
     init_terminal_screen();
@@ -13127,7 +13190,7 @@ var init_provider_cli_adapter = __esm({
         this.transportFactory = transportFactory;
         this.cliType = provider.type;
         this.cliName = provider.name;
-        this.workingDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os13.homedir()) : workingDir;
+        this.workingDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os14.homedir()) : workingDir;
         const resolvedConfig = resolveCliAdapterConfig(provider);
         this.timeouts = resolvedConfig.timeouts;
         this.approvalKeys = resolvedConfig.approvalKeys;
@@ -15510,7 +15573,7 @@ function buildIncrementalHistoryAppendMessages(previousMessages, currentMessages
 }
 function getDatabaseSync() {
   if (CachedDatabaseSync) return CachedDatabaseSync;
-  const requireFn = typeof require === "function" ? require : (0, import_node_module.createRequire)(path12.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
+  const requireFn = typeof require === "function" ? require : (0, import_node_module.createRequire)(path13.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
   const sqliteModule = requireFn(`node:${"sqlite"}`);
   CachedDatabaseSync = sqliteModule.DatabaseSync;
   if (!CachedDatabaseSync) {
@@ -15552,14 +15615,14 @@ async function waitForCliAdapterReady(adapter, options) {
   }
   throw new Error(`CLI runtime did not become ready within ${timeoutMs}ms`);
 }
-var os14, path12, crypto3, fs5, import_node_module, CachedDatabaseSync, CliProviderInstance;
+var os15, path13, crypto3, fs6, import_node_module, CachedDatabaseSync, CliProviderInstance;
 var init_cli_provider_instance = __esm({
   "../../oss/packages/daemon-core/src/providers/cli-provider-instance.ts"() {
     "use strict";
-    os14 = __toESM(require("os"));
-    path12 = __toESM(require("path"));
+    os15 = __toESM(require("os"));
+    path13 = __toESM(require("path"));
     crypto3 = __toESM(require("crypto"));
-    fs5 = __toESM(require("fs"));
+    fs6 = __toESM(require("fs"));
     import_node_module = require("module");
     init_contracts();
     init_provider_input_support();
@@ -15682,10 +15745,10 @@ var init_cli_provider_instance = __esm({
        * Replaces the previously duplicated probeOpenCode/Codex/Goose functions.
        */
       probeSessionIdFromConfig(probe) {
-        const resolvedDbPath = probe.dbPath.replace(/^~/, os14.homedir());
+        const resolvedDbPath = probe.dbPath.replace(/^~/, os15.homedir());
         const now = Date.now();
         if (this.cachedSqliteDbMissingUntil > now) return null;
-        if (!fs5.existsSync(resolvedDbPath)) {
+        if (!fs6.existsSync(resolvedDbPath)) {
           this.cachedSqliteDbMissingUntil = now + 1e4;
           return null;
         }
@@ -16417,7 +16480,7 @@ ${effect.notification.body || ""}`.trim();
         };
         addDir(this.workingDir);
         try {
-          addDir(fs5.realpathSync.native(this.workingDir));
+          addDir(fs6.realpathSync.native(this.workingDir));
         } catch {
         }
         return Array.from(dirs);
@@ -16708,10 +16771,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path35) {
-  if (!path35)
+function getElementAtPath(obj, path36) {
+  if (!path36)
     return obj;
-  return path35.reduce((acc, key) => acc?.[key], obj);
+  return path36.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -17023,11 +17086,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path35, issues) {
+function prefixIssues(path36, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path35);
+    iss.path.unshift(path36);
     return iss;
   });
 }
@@ -17270,7 +17333,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path35 = []) => {
+  const processError = (error49, path36 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -17280,7 +17343,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path35, ...issue2.path];
+        const fullpath = [...path36, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -17312,8 +17375,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path35 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path35) {
+  const path36 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path36) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -30077,13 +30140,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path35 = ref.slice(1).split("/").filter(Boolean);
-  if (path35.length === 0) {
+  const path36 = ref.slice(1).split("/").filter(Boolean);
+  if (path36.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path35[0] === defsKey) {
-    const key = path35[1];
+  if (path36[0] === defsKey) {
+    const key = path36[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -33929,11 +33992,11 @@ var init_hosted_runtime_restore = __esm({
 // ../../oss/packages/daemon-core/src/commands/cli-manager.ts
 function isExplicitCommand(command) {
   const trimmed = command.trim();
-  return path13.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
+  return path14.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
 }
 function expandExecutable(command) {
   const trimmed = command.trim();
-  return trimmed.startsWith("~") ? path13.join(os15.homedir(), trimmed.slice(1)) : trimmed;
+  return trimmed.startsWith("~") ? path14.join(os16.homedir(), trimmed.slice(1)) : trimmed;
 }
 function commandExists(command) {
   const trimmed = command.trim();
@@ -34070,12 +34133,12 @@ function resolveCliSessionBinding(provider, normalizedType, cliArgs, requestedRe
     launchMode: "new"
   };
 }
-var os15, path13, crypto4, import_fs5, import_child_process6, chalkModule, chalkApi, DaemonCliManager;
+var os16, path14, crypto4, import_fs5, import_child_process6, chalkModule, chalkApi, DaemonCliManager;
 var init_cli_manager = __esm({
   "../../oss/packages/daemon-core/src/commands/cli-manager.ts"() {
     "use strict";
-    os15 = __toESM(require("os"));
-    path13 = __toESM(require("path"));
+    os16 = __toESM(require("os"));
+    path14 = __toESM(require("path"));
     crypto4 = __toESM(require("crypto"));
     import_fs5 = require("fs");
     import_child_process6 = require("child_process");
@@ -34238,7 +34301,7 @@ var init_cli_manager = __esm({
       async startSession(cliType, workingDir, cliArgs, initialModel, options) {
         const trimmed = (workingDir || "").trim();
         if (!trimmed) throw new Error("working directory required");
-        const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os15.homedir()) : path13.resolve(trimmed);
+        const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os16.homedir()) : path14.resolve(trimmed);
         const normalizedType = this.providerLoader.resolveAlias(cliType);
         const rawProvider = this.providerLoader.getByAlias(cliType);
         const provider = rawProvider ? this.providerLoader.resolve(normalizedType) || rawProvider : void 0;
@@ -34841,7 +34904,7 @@ var init_readdirp = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
         if (wantBigintFsStats) {
-          this._stat = (path35) => statMethod(path35, { bigint: true });
+          this._stat = (path36) => statMethod(path36, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -34866,8 +34929,8 @@ var init_readdirp = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path35, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path35));
+              const { path: path36, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path36));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -34907,20 +34970,20 @@ var init_readdirp = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path35, depth) {
+      async _exploreDir(path36, depth) {
         let files;
         try {
-          files = await (0, import_promises.readdir)(path35, this._rdOptions);
+          files = await (0, import_promises.readdir)(path36, this._rdOptions);
         } catch (error48) {
           this._onError(error48);
         }
-        return { files, depth, path: path35 };
+        return { files, depth, path: path36 };
       }
-      async _formatEntry(dirent, path35) {
+      async _formatEntry(dirent, path36) {
         let entry;
         const basename10 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path35, basename10));
+          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path36, basename10));
           entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename10 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
@@ -34977,16 +35040,16 @@ var init_readdirp = __esm({
 });
 
 // ../../oss/packages/daemon-core/node_modules/chokidar/handler.js
-function createFsWatchInstance(path35, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path36, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path35);
-    emitRaw(rawEvent, evPath, { watchedPath: path35 });
-    if (evPath && path35 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path35, evPath), KEY_LISTENERS, sp.join(path35, evPath));
+    listener(path36);
+    emitRaw(rawEvent, evPath, { watchedPath: path36 });
+    if (evPath && path36 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path36, evPath), KEY_LISTENERS, sp.join(path36, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path35, {
+    return (0, import_node_fs.watch)(path36, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error48) {
@@ -35335,12 +35398,12 @@ var init_handler2 = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path35, fullPath, options, handlers) => {
+    setFsWatchListener = (path36, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path35, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path36, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -35351,7 +35414,7 @@ var init_handler2 = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path35,
+          path36,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -35366,7 +35429,7 @@ var init_handler2 = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error48.code === "EPERM") {
             try {
-              const fd = await (0, import_promises2.open)(path35, "r");
+              const fd = await (0, import_promises2.open)(path36, "r");
               await fd.close();
               broadcastErr(error48);
             } catch (err) {
@@ -35397,7 +35460,7 @@ var init_handler2 = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path35, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path36, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -35419,7 +35482,7 @@ var init_handler2 = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path35, curr));
+              foreach(cont.listeners, (listener2) => listener2(path36, curr));
             }
           })
         };
@@ -35449,13 +35512,13 @@ var init_handler2 = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path35, listener) {
+      _watchWithNodeFs(path36, listener) {
         const opts = this.fsw.options;
-        const directory = sp.dirname(path35);
-        const basename10 = sp.basename(path35);
+        const directory = sp.dirname(path36);
+        const basename10 = sp.basename(path36);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename10);
-        const absolutePath = sp.resolve(path35);
+        const absolutePath = sp.resolve(path36);
         const options = {
           persistent: opts.persistent
         };
@@ -35465,12 +35528,12 @@ var init_handler2 = __esm({
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
           options.interval = enableBin && isBinaryPath(basename10) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path35, absolutePath, options, {
+          closer = setFsWatchFileListener(path36, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path35, absolutePath, options, {
+          closer = setFsWatchListener(path36, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -35492,7 +35555,7 @@ var init_handler2 = __esm({
         let prevStats = stats;
         if (parent.has(basename10))
           return;
-        const listener = async (path35, newStats) => {
+        const listener = async (path36, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -35506,11 +35569,11 @@ var init_handler2 = __esm({
                 this.fsw._emit(EV.CHANGE, file2, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path35);
+                this.fsw._closeFile(path36);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file2, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path35, closer2);
+                  this.fsw._addPathCloser(path36, closer2);
               } else {
                 prevStats = newStats2;
               }
@@ -35542,7 +35605,7 @@ var init_handler2 = __esm({
        * @param item basename of this item
        * @returns true if no more processing is needed for this entry.
        */
-      async _handleSymlink(entry, directory, path35, item) {
+      async _handleSymlink(entry, directory, path36, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -35552,7 +35615,7 @@ var init_handler2 = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await (0, import_promises2.realpath)(path35);
+            linkPath = await (0, import_promises2.realpath)(path36);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -35562,12 +35625,12 @@ var init_handler2 = __esm({
           if (dir.has(item)) {
             if (this.fsw._symlinkPaths.get(full) !== linkPath) {
               this.fsw._symlinkPaths.set(full, linkPath);
-              this.fsw._emit(EV.CHANGE, path35, entry.stats);
+              this.fsw._emit(EV.CHANGE, path36, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path35, entry.stats);
+            this.fsw._emit(EV.ADD, path36, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -35597,9 +35660,9 @@ var init_handler2 = __esm({
             return;
           }
           const item = entry.path;
-          let path35 = sp.join(directory, item);
+          let path36 = sp.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path35, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path36, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -35608,8 +35671,8 @@ var init_handler2 = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path35 = sp.join(dir, sp.relative(dir, path35));
-            this._addToNodeFs(path35, initialAdd, wh, depth + 1);
+            path36 = sp.join(dir, sp.relative(dir, path36));
+            this._addToNodeFs(path36, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve18, reject) => {
@@ -35678,13 +35741,13 @@ var init_handler2 = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path35, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path36, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path35) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path36) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path35);
+        const wh = this.fsw._getWatchHelpers(path36);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -35700,8 +35763,8 @@ var init_handler2 = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sp.resolve(path35);
-            const targetPath = follow ? await (0, import_promises2.realpath)(path35) : path35;
+            const absPath = sp.resolve(path36);
+            const targetPath = follow ? await (0, import_promises2.realpath)(path36) : path36;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -35711,29 +35774,29 @@ var init_handler2 = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await (0, import_promises2.realpath)(path35) : path35;
+            const targetPath = follow ? await (0, import_promises2.realpath)(path36) : path36;
             if (this.fsw.closed)
               return;
             const parent = sp.dirname(wh.watchPath);
             this.fsw._getWatchedDir(parent).add(wh.watchPath);
             this.fsw._emit(EV.ADD, wh.watchPath, stats);
-            closer = await this._handleDir(parent, stats, initialAdd, depth, path35, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path36, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sp.resolve(path35), targetPath);
+              this.fsw._symlinkPaths.set(sp.resolve(path36), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path35, closer);
+            this.fsw._addPathCloser(path36, closer);
           return false;
         } catch (error48) {
           if (this.fsw._handleError(error48)) {
             ready();
-            return path35;
+            return path36;
           }
         }
       }
@@ -35768,24 +35831,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path35) {
-  if (typeof path35 !== "string")
+function normalizePath(path36) {
+  if (typeof path36 !== "string")
     throw new Error("string expected");
-  path35 = sp2.normalize(path35);
-  path35 = path35.replace(/\\/g, "/");
+  path36 = sp2.normalize(path36);
+  path36 = path36.replace(/\\/g, "/");
   let prepend = false;
-  if (path35.startsWith("//"))
+  if (path36.startsWith("//"))
     prepend = true;
-  path35 = path35.replace(DOUBLE_SLASH_RE, "/");
+  path36 = path36.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path35 = "/" + path35;
-  return path35;
+    path36 = "/" + path36;
+  return path36;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path35 = normalizePath(testString);
+  const path36 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path35, stats)) {
+    if (pattern(path36, stats)) {
       return true;
     }
   }
@@ -35848,19 +35911,19 @@ var init_chokidar = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path35) => toUnix(sp2.normalize(toUnix(path35)));
-    normalizeIgnored = (cwd = "") => (path35) => {
-      if (typeof path35 === "string") {
-        return normalizePathToUnix(sp2.isAbsolute(path35) ? path35 : sp2.join(cwd, path35));
+    normalizePathToUnix = (path36) => toUnix(sp2.normalize(toUnix(path36)));
+    normalizeIgnored = (cwd = "") => (path36) => {
+      if (typeof path36 === "string") {
+        return normalizePathToUnix(sp2.isAbsolute(path36) ? path36 : sp2.join(cwd, path36));
       } else {
-        return path35;
+        return path36;
       }
     };
-    getAbsolutePath = (path35, cwd) => {
-      if (sp2.isAbsolute(path35)) {
-        return path35;
+    getAbsolutePath = (path36, cwd) => {
+      if (sp2.isAbsolute(path36)) {
+        return path36;
       }
-      return sp2.join(cwd, path35);
+      return sp2.join(cwd, path36);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -35925,10 +35988,10 @@ var init_chokidar = __esm({
       dirParts;
       followSymlinks;
       statMethod;
-      constructor(path35, follow, fsw) {
+      constructor(path36, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path35;
-        this.path = path35 = path35.replace(REPLACER_RE, "");
+        const watchPath = path36;
+        this.path = path36 = path36.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sp2.resolve(watchPath);
         this.dirParts = [];
@@ -36068,20 +36131,20 @@ var init_chokidar = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path35) => {
-            const absPath = getAbsolutePath(path35, cwd);
+          paths = paths.map((path36) => {
+            const absPath = getAbsolutePath(path36, cwd);
             return absPath;
           });
         }
-        paths.forEach((path35) => {
-          this._removeIgnoredPath(path35);
+        paths.forEach((path36) => {
+          this._removeIgnoredPath(path36);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path35) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path35, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path36) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path36, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -36103,17 +36166,17 @@ var init_chokidar = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path35) => {
-          if (!sp2.isAbsolute(path35) && !this._closers.has(path35)) {
+        paths.forEach((path36) => {
+          if (!sp2.isAbsolute(path36) && !this._closers.has(path36)) {
             if (cwd)
-              path35 = sp2.join(cwd, path35);
-            path35 = sp2.resolve(path35);
+              path36 = sp2.join(cwd, path36);
+            path36 = sp2.resolve(path36);
           }
-          this._closePath(path35);
-          this._addIgnoredPath(path35);
-          if (this._watched.has(path35)) {
+          this._closePath(path36);
+          this._addIgnoredPath(path36);
+          if (this._watched.has(path36)) {
             this._addIgnoredPath({
-              path: path35,
+              path: path36,
               recursive: true
             });
           }
@@ -36177,38 +36240,38 @@ var init_chokidar = __esm({
        * @param stats arguments to be passed with event
        * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
        */
-      async _emit(event, path35, stats) {
+      async _emit(event, path36, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path35 = sp2.normalize(path35);
+          path36 = sp2.normalize(path36);
         if (opts.cwd)
-          path35 = sp2.relative(opts.cwd, path35);
-        const args = [path35];
+          path36 = sp2.relative(opts.cwd, path36);
+        const args = [path36];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path35))) {
+        if (awf && (pw = this._pendingWrites.get(path36))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path35, [event, ...args]);
+            this._pendingUnlinks.set(path36, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path36) => {
+              this._pendingUnlinks.forEach((entry, path37) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path36);
+                this._pendingUnlinks.delete(path37);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path35)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path36)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path35);
+            this._pendingUnlinks.delete(path36);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -36226,16 +36289,16 @@ var init_chokidar = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path35, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path36, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path35, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path36, 50);
           if (isThrottled)
             return this;
         }
         if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-          const fullPath = opts.cwd ? sp2.join(opts.cwd, path35) : path35;
+          const fullPath = opts.cwd ? sp2.join(opts.cwd, path36) : path36;
           let stats2;
           try {
             stats2 = await (0, import_promises3.stat)(fullPath);
@@ -36266,23 +36329,23 @@ var init_chokidar = __esm({
        * @param timeout duration of time to suppress duplicate actions
        * @returns tracking object or false if action should be suppressed
        */
-      _throttle(actionType, path35, timeout) {
+      _throttle(actionType, path36, timeout) {
         if (!this._throttled.has(actionType)) {
           this._throttled.set(actionType, /* @__PURE__ */ new Map());
         }
         const action = this._throttled.get(actionType);
         if (!action)
           throw new Error("invalid throttle");
-        const actionPath = action.get(path35);
+        const actionPath = action.get(path36);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path35);
+          const item = action.get(path36);
           const count = item ? item.count : 0;
-          action.delete(path35);
+          action.delete(path36);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -36290,7 +36353,7 @@ var init_chokidar = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path35, thr);
+        action.set(path36, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -36304,44 +36367,44 @@ var init_chokidar = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path35, threshold, event, awfEmit) {
+      _awaitWriteFinish(path36, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path35;
-        if (this.options.cwd && !sp2.isAbsolute(path35)) {
-          fullPath = sp2.join(this.options.cwd, path35);
+        let fullPath = path36;
+        if (this.options.cwd && !sp2.isAbsolute(path36)) {
+          fullPath = sp2.join(this.options.cwd, path36);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-            if (err || !writes.has(path35)) {
+            if (err || !writes.has(path36)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path35).lastChange = now2;
+              writes.get(path36).lastChange = now2;
             }
-            const pw = writes.get(path35);
+            const pw = writes.get(path36);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path35);
+              writes.delete(path36);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path35)) {
-          writes.set(path35, {
+        if (!writes.has(path36)) {
+          writes.set(path36, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path35);
+              writes.delete(path36);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -36352,8 +36415,8 @@ var init_chokidar = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path35, stats) {
-        if (this.options.atomic && DOT_RE.test(path35))
+      _isIgnored(path36, stats) {
+        if (this.options.atomic && DOT_RE.test(path36))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -36363,17 +36426,17 @@ var init_chokidar = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path35, stats);
+        return this._userIgnored(path36, stats);
       }
-      _isntIgnored(path35, stat4) {
-        return !this._isIgnored(path35, stat4);
+      _isntIgnored(path36, stat4) {
+        return !this._isIgnored(path36, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path35) {
-        return new WatchHelper(path35, this.options.followSymlinks, this);
+      _getWatchHelpers(path36) {
+        return new WatchHelper(path36, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -36405,63 +36468,63 @@ var init_chokidar = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path35 = sp2.join(directory, item);
-        const fullPath = sp2.resolve(path35);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path35) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path35, 100))
+        const path36 = sp2.join(directory, item);
+        const fullPath = sp2.resolve(path36);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path36) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path36, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path35);
+        const wp = this._getWatchedDir(path36);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path35, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path36, nested));
         const parent = this._getWatchedDir(directory);
         const wasTracked = parent.has(item);
         parent.remove(item);
         if (this._symlinkPaths.has(fullPath)) {
           this._symlinkPaths.delete(fullPath);
         }
-        let relPath = path35;
+        let relPath = path36;
         if (this.options.cwd)
-          relPath = sp2.relative(this.options.cwd, path35);
+          relPath = sp2.relative(this.options.cwd, path36);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path35);
+        this._watched.delete(path36);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path35))
-          this._emit(eventName, path35);
-        this._closePath(path35);
+        if (wasTracked && !this._isIgnored(path36))
+          this._emit(eventName, path36);
+        this._closePath(path36);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path35) {
-        this._closeFile(path35);
-        const dir = sp2.dirname(path35);
-        this._getWatchedDir(dir).remove(sp2.basename(path35));
+      _closePath(path36) {
+        this._closeFile(path36);
+        const dir = sp2.dirname(path36);
+        this._getWatchedDir(dir).remove(sp2.basename(path36));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path35) {
-        const closers = this._closers.get(path35);
+      _closeFile(path36) {
+        const closers = this._closers.get(path36);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path35);
+        this._closers.delete(path36);
       }
-      _addPathCloser(path35, closer) {
+      _addPathCloser(path36, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path35);
+        let list = this._closers.get(path36);
         if (!list) {
           list = [];
-          this._closers.set(path35, list);
+          this._closers.set(path36, list);
         }
         list.push(closer);
       }
@@ -36722,13 +36785,13 @@ var init_provider_schema = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/providers/provider-loader.ts
-var fs6, path14, os16, ProviderLoader;
+var fs7, path15, os17, ProviderLoader;
 var init_provider_loader = __esm({
   "../../oss/packages/daemon-core/src/providers/provider-loader.ts"() {
     "use strict";
-    fs6 = __toESM(require("fs"));
-    path14 = __toESM(require("path"));
-    os16 = __toESM(require("os"));
+    fs7 = __toESM(require("fs"));
+    path15 = __toESM(require("path"));
+    os17 = __toESM(require("os"));
     init_chokidar();
     init_ide_detector();
     init_logger();
@@ -36762,9 +36825,9 @@ var init_provider_loader = __esm({
       static siblingStderrLogged = /* @__PURE__ */ new Set();
       static looksLikeProviderRoot(candidate) {
         try {
-          if (!fs6.existsSync(candidate) || !fs6.statSync(candidate).isDirectory()) return false;
+          if (!fs7.existsSync(candidate) || !fs7.statSync(candidate).isDirectory()) return false;
           return ["ide", "extension", "cli", "acp"].some(
-            (category) => fs6.existsSync(path14.join(candidate, category))
+            (category) => fs7.existsSync(path15.join(candidate, category))
           );
         } catch {
           return false;
@@ -36772,20 +36835,20 @@ var init_provider_loader = __esm({
       }
       static hasProviderRootMarker(candidate) {
         try {
-          return fs6.existsSync(path14.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
+          return fs7.existsSync(path15.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
         } catch {
           return false;
         }
       }
       detectDefaultUserDir() {
-        const fallback2 = path14.join(os16.homedir(), ".adhdev", "providers");
+        const fallback2 = path15.join(os17.homedir(), ".adhdev", "providers");
         const envOptIn = process.env[_ProviderLoader.SIBLING_ENV_VAR] === "1";
         const visited = /* @__PURE__ */ new Set();
         for (const start of this.probeStarts) {
-          let current = path14.resolve(start);
+          let current = path15.resolve(start);
           while (!visited.has(current)) {
             visited.add(current);
-            const siblingCandidate = path14.join(path14.dirname(current), _ProviderLoader.REPO_PROVIDER_DIRNAME);
+            const siblingCandidate = path15.join(path15.dirname(current), _ProviderLoader.REPO_PROVIDER_DIRNAME);
             if (_ProviderLoader.looksLikeProviderRoot(siblingCandidate)) {
               const hasMarker = _ProviderLoader.hasProviderRootMarker(siblingCandidate);
               if (envOptIn || hasMarker) {
@@ -36807,7 +36870,7 @@ var init_provider_loader = __esm({
                 return { path: siblingCandidate, source };
               }
             }
-            const parent = path14.dirname(current);
+            const parent = path15.dirname(current);
             if (parent === current) break;
             current = parent;
           }
@@ -36817,11 +36880,11 @@ var init_provider_loader = __esm({
       constructor(options) {
         this.logFn = options?.logFn || LOG.forComponent("Provider").asLogFn();
         this.probeStarts = options?.probeStarts ?? [process.cwd(), __dirname];
-        this.defaultProvidersDir = path14.join(os16.homedir(), ".adhdev", "providers");
+        this.defaultProvidersDir = path15.join(os17.homedir(), ".adhdev", "providers");
         const detected = this.detectDefaultUserDir();
         this.userDir = detected.path;
         this.userDirSource = detected.source;
-        this.upstreamDir = path14.join(this.defaultProvidersDir, ".upstream");
+        this.upstreamDir = path15.join(this.defaultProvidersDir, ".upstream");
         this.disableUpstream = false;
         this.applySourceConfig({
           userDir: options?.userDir,
@@ -36880,7 +36943,7 @@ var init_provider_loader = __esm({
           this.userDir = detected.path;
           this.userDirSource = detected.source;
         }
-        this.upstreamDir = path14.join(this.defaultProvidersDir, ".upstream");
+        this.upstreamDir = path15.join(this.defaultProvidersDir, ".upstream");
         this.disableUpstream = this.sourceMode === "no-upstream";
         if (this.explicitProviderDir) {
           this.log(`Config 'providerDir' applied: ${this.userDir}`);
@@ -36894,7 +36957,7 @@ var init_provider_loader = __esm({
       * Canonical provider directory shape for a given root.
       */
       getProviderDir(root, category, type) {
-        return path14.join(root, category, type);
+        return path15.join(root, category, type);
       }
       /**
       * Canonical user override directory for a provider.
@@ -36921,7 +36984,7 @@ var init_provider_loader = __esm({
       resolveProviderFile(type, ...segments) {
         const dir = this.findProviderDirInternal(type);
         if (!dir) return null;
-        return path14.join(dir, ...segments);
+        return path15.join(dir, ...segments);
       }
       /**
       * Load all providers (3-tier priority)
@@ -36934,7 +36997,7 @@ var init_provider_loader = __esm({
         this.providers.clear();
         this.providerAvailability.clear();
         let upstreamCount = 0;
-        if (!this.disableUpstream && fs6.existsSync(this.upstreamDir)) {
+        if (!this.disableUpstream && fs7.existsSync(this.upstreamDir)) {
           upstreamCount = this.loadDir(this.upstreamDir);
           if (upstreamCount > 0) {
             this.log(`Loaded ${upstreamCount} upstream providers (auto-updated)`);
@@ -36942,7 +37005,7 @@ var init_provider_loader = __esm({
         } else if (this.disableUpstream) {
           this.log("Upstream loading disabled (sourceMode=no-upstream)");
         }
-        if (fs6.existsSync(this.userDir)) {
+        if (fs7.existsSync(this.userDir)) {
           const userCount = this.loadDir(this.userDir, [".upstream"]);
           if (userCount > 0) {
             this.log(`Loaded ${userCount} user custom providers (never auto-updated)`);
@@ -36957,10 +37020,10 @@ var init_provider_loader = __esm({
        * Check if upstream directory exists and has providers.
        */
       hasUpstream() {
-        if (!fs6.existsSync(this.upstreamDir)) return false;
+        if (!fs7.existsSync(this.upstreamDir)) return false;
         try {
-          return fs6.readdirSync(this.upstreamDir).some(
-            (d) => fs6.statSync(path14.join(this.upstreamDir, d)).isDirectory()
+          return fs7.readdirSync(this.upstreamDir).some(
+            (d) => fs7.statSync(path15.join(this.upstreamDir, d)).isDirectory()
           );
         } catch {
           return false;
@@ -37457,8 +37520,8 @@ var init_provider_loader = __esm({
                   resolved._resolvedScriptDir = entry.scriptDir;
                   resolved._resolvedScriptsSource = `compatibility:${entry.ideVersion}`;
                   if (providerDir) {
-                    const fullDir = path14.join(providerDir, entry.scriptDir);
-                    resolved._resolvedScriptsPath = fs6.existsSync(path14.join(fullDir, "scripts.js")) ? path14.join(fullDir, "scripts.js") : fullDir;
+                    const fullDir = path15.join(providerDir, entry.scriptDir);
+                    resolved._resolvedScriptsPath = fs7.existsSync(path15.join(fullDir, "scripts.js")) ? path15.join(fullDir, "scripts.js") : fullDir;
                   }
                   matched = true;
                 }
@@ -37473,8 +37536,8 @@ var init_provider_loader = __esm({
                 resolved._resolvedScriptDir = base.defaultScriptDir;
                 resolved._resolvedScriptsSource = "defaultScriptDir:version_miss";
                 if (providerDir) {
-                  const fullDir = path14.join(providerDir, base.defaultScriptDir);
-                  resolved._resolvedScriptsPath = fs6.existsSync(path14.join(fullDir, "scripts.js")) ? path14.join(fullDir, "scripts.js") : fullDir;
+                  const fullDir = path15.join(providerDir, base.defaultScriptDir);
+                  resolved._resolvedScriptsPath = fs7.existsSync(path15.join(fullDir, "scripts.js")) ? path15.join(fullDir, "scripts.js") : fullDir;
                 }
               }
               resolved._versionWarning = `Version ${currentVersion} not in compatibility matrix. Using default scripts.`;
@@ -37491,8 +37554,8 @@ var init_provider_loader = __esm({
                   resolved._resolvedScriptDir = dirOverride;
                   resolved._resolvedScriptsSource = `versions:${range}`;
                   if (providerDir) {
-                    const fullDir = path14.join(providerDir, dirOverride);
-                    resolved._resolvedScriptsPath = fs6.existsSync(path14.join(fullDir, "scripts.js")) ? path14.join(fullDir, "scripts.js") : fullDir;
+                    const fullDir = path15.join(providerDir, dirOverride);
+                    resolved._resolvedScriptsPath = fs7.existsSync(path15.join(fullDir, "scripts.js")) ? path15.join(fullDir, "scripts.js") : fullDir;
                   }
                 }
               } else if (override.scripts) {
@@ -37508,8 +37571,8 @@ var init_provider_loader = __esm({
             resolved._resolvedScriptDir = base.defaultScriptDir;
             resolved._resolvedScriptsSource = "defaultScriptDir:no_version";
             if (providerDir) {
-              const fullDir = path14.join(providerDir, base.defaultScriptDir);
-              resolved._resolvedScriptsPath = fs6.existsSync(path14.join(fullDir, "scripts.js")) ? path14.join(fullDir, "scripts.js") : fullDir;
+              const fullDir = path15.join(providerDir, base.defaultScriptDir);
+              resolved._resolvedScriptsPath = fs7.existsSync(path15.join(fullDir, "scripts.js")) ? path15.join(fullDir, "scripts.js") : fullDir;
             }
           }
         }
@@ -37541,15 +37604,15 @@ var init_provider_loader = __esm({
           this.log(`  [loadScriptsFromDir] ${type}: providerDir not found`);
           return null;
         }
-        const dir = path14.join(providerDir, scriptDir);
-        if (!fs6.existsSync(dir)) {
+        const dir = path15.join(providerDir, scriptDir);
+        if (!fs7.existsSync(dir)) {
           this.log(`  [loadScriptsFromDir] ${type}: dir not found: ${dir}`);
           return null;
         }
         const cached2 = this.scriptsCache.get(dir);
         if (cached2) return cached2;
-        const scriptsJs = path14.join(dir, "scripts.js");
-        if (fs6.existsSync(scriptsJs)) {
+        const scriptsJs = path15.join(dir, "scripts.js");
+        if (fs7.existsSync(scriptsJs)) {
           try {
             delete require.cache[require.resolve(scriptsJs)];
             const loaded = require(scriptsJs);
@@ -37570,9 +37633,9 @@ var init_provider_loader = __esm({
       watch() {
         this.stopWatch();
         const watchDir = (dir) => {
-          if (!fs6.existsSync(dir)) {
+          if (!fs7.existsSync(dir)) {
             try {
-              fs6.mkdirSync(dir, { recursive: true });
+              fs7.mkdirSync(dir, { recursive: true });
             } catch {
               return;
             }
@@ -37590,7 +37653,7 @@ var init_provider_loader = __esm({
                 return;
               }
               if (filePath.endsWith(".js") || filePath.endsWith(".json")) {
-                this.log(`File changed: ${path14.basename(filePath)}, reloading...`);
+                this.log(`File changed: ${path15.basename(filePath)}, reloading...`);
                 this.reload();
               }
             };
@@ -37645,12 +37708,12 @@ var init_provider_loader = __esm({
         }
         const https = require("https");
         const { execSync: execSync8 } = require("child_process");
-        const metaPath = path14.join(this.upstreamDir, _ProviderLoader.META_FILE);
+        const metaPath = path15.join(this.upstreamDir, _ProviderLoader.META_FILE);
         let prevEtag = "";
         let prevTimestamp = 0;
         try {
-          if (fs6.existsSync(metaPath)) {
-            const meta3 = JSON.parse(fs6.readFileSync(metaPath, "utf-8"));
+          if (fs7.existsSync(metaPath)) {
+            const meta3 = JSON.parse(fs7.readFileSync(metaPath, "utf-8"));
             prevEtag = meta3.etag || "";
             prevTimestamp = meta3.timestamp || 0;
           }
@@ -37705,39 +37768,39 @@ var init_provider_loader = __esm({
             return { updated: false };
           }
           this.log("Downloading latest providers from GitHub...");
-          const tmpTar = path14.join(os16.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
-          const tmpExtract = path14.join(os16.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
+          const tmpTar = path15.join(os17.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
+          const tmpExtract = path15.join(os17.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
           await this.downloadFile(_ProviderLoader.GITHUB_TARBALL_URL, tmpTar);
-          fs6.mkdirSync(tmpExtract, { recursive: true });
+          fs7.mkdirSync(tmpExtract, { recursive: true });
           execSync8(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
-          const extracted = fs6.readdirSync(tmpExtract);
+          const extracted = fs7.readdirSync(tmpExtract);
           const rootDir = extracted.find(
-            (d) => fs6.statSync(path14.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
+            (d) => fs7.statSync(path15.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
           );
           if (!rootDir) throw new Error("Unexpected tarball structure");
-          const sourceDir = path14.join(tmpExtract, rootDir);
+          const sourceDir = path15.join(tmpExtract, rootDir);
           const backupDir = this.upstreamDir + ".bak";
-          if (fs6.existsSync(this.upstreamDir)) {
-            if (fs6.existsSync(backupDir)) fs6.rmSync(backupDir, { recursive: true, force: true });
-            fs6.renameSync(this.upstreamDir, backupDir);
+          if (fs7.existsSync(this.upstreamDir)) {
+            if (fs7.existsSync(backupDir)) fs7.rmSync(backupDir, { recursive: true, force: true });
+            fs7.renameSync(this.upstreamDir, backupDir);
           }
           try {
             this.copyDirRecursive(sourceDir, this.upstreamDir);
             this.writeMeta(metaPath, etag || `ts-${Date.now()}`, Date.now());
-            if (fs6.existsSync(backupDir)) fs6.rmSync(backupDir, { recursive: true, force: true });
+            if (fs7.existsSync(backupDir)) fs7.rmSync(backupDir, { recursive: true, force: true });
           } catch (e) {
-            if (fs6.existsSync(backupDir)) {
-              if (fs6.existsSync(this.upstreamDir)) fs6.rmSync(this.upstreamDir, { recursive: true, force: true });
-              fs6.renameSync(backupDir, this.upstreamDir);
+            if (fs7.existsSync(backupDir)) {
+              if (fs7.existsSync(this.upstreamDir)) fs7.rmSync(this.upstreamDir, { recursive: true, force: true });
+              fs7.renameSync(backupDir, this.upstreamDir);
             }
             throw e;
           }
           try {
-            fs6.rmSync(tmpTar, { force: true });
+            fs7.rmSync(tmpTar, { force: true });
           } catch {
           }
           try {
-            fs6.rmSync(tmpExtract, { recursive: true, force: true });
+            fs7.rmSync(tmpExtract, { recursive: true, force: true });
           } catch {
           }
           const upstreamCount = this.countProviders(this.upstreamDir);
@@ -37769,7 +37832,7 @@ var init_provider_loader = __esm({
                 reject(new Error(`HTTP ${res.statusCode}`));
                 return;
               }
-              const ws = fs6.createWriteStream(destPath);
+              const ws = fs7.createWriteStream(destPath);
               res.pipe(ws);
               ws.on("finish", () => {
                 ws.close();
@@ -37788,22 +37851,22 @@ var init_provider_loader = __esm({
       }
       /** Recursive directory copy */
       copyDirRecursive(src, dest) {
-        fs6.mkdirSync(dest, { recursive: true });
-        for (const entry of fs6.readdirSync(src, { withFileTypes: true })) {
-          const srcPath = path14.join(src, entry.name);
-          const destPath = path14.join(dest, entry.name);
+        fs7.mkdirSync(dest, { recursive: true });
+        for (const entry of fs7.readdirSync(src, { withFileTypes: true })) {
+          const srcPath = path15.join(src, entry.name);
+          const destPath = path15.join(dest, entry.name);
           if (entry.isDirectory()) {
             this.copyDirRecursive(srcPath, destPath);
           } else {
-            fs6.copyFileSync(srcPath, destPath);
+            fs7.copyFileSync(srcPath, destPath);
           }
         }
       }
       /** .meta.json save */
       writeMeta(metaPath, etag, timestamp) {
         try {
-          fs6.mkdirSync(path14.dirname(metaPath), { recursive: true });
-          fs6.writeFileSync(metaPath, JSON.stringify({
+          fs7.mkdirSync(path15.dirname(metaPath), { recursive: true });
+          fs7.writeFileSync(metaPath, JSON.stringify({
             etag,
             timestamp,
             lastCheck: new Date(timestamp).toISOString(),
@@ -37814,12 +37877,12 @@ var init_provider_loader = __esm({
       }
       /** Count provider files (provider.js or provider.json) */
       countProviders(dir) {
-        if (!fs6.existsSync(dir)) return 0;
+        if (!fs7.existsSync(dir)) return 0;
         let count = 0;
         const scan = (d) => {
           try {
-            for (const entry of fs6.readdirSync(d, { withFileTypes: true })) {
-              if (entry.isDirectory()) scan(path14.join(d, entry.name));
+            for (const entry of fs7.readdirSync(d, { withFileTypes: true })) {
+              if (entry.isDirectory()) scan(path15.join(d, entry.name));
               else if (entry.name === "provider.json") count++;
             }
           } catch {
@@ -38045,19 +38108,19 @@ var init_provider_loader = __esm({
         const cat = provider.category;
         const searchRoots = this.getProviderRoots();
         for (const root of searchRoots) {
-          if (!fs6.existsSync(root)) continue;
+          if (!fs7.existsSync(root)) continue;
           const candidate = this.getProviderDir(root, cat, type);
-          if (fs6.existsSync(path14.join(candidate, "provider.json"))) return candidate;
-          const catDir = path14.join(root, cat);
-          if (fs6.existsSync(catDir)) {
+          if (fs7.existsSync(path15.join(candidate, "provider.json"))) return candidate;
+          const catDir = path15.join(root, cat);
+          if (fs7.existsSync(catDir)) {
             try {
-              for (const entry of fs6.readdirSync(catDir, { withFileTypes: true })) {
+              for (const entry of fs7.readdirSync(catDir, { withFileTypes: true })) {
                 if (!entry.isDirectory()) continue;
-                const jsonPath = path14.join(catDir, entry.name, "provider.json");
-                if (fs6.existsSync(jsonPath)) {
+                const jsonPath = path15.join(catDir, entry.name, "provider.json");
+                if (fs7.existsSync(jsonPath)) {
                   try {
-                    const data = JSON.parse(fs6.readFileSync(jsonPath, "utf-8"));
-                    if (data.type === type) return path14.join(catDir, entry.name);
+                    const data = JSON.parse(fs7.readFileSync(jsonPath, "utf-8"));
+                    if (data.type === type) return path15.join(catDir, entry.name);
                   } catch {
                   }
                 }
@@ -38074,8 +38137,8 @@ var init_provider_loader = __esm({
        * (template substitution is NOT applied here — scripts.js handles that)
        */
       buildScriptWrappersFromDir(dir) {
-        const scriptsJs = path14.join(dir, "scripts.js");
-        if (fs6.existsSync(scriptsJs)) {
+        const scriptsJs = path15.join(dir, "scripts.js");
+        if (fs7.existsSync(scriptsJs)) {
           try {
             delete require.cache[require.resolve(scriptsJs)];
             return require(scriptsJs);
@@ -38085,13 +38148,13 @@ var init_provider_loader = __esm({
         const toCamel = (name) => name.replace(/_([a-z])/g, (_2, c) => c.toUpperCase());
         const result = {};
         try {
-          for (const file2 of fs6.readdirSync(dir)) {
+          for (const file2 of fs7.readdirSync(dir)) {
             if (!file2.endsWith(".js")) continue;
             const scriptName = toCamel(file2.replace(".js", ""));
-            const filePath = path14.join(dir, file2);
+            const filePath = path15.join(dir, file2);
             result[scriptName] = (...args) => {
               try {
-                let content = fs6.readFileSync(filePath, "utf-8");
+                let content = fs7.readFileSync(filePath, "utf-8");
                 if (args[0] && typeof args[0] === "object") {
                   for (const [key, val] of Object.entries(args[0])) {
                     let v = val;
@@ -38137,20 +38200,20 @@ var init_provider_loader = __esm({
        * Structure: dir/category/agent-name/provider.{json,js}
        */
       loadDir(dir, excludeDirs) {
-        if (!fs6.existsSync(dir)) return 0;
+        if (!fs7.existsSync(dir)) return 0;
         let count = 0;
         const scan = (d) => {
           let entries;
           try {
-            entries = fs6.readdirSync(d, { withFileTypes: true });
+            entries = fs7.readdirSync(d, { withFileTypes: true });
           } catch {
             return;
           }
           const hasJson = entries.some((e) => e.name === "provider.json");
           if (hasJson) {
-            const jsonPath = path14.join(d, "provider.json");
+            const jsonPath = path15.join(d, "provider.json");
             try {
-              const raw = fs6.readFileSync(jsonPath, "utf-8");
+              const raw = fs7.readFileSync(jsonPath, "utf-8");
               const mod = JSON.parse(raw);
               if (typeof mod.extensionIdPattern === "string") {
                 const flags = mod.extensionIdPattern_flags || "";
@@ -38169,8 +38232,8 @@ var init_provider_loader = __esm({
                 this.log(`\u26A0 Invalid provider at ${jsonPath}: ${validation.errors.join("; ")}`);
               } else {
                 const hasCompatibility = Array.isArray(normalizedProvider.compatibility);
-                const scriptsPath = path14.join(d, "scripts.js");
-                if (!hasCompatibility && fs6.existsSync(scriptsPath)) {
+                const scriptsPath = path15.join(d, "scripts.js");
+                if (!hasCompatibility && fs7.existsSync(scriptsPath)) {
                   try {
                     delete require.cache[require.resolve(scriptsPath)];
                     const scripts = require(scriptsPath);
@@ -38195,7 +38258,7 @@ var init_provider_loader = __esm({
               if (!entry.isDirectory()) continue;
               if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
               if (excludeDirs && d === dir && excludeDirs.includes(entry.name)) continue;
-              scan(path14.join(d, entry.name));
+              scan(path15.join(d, entry.name));
             }
           }
         };
@@ -38391,7 +38454,7 @@ async function isCdpActive(port) {
   });
 }
 async function killIdeProcess(ideId) {
-  const plat = os17.platform();
+  const plat = os18.platform();
   const appName = getMacAppIdentifiers()[ideId];
   const winProcesses = getWinProcessNames()[ideId];
   try {
@@ -38452,7 +38515,7 @@ async function killIdeProcess(ideId) {
   }
 }
 function isIdeRunning(ideId) {
-  const plat = os17.platform();
+  const plat = os18.platform();
   try {
     if (plat === "darwin") {
       const appName = getMacAppIdentifiers()[ideId];
@@ -38507,7 +38570,7 @@ function isIdeRunning(ideId) {
   }
 }
 function detectCurrentWorkspace(ideId) {
-  const plat = os17.platform();
+  const plat = os18.platform();
   if (plat === "darwin") {
     try {
       const appName = getMacAppIdentifiers()[ideId];
@@ -38522,17 +38585,17 @@ function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs22 = require("fs");
+      const fs23 = require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
-        const storagePath = path15.join(
-          process.env.APPDATA || path15.join(os17.homedir(), "AppData", "Roaming"),
+        const storagePath = path16.join(
+          process.env.APPDATA || path16.join(os18.homedir(), "AppData", "Roaming"),
           appName,
           "storage.json"
         );
-        if (fs22.existsSync(storagePath)) {
-          const data = JSON.parse(fs22.readFileSync(storagePath, "utf-8"));
+        if (fs23.existsSync(storagePath)) {
+          const data = JSON.parse(fs23.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -38549,7 +38612,7 @@ function detectCurrentWorkspace(ideId) {
   return void 0;
 }
 async function launchWithCdp(options = {}) {
-  const platform12 = os17.platform();
+  const platform12 = os18.platform();
   let targetIde;
   const ides = await detectIDEs(getProviderLoader());
   if (options.ideId) {
@@ -38698,14 +38761,14 @@ async function launchLinux(ide, port, workspace, newWindow) {
 function getAvailableIdeIds() {
   return getProviderLoader().getAvailableIdeTypes();
 }
-var import_child_process7, net2, os17, path15, _providerLoader;
+var import_child_process7, net2, os18, path16, _providerLoader;
 var init_launch = __esm({
   "../../oss/packages/daemon-core/src/launch.ts"() {
     "use strict";
     import_child_process7 = require("child_process");
     net2 = __toESM(require("net"));
-    os17 = __toESM(require("os"));
-    path15 = __toESM(require("path"));
+    os18 = __toESM(require("os"));
+    path16 = __toESM(require("path"));
     init_ide_detector();
     init_provider_loader();
     init_macos_app_process();
@@ -38737,13 +38800,13 @@ function checkRotation() {
   const today = getDateStr2();
   if (today !== currentDate2) {
     currentDate2 = today;
-    currentFile = path16.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+    currentFile = path17.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
     cleanOldFiles();
   }
 }
 function cleanOldFiles() {
   try {
-    const files = fs7.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
+    const files = fs8.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
     const cutoff = /* @__PURE__ */ new Date();
     cutoff.setDate(cutoff.getDate() - MAX_DAYS);
     const cutoffStr = cutoff.toISOString().slice(0, 10);
@@ -38751,7 +38814,7 @@ function cleanOldFiles() {
       const dateMatch = file2.match(/commands-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs7.unlinkSync(path16.join(LOG_DIR2, file2));
+          fs8.unlinkSync(path17.join(LOG_DIR2, file2));
         } catch {
         }
       }
@@ -38761,14 +38824,14 @@ function cleanOldFiles() {
 }
 function checkSize() {
   try {
-    const stat4 = fs7.statSync(currentFile);
+    const stat4 = fs8.statSync(currentFile);
     if (stat4.size > MAX_FILE_SIZE) {
       const backup = currentFile.replace(".jsonl", ".1.jsonl");
       try {
-        fs7.unlinkSync(backup);
+        fs8.unlinkSync(backup);
       } catch {
       }
-      fs7.renameSync(currentFile, backup);
+      fs8.renameSync(currentFile, backup);
     }
   } catch {
   }
@@ -38793,14 +38856,14 @@ function logCommand(entry) {
       ...entry.error ? { err: entry.error } : {},
       ...entry.durationMs !== void 0 ? { ms: entry.durationMs } : {}
     });
-    fs7.appendFileSync(currentFile, line + "\n");
+    fs8.appendFileSync(currentFile, line + "\n");
   } catch {
   }
 }
 function getRecentCommands(count = 50) {
   try {
-    if (!fs7.existsSync(currentFile)) return [];
-    const content = fs7.readFileSync(currentFile, "utf-8");
+    if (!fs8.existsSync(currentFile)) return [];
+    const content = fs8.readFileSync(currentFile, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     return lines.slice(-count).map((line) => {
       try {
@@ -38823,18 +38886,18 @@ function getRecentCommands(count = 50) {
     return [];
   }
 }
-var fs7, path16, os18, LOG_DIR2, MAX_FILE_SIZE, MAX_DAYS, SENSITIVE_KEYS, currentDate2, currentFile, writeCount2, SKIP_COMMANDS;
+var fs8, path17, os19, LOG_DIR2, MAX_FILE_SIZE, MAX_DAYS, SENSITIVE_KEYS, currentDate2, currentFile, writeCount2, SKIP_COMMANDS;
 var init_command_log = __esm({
   "../../oss/packages/daemon-core/src/logging/command-log.ts"() {
     "use strict";
-    fs7 = __toESM(require("fs"));
-    path16 = __toESM(require("path"));
-    os18 = __toESM(require("os"));
-    LOG_DIR2 = process.platform === "win32" ? path16.join(process.env.LOCALAPPDATA || process.env.APPDATA || path16.join(os18.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path16.join(os18.homedir(), "Library", "Logs", "adhdev") : path16.join(os18.homedir(), ".local", "share", "adhdev", "logs");
+    fs8 = __toESM(require("fs"));
+    path17 = __toESM(require("path"));
+    os19 = __toESM(require("os"));
+    LOG_DIR2 = process.platform === "win32" ? path17.join(process.env.LOCALAPPDATA || process.env.APPDATA || path17.join(os19.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path17.join(os19.homedir(), "Library", "Logs", "adhdev") : path17.join(os19.homedir(), ".local", "share", "adhdev", "logs");
     MAX_FILE_SIZE = 5 * 1024 * 1024;
     MAX_DAYS = 7;
     try {
-      fs7.mkdirSync(LOG_DIR2, { recursive: true });
+      fs8.mkdirSync(LOG_DIR2, { recursive: true });
     } catch {
     }
     SENSITIVE_KEYS = /* @__PURE__ */ new Set([
@@ -38849,7 +38912,7 @@ var init_command_log = __esm({
       "text"
     ]);
     currentDate2 = getDateStr2();
-    currentFile = path16.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+    currentFile = path17.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
     writeCount2 = 0;
     SKIP_COMMANDS = /* @__PURE__ */ new Set([
       "heartbeat",
@@ -38913,8 +38976,8 @@ function buildAvailableProviders(providerLoader) {
 }
 function buildMachineInfo(profile = "full") {
   const base = {
-    hostname: os19.hostname(),
-    platform: os19.platform()
+    hostname: os20.hostname(),
+    platform: os20.platform()
   };
   if (profile === "live") {
     return base;
@@ -38923,23 +38986,23 @@ function buildMachineInfo(profile = "full") {
     const memSnap2 = getHostMemorySnapshot();
     return {
       ...base,
-      arch: os19.arch(),
-      cpus: os19.cpus().length,
+      arch: os20.arch(),
+      cpus: os20.cpus().length,
       totalMem: memSnap2.totalMem,
-      release: os19.release()
+      release: os20.release()
     };
   }
   const memSnap = getHostMemorySnapshot();
   return {
     ...base,
-    arch: os19.arch(),
-    cpus: os19.cpus().length,
+    arch: os20.arch(),
+    cpus: os20.cpus().length,
     totalMem: memSnap.totalMem,
     freeMem: memSnap.freeMem,
     availableMem: memSnap.availableMem,
-    loadavg: os19.loadavg(),
-    uptime: os19.uptime(),
-    release: os19.release()
+    loadavg: os20.loadavg(),
+    uptime: os20.uptime(),
+    release: os20.release()
   };
 }
 function parseMessageTime(value) {
@@ -39162,11 +39225,11 @@ function buildStatusSnapshot(options) {
     }
   };
 }
-var os19, READ_DEBUG_ENABLED, recentReadDebugSignatureBySession;
+var os20, READ_DEBUG_ENABLED, recentReadDebugSignatureBySession;
 var init_snapshot = __esm({
   "../../oss/packages/daemon-core/src/status/snapshot.ts"() {
     "use strict";
-    os19 = __toESM(require("os"));
+    os20 = __toESM(require("os"));
     init_config();
     init_state_store();
     init_recent_activity();
@@ -39184,37 +39247,37 @@ var init_snapshot = __esm({
 
 // ../../oss/packages/daemon-core/src/commands/upgrade-helper.ts
 function getUpgradeLogPath() {
-  const home = os20.homedir();
-  const dir = path17.join(home, ".adhdev");
-  fs8.mkdirSync(dir, { recursive: true });
-  return path17.join(dir, "daemon-upgrade.log");
+  const home = os21.homedir();
+  const dir = path18.join(home, ".adhdev");
+  fs9.mkdirSync(dir, { recursive: true });
+  return path18.join(dir, "daemon-upgrade.log");
 }
 function appendUpgradeLog(message) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
 `;
   try {
-    fs8.appendFileSync(getUpgradeLogPath(), line, "utf8");
+    fs9.appendFileSync(getUpgradeLogPath(), line, "utf8");
   } catch {
   }
 }
 function resolveSiblingNpmInvocation(nodeExecutable, platform12 = process.platform) {
-  const binDir = path17.dirname(nodeExecutable);
+  const binDir = path18.dirname(nodeExecutable);
   if (platform12 === "win32") {
-    const npmCliPath = path17.join(binDir, "node_modules", "npm", "bin", "npm-cli.js");
-    if (fs8.existsSync(npmCliPath)) {
+    const npmCliPath = path18.join(binDir, "node_modules", "npm", "bin", "npm-cli.js");
+    if (fs9.existsSync(npmCliPath)) {
       return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform12) };
     }
     for (const candidate of ["npm.exe", "npm"]) {
-      const candidatePath = path17.join(binDir, candidate);
-      if (fs8.existsSync(candidatePath)) {
+      const candidatePath = path18.join(binDir, candidate);
+      if (fs9.existsSync(candidatePath)) {
         return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform12) };
       }
     }
     return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform12) };
   }
   for (const candidate of ["npm"]) {
-    const candidatePath = path17.join(binDir, candidate);
-    if (fs8.existsSync(candidatePath)) {
+    const candidatePath = path18.join(binDir, candidate);
+    if (fs9.existsSync(candidatePath)) {
       return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform12) };
     }
   }
@@ -39224,22 +39287,22 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
   if (!currentCliPath) return null;
   let resolvedPath = currentCliPath;
   try {
-    resolvedPath = fs8.realpathSync.native(currentCliPath);
+    resolvedPath = fs9.realpathSync.native(currentCliPath);
   } catch {
   }
   let currentDir = resolvedPath;
   try {
-    if (fs8.statSync(resolvedPath).isFile()) {
-      currentDir = path17.dirname(resolvedPath);
+    if (fs9.statSync(resolvedPath).isFile()) {
+      currentDir = path18.dirname(resolvedPath);
     }
   } catch {
-    currentDir = path17.dirname(resolvedPath);
+    currentDir = path18.dirname(resolvedPath);
   }
   while (true) {
-    const packageJsonPath = path17.join(currentDir, "package.json");
+    const packageJsonPath = path18.join(currentDir, "package.json");
     try {
-      if (fs8.existsSync(packageJsonPath)) {
-        const parsed = JSON.parse(fs8.readFileSync(packageJsonPath, "utf8"));
+      if (fs9.existsSync(packageJsonPath)) {
+        const parsed = JSON.parse(fs9.readFileSync(packageJsonPath, "utf8"));
         if (parsed?.name === packageName) {
           const normalized = currentDir.replace(/\\/g, "/");
           return normalized.includes("/node_modules/") ? currentDir : null;
@@ -39247,7 +39310,7 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
       }
     } catch {
     }
-    const parentDir = path17.dirname(currentDir);
+    const parentDir = path18.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -39255,13 +39318,13 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
   }
 }
 function resolveInstallPrefixFromPackageRoot(packageRoot, packageName) {
-  const nodeModulesDir = packageName.startsWith("@") ? path17.dirname(path17.dirname(packageRoot)) : path17.dirname(packageRoot);
-  if (path17.basename(nodeModulesDir) !== "node_modules") {
+  const nodeModulesDir = packageName.startsWith("@") ? path18.dirname(path18.dirname(packageRoot)) : path18.dirname(packageRoot);
+  if (path18.basename(nodeModulesDir) !== "node_modules") {
     return null;
   }
-  const maybeLibDir = path17.dirname(nodeModulesDir);
-  if (path17.basename(maybeLibDir) === "lib") {
-    return path17.dirname(maybeLibDir);
+  const maybeLibDir = path18.dirname(nodeModulesDir);
+  if (path18.basename(maybeLibDir) === "lib") {
+    return path18.dirname(maybeLibDir);
   }
   return maybeLibDir;
 }
@@ -39376,10 +39439,10 @@ async function waitForPidExit(pid, timeoutMs) {
   }
 }
 function stopSessionHostProcesses(appName) {
-  const pidFile = path17.join(os20.homedir(), ".adhdev", `${appName}-session-host.pid`);
+  const pidFile = path18.join(os21.homedir(), ".adhdev", `${appName}-session-host.pid`);
   try {
-    if (fs8.existsSync(pidFile)) {
-      const pid = Number.parseInt(fs8.readFileSync(pidFile, "utf8").trim(), 10);
+    if (fs9.existsSync(pidFile)) {
+      const pid = Number.parseInt(fs9.readFileSync(pidFile, "utf8").trim(), 10);
       if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
         killPid(pid);
       }
@@ -39387,15 +39450,15 @@ function stopSessionHostProcesses(appName) {
   } catch {
   } finally {
     try {
-      fs8.unlinkSync(pidFile);
+      fs9.unlinkSync(pidFile);
     } catch {
     }
   }
 }
 function removeDaemonPidFile() {
-  const pidFile = path17.join(os20.homedir(), ".adhdev", "daemon.pid");
+  const pidFile = path18.join(os21.homedir(), ".adhdev", "daemon.pid");
   try {
-    fs8.unlinkSync(pidFile);
+    fs9.unlinkSync(pidFile);
   } catch {
   }
 }
@@ -39404,7 +39467,7 @@ function cleanupStaleGlobalInstallDirs(pkgName, surface) {
   const npmRoot = String(execNpmCommandSync(["root", "-g", ...prefixArgs], { encoding: "utf8" }, surface)).trim();
   if (!npmRoot) return;
   const npmPrefix = surface.installPrefix || String(execNpmCommandSync(["prefix", "-g", ...prefixArgs], { encoding: "utf8" }, surface)).trim();
-  const binDir = process.platform === "win32" ? npmPrefix : path17.join(npmPrefix, "bin");
+  const binDir = process.platform === "win32" ? npmPrefix : path18.join(npmPrefix, "bin");
   const packageBaseName = pkgName.startsWith("@") ? pkgName.split("/")[1] : pkgName;
   const binNames = /* @__PURE__ */ new Set([packageBaseName]);
   if (pkgName === "@adhdev/daemon-standalone") {
@@ -39412,25 +39475,25 @@ function cleanupStaleGlobalInstallDirs(pkgName, surface) {
   }
   if (pkgName.startsWith("@")) {
     const [scope, name] = pkgName.split("/");
-    const scopeDir = path17.join(npmRoot, scope);
-    if (!fs8.existsSync(scopeDir)) return;
-    for (const entry of fs8.readdirSync(scopeDir)) {
+    const scopeDir = path18.join(npmRoot, scope);
+    if (!fs9.existsSync(scopeDir)) return;
+    for (const entry of fs9.readdirSync(scopeDir)) {
       if (!entry.startsWith(`.${name}-`)) continue;
-      fs8.rmSync(path17.join(scopeDir, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale scoped staging dir: ${path17.join(scopeDir, entry)}`);
+      fs9.rmSync(path18.join(scopeDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale scoped staging dir: ${path18.join(scopeDir, entry)}`);
     }
   } else {
-    for (const entry of fs8.readdirSync(npmRoot)) {
+    for (const entry of fs9.readdirSync(npmRoot)) {
       if (!entry.startsWith(`.${pkgName}-`)) continue;
-      fs8.rmSync(path17.join(npmRoot, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale staging dir: ${path17.join(npmRoot, entry)}`);
+      fs9.rmSync(path18.join(npmRoot, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale staging dir: ${path18.join(npmRoot, entry)}`);
     }
   }
-  if (fs8.existsSync(binDir)) {
-    for (const entry of fs8.readdirSync(binDir)) {
+  if (fs9.existsSync(binDir)) {
+    for (const entry of fs9.readdirSync(binDir)) {
       if (!Array.from(binNames).some((name) => entry.startsWith(`.${name}-`))) continue;
-      fs8.rmSync(path17.join(binDir, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale bin staging entry: ${path17.join(binDir, entry)}`);
+      fs9.rmSync(path18.join(binDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale bin staging entry: ${path18.join(binDir, entry)}`);
     }
   }
 }
@@ -39513,15 +39576,15 @@ async function maybeRunDaemonUpgradeHelperFromEnv() {
     process.exit(1);
   }
 }
-var import_child_process8, import_child_process9, fs8, os20, path17, UPGRADE_HELPER_ENV;
+var import_child_process8, import_child_process9, fs9, os21, path18, UPGRADE_HELPER_ENV;
 var init_upgrade_helper = __esm({
   "../../oss/packages/daemon-core/src/commands/upgrade-helper.ts"() {
     "use strict";
     import_child_process8 = require("child_process");
     import_child_process9 = require("child_process");
-    fs8 = __toESM(require("fs"));
-    os20 = __toESM(require("os"));
-    path17 = __toESM(require("path"));
+    fs9 = __toESM(require("fs"));
+    os21 = __toESM(require("os"));
+    path18 = __toESM(require("path"));
     UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
   }
 });
@@ -39608,7 +39671,7 @@ function summarizeSessionHostPruneResult(result) {
     keptCount: Array.isArray(value.keptSessionIds) ? value.keptSessionIds.length : void 0
   };
 }
-var fs9, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
+var fs10, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
 var init_router = __esm({
   "../../oss/packages/daemon-core/src/commands/router.ts"() {
     "use strict";
@@ -39633,7 +39696,7 @@ var init_router = __esm({
     init_snapshot();
     init_snapshot();
     init_upgrade_helper();
-    fs9 = __toESM(require("fs"));
+    fs10 = __toESM(require("fs"));
     CHAT_COMMANDS = [
       "send_chat",
       "new_chat",
@@ -39788,8 +39851,8 @@ var init_router = __esm({
               if (sinceTs > 0) {
                 return { success: true, logs: [], totalBuffered: 0 };
               }
-              if (fs9.existsSync(LOG_PATH)) {
-                const content = fs9.readFileSync(LOG_PATH, "utf-8");
+              if (fs10.existsSync(LOG_PATH)) {
+                const content = fs10.readFileSync(LOG_PATH, "utf-8");
                 const allLines = content.split("\n");
                 const recent = allLines.slice(-count).join("\n");
                 return { success: true, logs: recent, totalLines: allLines.length };
@@ -42067,19 +42130,19 @@ function getVersion(binary, versionCommand) {
 function checkPathExists2(paths) {
   for (const p of paths) {
     if (p.includes("*")) {
-      const home = os21.homedir();
-      const resolved = p.replace(/\*/g, home.split(path18.sep).pop() || "");
-      if (fs10.existsSync(resolved)) return resolved;
+      const home = os23.homedir();
+      const resolved = p.replace(/\*/g, home.split(path19.sep).pop() || "");
+      if (fs11.existsSync(resolved)) return resolved;
     } else {
-      if (fs10.existsSync(p)) return p;
+      if (fs11.existsSync(p)) return p;
     }
   }
   return null;
 }
 function getMacAppVersion(appPath) {
   if ((0, import_os3.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
-  const plistPath = path18.join(appPath, "Contents", "Info.plist");
-  if (!fs10.existsSync(plistPath)) return null;
+  const plistPath = path19.join(appPath, "Contents", "Info.plist");
+  if (!fs11.existsSync(plistPath)) return null;
   const raw = runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
 }
@@ -42104,8 +42167,8 @@ async function detectAllVersions(loader, archive) {
       const cliBin = provider.cli ? findBinary2(provider.cli) : null;
       let resolvedBin = cliBin;
       if (!resolvedBin && appPath && currentOs === "darwin") {
-        const bundled = path18.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-        if (provider.cli && fs10.existsSync(bundled)) resolvedBin = bundled;
+        const bundled = path19.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
+        if (provider.cli && fs11.existsSync(bundled)) resolvedBin = bundled;
       }
       info.installed = !!(appPath || resolvedBin);
       info.path = appPath || null;
@@ -42141,16 +42204,16 @@ async function detectAllVersions(loader, archive) {
   }
   return results;
 }
-var fs10, path18, os21, import_child_process10, import_os3, ARCHIVE_PATH, MAX_ENTRIES_PER_PROVIDER, VersionArchive;
+var fs11, path19, os23, import_child_process10, import_os3, ARCHIVE_PATH, MAX_ENTRIES_PER_PROVIDER, VersionArchive;
 var init_version_archive = __esm({
   "../../oss/packages/daemon-core/src/providers/version-archive.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs"));
-    path18 = __toESM(require("path"));
-    os21 = __toESM(require("os"));
+    fs11 = __toESM(require("fs"));
+    path19 = __toESM(require("path"));
+    os23 = __toESM(require("os"));
     import_child_process10 = require("child_process");
     import_os3 = require("os");
-    ARCHIVE_PATH = path18.join(os21.homedir(), ".adhdev", "version-history.json");
+    ARCHIVE_PATH = path19.join(os23.homedir(), ".adhdev", "version-history.json");
     MAX_ENTRIES_PER_PROVIDER = 20;
     VersionArchive = class {
       history = {};
@@ -42159,8 +42222,8 @@ var init_version_archive = __esm({
       }
       load() {
         try {
-          if (fs10.existsSync(ARCHIVE_PATH)) {
-            this.history = JSON.parse(fs10.readFileSync(ARCHIVE_PATH, "utf-8"));
+          if (fs11.existsSync(ARCHIVE_PATH)) {
+            this.history = JSON.parse(fs11.readFileSync(ARCHIVE_PATH, "utf-8"));
           }
         } catch {
           this.history = {};
@@ -42197,8 +42260,8 @@ var init_version_archive = __esm({
       }
       save() {
         try {
-          fs10.mkdirSync(path18.dirname(ARCHIVE_PATH), { recursive: true });
-          fs10.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
+          fs11.mkdirSync(path19.dirname(ARCHIVE_PATH), { recursive: true });
+          fs11.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
         } catch {
         }
       }
@@ -42732,18 +42795,18 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   let scriptsPath = "";
-  const directScripts = path19.join(dir, "scripts.js");
-  if (fs11.existsSync(directScripts)) {
+  const directScripts = path20.join(dir, "scripts.js");
+  if (fs12.existsSync(directScripts)) {
     scriptsPath = directScripts;
   } else {
-    const scriptsDir = path19.join(dir, "scripts");
-    if (fs11.existsSync(scriptsDir)) {
-      const versions = fs11.readdirSync(scriptsDir).filter((d) => {
-        return fs11.statSync(path19.join(scriptsDir, d)).isDirectory();
+    const scriptsDir = path20.join(dir, "scripts");
+    if (fs12.existsSync(scriptsDir)) {
+      const versions = fs12.readdirSync(scriptsDir).filter((d) => {
+        return fs12.statSync(path20.join(scriptsDir, d)).isDirectory();
       }).sort().reverse();
       for (const ver of versions) {
-        const p = path19.join(scriptsDir, ver, "scripts.js");
-        if (fs11.existsSync(p)) {
+        const p = path20.join(scriptsDir, ver, "scripts.js");
+        if (fs12.existsSync(p)) {
           scriptsPath = p;
           break;
         }
@@ -42755,7 +42818,7 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   try {
-    const source = fs11.readFileSync(scriptsPath, "utf-8");
+    const source = fs12.readFileSync(scriptsPath, "utf-8");
     const hints = {};
     const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
     let match;
@@ -43568,12 +43631,12 @@ async function handleDomContext(ctx, type, req, res) {
     ctx.json(res, 500, { error: `DOM context collection failed: ${e.message}` });
   }
 }
-var fs11, path19;
+var fs12, path20;
 var init_dev_cdp_handlers = __esm({
   "../../oss/packages/daemon-core/src/daemon/dev-cdp-handlers.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs"));
-    path19 = __toESM(require("path"));
+    fs12 = __toESM(require("fs"));
+    path20 = __toESM(require("path"));
     init_logger();
   }
 });
@@ -43588,15 +43651,15 @@ function getCliFixtureDir(ctx, type) {
   if (!providerDir) {
     throw new Error(`Provider directory not found for '${type}'`);
   }
-  return path20.join(providerDir, "fixtures");
+  return path21.join(providerDir, "fixtures");
 }
 function readCliFixture(ctx, type, name) {
   const fixtureDir = getCliFixtureDir(ctx, type);
-  const filePath = path20.join(fixtureDir, `${name}.json`);
-  if (!fs12.existsSync(filePath)) {
+  const filePath = path21.join(fixtureDir, `${name}.json`);
+  if (!fs13.existsSync(filePath)) {
     throw new Error(`Fixture not found: ${filePath}`);
   }
-  return JSON.parse(fs12.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs13.readFileSync(filePath, "utf-8"));
 }
 function getExerciseTranscriptText(result) {
   const parts = [];
@@ -44332,7 +44395,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       return;
     }
     const fixtureDir = getCliFixtureDir(ctx, type);
-    fs12.mkdirSync(fixtureDir, { recursive: true });
+    fs13.mkdirSync(fixtureDir, { recursive: true });
     const name = slugifyFixtureName(String(body?.name || `${type}-${Date.now()}`));
     const result = await runCliExerciseInternal(ctx, { ...request, type });
     const fixture = {
@@ -44359,8 +44422,8 @@ async function handleCliFixtureCapture(ctx, req, res) {
       },
       notes: typeof body?.notes === "string" ? body.notes : void 0
     };
-    const filePath = path20.join(fixtureDir, `${name}.json`);
-    fs12.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+    const filePath = path21.join(fixtureDir, `${name}.json`);
+    fs13.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
     ctx.json(res, 200, {
       saved: true,
       name,
@@ -44378,14 +44441,14 @@ async function handleCliFixtureCapture(ctx, req, res) {
 async function handleCliFixtureList(ctx, type, _req, res) {
   try {
     const fixtureDir = getCliFixtureDir(ctx, type);
-    if (!fs12.existsSync(fixtureDir)) {
+    if (!fs13.existsSync(fixtureDir)) {
       ctx.json(res, 200, { fixtures: [], count: 0 });
       return;
     }
-    const fixtures = fs12.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
-      const fullPath = path20.join(fixtureDir, file2);
+    const fixtures = fs13.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
+      const fullPath = path21.join(fixtureDir, file2);
       try {
-        const raw = JSON.parse(fs12.readFileSync(fullPath, "utf-8"));
+        const raw = JSON.parse(fs13.readFileSync(fullPath, "utf-8"));
         return {
           name: raw.name || file2.replace(/\.json$/i, ""),
           path: fullPath,
@@ -44516,12 +44579,12 @@ async function handleCliRaw(ctx, req, res) {
     ctx.json(res, 500, { error: `Raw send failed: ${e.message}` });
   }
 }
-var fs12, path20;
+var fs13, path21;
 var init_dev_cli_debug = __esm({
   "../../oss/packages/daemon-core/src/daemon/dev-cli-debug.ts"() {
     "use strict";
-    fs12 = __toESM(require("fs"));
-    path20 = __toESM(require("path"));
+    fs13 = __toESM(require("fs"));
+    path21 = __toESM(require("path"));
   }
 });
 
@@ -44571,38 +44634,38 @@ function resolveAutoImplReference(ctx, category, requestedReference, targetType)
   return fallback2?.type || null;
 }
 function getLatestScriptVersionDir(scriptsDir) {
-  if (!fs13.existsSync(scriptsDir)) return null;
-  const versions = fs13.readdirSync(scriptsDir).filter((d) => {
+  if (!fs14.existsSync(scriptsDir)) return null;
+  const versions = fs14.readdirSync(scriptsDir).filter((d) => {
     try {
-      return fs13.statSync(path21.join(scriptsDir, d)).isDirectory();
+      return fs14.statSync(path23.join(scriptsDir, d)).isDirectory();
     } catch {
       return false;
     }
   }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
   if (versions.length === 0) return null;
-  return path21.join(scriptsDir, versions[0]);
+  return path23.join(scriptsDir, versions[0]);
 }
 function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
-  const canonicalUserDir = path21.resolve(ctx.providerLoader.getUserProviderDir(category, type));
-  const desiredDir = requestedDir ? path21.resolve(requestedDir) : canonicalUserDir;
-  const upstreamRoot = path21.resolve(ctx.providerLoader.getUpstreamDir());
-  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path21.sep}`)) {
+  const canonicalUserDir = path23.resolve(ctx.providerLoader.getUserProviderDir(category, type));
+  const desiredDir = requestedDir ? path23.resolve(requestedDir) : canonicalUserDir;
+  const upstreamRoot = path23.resolve(ctx.providerLoader.getUpstreamDir());
+  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path23.sep}`)) {
     return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
   }
-  if (path21.basename(desiredDir) !== type) {
+  if (path23.basename(desiredDir) !== type) {
     return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
   }
   const sourceDir = ctx.findProviderDir(type);
   if (!sourceDir) {
     return { dir: null, reason: `Provider source directory not found for '${type}'` };
   }
-  if (!fs13.existsSync(desiredDir)) {
-    fs13.mkdirSync(path21.dirname(desiredDir), { recursive: true });
-    fs13.cpSync(sourceDir, desiredDir, { recursive: true });
+  if (!fs14.existsSync(desiredDir)) {
+    fs14.mkdirSync(path23.dirname(desiredDir), { recursive: true });
+    fs14.cpSync(sourceDir, desiredDir, { recursive: true });
     ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
   }
-  const providerJson = path21.join(desiredDir, "provider.json");
-  if (!fs13.existsSync(providerJson)) {
+  const providerJson = path23.join(desiredDir, "provider.json");
+  if (!fs14.existsSync(providerJson)) {
     return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
   }
   return { dir: desiredDir };
@@ -44610,15 +44673,15 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
 function loadAutoImplReferenceScripts(ctx, referenceType) {
   if (!referenceType) return {};
   const refDir = ctx.findProviderDir(referenceType);
-  if (!refDir || !fs13.existsSync(refDir)) return {};
+  if (!refDir || !fs14.existsSync(refDir)) return {};
   const referenceScripts = {};
-  const scriptsDir = path21.join(refDir, "scripts");
+  const scriptsDir = path23.join(refDir, "scripts");
   const latestDir = getLatestScriptVersionDir(scriptsDir);
   if (!latestDir) return referenceScripts;
-  for (const file2 of fs13.readdirSync(latestDir)) {
+  for (const file2 of fs14.readdirSync(latestDir)) {
     if (!file2.endsWith(".js")) continue;
     try {
-      referenceScripts[file2] = fs13.readFileSync(path21.join(latestDir, file2), "utf-8");
+      referenceScripts[file2] = fs14.readFileSync(path23.join(latestDir, file2), "utf-8");
     } catch {
     }
   }
@@ -44726,16 +44789,16 @@ async function handleAutoImplement(ctx, type, req, res) {
     });
     const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
     const prompt2 = buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
-    const tmpDir = path21.join(os23.tmpdir(), "adhdev-autoimpl");
-    if (!fs13.existsSync(tmpDir)) fs13.mkdirSync(tmpDir, { recursive: true });
-    const promptFile = path21.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
-    fs13.writeFileSync(promptFile, prompt2, "utf-8");
+    const tmpDir = path23.join(os24.tmpdir(), "adhdev-autoimpl");
+    if (!fs14.existsSync(tmpDir)) fs14.mkdirSync(tmpDir, { recursive: true });
+    const promptFile = path23.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
+    fs14.writeFileSync(promptFile, prompt2, "utf-8");
     ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt2.length} chars)`);
     const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
     const spawn6 = agentProvider?.spawn;
     if (!spawn6?.command) {
       try {
-        fs13.unlinkSync(promptFile);
+        fs14.unlinkSync(promptFile);
       } catch {
       }
       ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -44837,7 +44900,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs13.unlinkSync(promptFile);
+          fs14.unlinkSync(promptFile);
         } catch {
         }
         ctx.log(`Auto-implement (ACP) ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -44881,7 +44944,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     const interactiveFlags = ["--yolo", "--interactive", "-i"];
     const baseArgs = [...spawn6.args || []].filter((a) => !interactiveFlags.includes(a));
     let shellCmd;
-    const isWin = os23.platform() === "win32";
+    const isWin = os24.platform() === "win32";
     const escapeArg = (a) => isWin ? `"${a.replace(/"/g, '""')}"` : `'${a.replace(/'/g, "'\\''")}'`;
     const promptMode = autoImpl?.promptMode ?? "stdin";
     const extraArgs = autoImpl?.extraArgs ?? [];
@@ -44920,7 +44983,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     try {
       const pty = require("node-pty");
       ctx.log(`Auto-implement spawn (PTY): ${shellCmd}`);
-      const isWin2 = os23.platform() === "win32";
+      const isWin2 = os24.platform() === "win32";
       child = pty.spawn(isWin2 ? "cmd.exe" : process.env.SHELL || "/bin/zsh", [isWin2 ? "/c" : "-c", shellCmd], {
         name: "xterm-256color",
         cols: 120,
@@ -45063,7 +45126,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         }
       });
       try {
-        fs13.unlinkSync(promptFile);
+        fs14.unlinkSync(promptFile);
       } catch {
       }
       ctx.log(`Auto-implement ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -45160,7 +45223,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     setMode: "set_mode.js"
   };
   const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-  const scriptsDir = path21.join(providerDir, "scripts");
+  const scriptsDir = path23.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -45168,10 +45231,10 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
     lines.push("");
-    for (const file2 of fs13.readdirSync(latestScriptsDir)) {
+    for (const file2 of fs14.readdirSync(latestScriptsDir)) {
       if (file2.endsWith(".js") && targetFileNames.has(file2)) {
         try {
-          const content = fs13.readFileSync(path21.join(latestScriptsDir, file2), "utf-8");
+          const content = fs14.readFileSync(path23.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -45181,14 +45244,14 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
         }
       }
     }
-    const refFiles = fs13.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs14.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file2 of refFiles) {
         try {
-          const content = fs13.readFileSync(path21.join(latestScriptsDir, file2), "utf-8");
+          const content = fs14.readFileSync(path23.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -45229,11 +45292,11 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
       lines.push("");
     }
   }
-  const docsDir = path21.join(providerDir, "../../docs");
+  const docsDir = path23.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path21.join(docsDir, name);
-      if (fs13.existsSync(p)) return fs13.readFileSync(p, "utf-8");
+      const p = path23.join(docsDir, name);
+      if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -45469,7 +45532,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     parseApproval: "parse_approval.js"
   };
   const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-  const scriptsDir = path21.join(providerDir, "scripts");
+  const scriptsDir = path23.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -45477,11 +45540,11 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
     lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
     lines.push("");
-    for (const file2 of fs13.readdirSync(latestScriptsDir)) {
+    for (const file2 of fs14.readdirSync(latestScriptsDir)) {
       if (!file2.endsWith(".js")) continue;
       if (!targetFileNames.has(file2)) continue;
       try {
-        const content = fs13.readFileSync(path21.join(latestScriptsDir, file2), "utf-8");
+        const content = fs14.readFileSync(path23.join(latestScriptsDir, file2), "utf-8");
         lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -45490,14 +45553,14 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       } catch {
       }
     }
-    const refFiles = fs13.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+    const refFiles = fs14.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
     if (refFiles.length > 0) {
       lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
       lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
       lines.push("");
       for (const file2 of refFiles) {
         try {
-          const content = fs13.readFileSync(path21.join(latestScriptsDir, file2), "utf-8");
+          const content = fs14.readFileSync(path23.join(latestScriptsDir, file2), "utf-8");
           lines.push(`### \`${file2}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -45530,11 +45593,11 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       lines.push("");
     }
   }
-  const docsDir = path21.join(providerDir, "../../docs");
+  const docsDir = path23.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path21.join(docsDir, name);
-      if (fs13.existsSync(p)) return fs13.readFileSync(p, "utf-8");
+      const p = path23.join(docsDir, name);
+      if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
     } catch {
     }
     return null;
@@ -45845,13 +45908,13 @@ data: ${JSON.stringify(msg.data)}
     }
   }
 }
-var fs13, path21, os23;
+var fs14, path23, os24;
 var init_dev_auto_implement = __esm({
   "../../oss/packages/daemon-core/src/daemon/dev-auto-implement.ts"() {
     "use strict";
-    fs13 = __toESM(require("fs"));
-    path21 = __toESM(require("path"));
-    os23 = __toESM(require("os"));
+    fs14 = __toESM(require("fs"));
+    path23 = __toESM(require("path"));
+    os24 = __toESM(require("os"));
     init_dev_server();
     init_dev_cli_debug();
   }
@@ -45890,13 +45953,13 @@ function toProviderListEntry(provider) {
   }
   return base;
 }
-var http2, fs14, path23, DEV_SERVER_PORT, DevServer;
+var http2, fs15, path24, DEV_SERVER_PORT, DevServer;
 var init_dev_server = __esm({
   "../../oss/packages/daemon-core/src/daemon/dev-server.ts"() {
     "use strict";
     http2 = __toESM(require("http"));
-    fs14 = __toESM(require("fs"));
-    path23 = __toESM(require("path"));
+    fs15 = __toESM(require("fs"));
+    path24 = __toESM(require("path"));
     init_provider_schema();
     init_config();
     init_provider_source_config();
@@ -46009,8 +46072,8 @@ var init_dev_server = __esm({
       }
       getEndpointList() {
         return this.routes.map((r) => {
-          const path35 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-          return `${r.method.padEnd(5)} ${path35}`;
+          const path36 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+          return `${r.method.padEnd(5)} ${path36}`;
         });
       }
       async start(port = DEV_SERVER_PORT) {
@@ -46298,12 +46361,12 @@ var init_dev_server = __esm({
       // ─── DevConsole SPA ───
       getConsoleDistDir() {
         const candidates = [
-          path23.resolve(__dirname, "../../web-devconsole/dist"),
-          path23.resolve(__dirname, "../../../web-devconsole/dist"),
-          path23.join(process.cwd(), "packages/web-devconsole/dist")
+          path24.resolve(__dirname, "../../web-devconsole/dist"),
+          path24.resolve(__dirname, "../../../web-devconsole/dist"),
+          path24.join(process.cwd(), "packages/web-devconsole/dist")
         ];
         for (const dir of candidates) {
-          if (fs14.existsSync(path23.join(dir, "index.html"))) return dir;
+          if (fs15.existsSync(path24.join(dir, "index.html"))) return dir;
         }
         return null;
       }
@@ -46313,9 +46376,9 @@ var init_dev_server = __esm({
           this.json(res, 500, { error: "DevConsole not found. Run: npm run build -w packages/web-devconsole" });
           return;
         }
-        const htmlPath = path23.join(distDir, "index.html");
+        const htmlPath = path24.join(distDir, "index.html");
         try {
-          const html = fs14.readFileSync(htmlPath, "utf-8");
+          const html = fs15.readFileSync(htmlPath, "utf-8");
           res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
           res.end(html);
         } catch (e) {
@@ -46338,15 +46401,15 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: "Not found" });
           return;
         }
-        const safePath = path23.normalize(pathname).replace(/^\.\.\//, "");
-        const filePath = path23.join(distDir, safePath);
+        const safePath = path24.normalize(pathname).replace(/^\.\.\//, "");
+        const filePath = path24.join(distDir, safePath);
         if (!filePath.startsWith(distDir)) {
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
         try {
-          const content = fs14.readFileSync(filePath);
-          const ext = path23.extname(filePath);
+          const content = fs15.readFileSync(filePath);
+          const ext = path24.extname(filePath);
           const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
           res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
           res.end(content);
@@ -46454,14 +46517,14 @@ var init_dev_server = __esm({
         const files = [];
         const scan = (d, prefix) => {
           try {
-            for (const entry of fs14.readdirSync(d, { withFileTypes: true })) {
+            for (const entry of fs15.readdirSync(d, { withFileTypes: true })) {
               if (entry.name.startsWith(".") || entry.name.endsWith(".bak")) continue;
               const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
               if (entry.isDirectory()) {
                 files.push({ path: rel, size: 0, type: "dir" });
-                scan(path23.join(d, entry.name), rel);
+                scan(path24.join(d, entry.name), rel);
               } else {
-                const stat4 = fs14.statSync(path23.join(d, entry.name));
+                const stat4 = fs15.statSync(path24.join(d, entry.name));
                 files.push({ path: rel, size: stat4.size, type: "file" });
               }
             }
@@ -46484,16 +46547,16 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider directory not found: ${type}` });
           return;
         }
-        const fullPath = path23.resolve(dir, path23.normalize(filePath));
+        const fullPath = path24.resolve(dir, path24.normalize(filePath));
         if (!fullPath.startsWith(dir)) {
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
-        if (!fs14.existsSync(fullPath) || fs14.statSync(fullPath).isDirectory()) {
+        if (!fs15.existsSync(fullPath) || fs15.statSync(fullPath).isDirectory()) {
           this.json(res, 404, { error: `File not found: ${filePath}` });
           return;
         }
-        const content = fs14.readFileSync(fullPath, "utf-8");
+        const content = fs15.readFileSync(fullPath, "utf-8");
         this.json(res, 200, { type, path: filePath, content, lines: content.split("\n").length });
       }
       /** POST /api/providers/:type/file — write a file { path, content } */
@@ -46509,15 +46572,15 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider directory not found: ${type}` });
           return;
         }
-        const fullPath = path23.resolve(dir, path23.normalize(filePath));
+        const fullPath = path24.resolve(dir, path24.normalize(filePath));
         if (!fullPath.startsWith(dir)) {
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
         try {
-          if (fs14.existsSync(fullPath)) fs14.copyFileSync(fullPath, fullPath + ".bak");
-          fs14.mkdirSync(path23.dirname(fullPath), { recursive: true });
-          fs14.writeFileSync(fullPath, content, "utf-8");
+          if (fs15.existsSync(fullPath)) fs15.copyFileSync(fullPath, fullPath + ".bak");
+          fs15.mkdirSync(path24.dirname(fullPath), { recursive: true });
+          fs15.writeFileSync(fullPath, content, "utf-8");
           this.log(`File saved: ${fullPath} (${content.length} chars)`);
           this.providerLoader.reload();
           this.json(res, 200, { saved: true, path: filePath, chars: content.length });
@@ -46533,9 +46596,9 @@ var init_dev_server = __esm({
           return;
         }
         for (const name of ["scripts.js", "provider.json"]) {
-          const p = path23.join(dir, name);
-          if (fs14.existsSync(p)) {
-            const source = fs14.readFileSync(p, "utf-8");
+          const p = path24.join(dir, name);
+          if (fs15.existsSync(p)) {
+            const source = fs15.readFileSync(p, "utf-8");
             this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
             return;
           }
@@ -46554,11 +46617,11 @@ var init_dev_server = __esm({
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const target = fs14.existsSync(path23.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
-        const targetPath = path23.join(dir, target);
+        const target = fs15.existsSync(path24.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+        const targetPath = path24.join(dir, target);
         try {
-          if (fs14.existsSync(targetPath)) fs14.copyFileSync(targetPath, targetPath + ".bak");
-          fs14.writeFileSync(targetPath, source, "utf-8");
+          if (fs15.existsSync(targetPath)) fs15.copyFileSync(targetPath, targetPath + ".bak");
+          fs15.writeFileSync(targetPath, source, "utf-8");
           this.log(`Saved provider: ${targetPath} (${source.length} chars)`);
           this.providerLoader.reload();
           this.json(res, 200, { saved: true, path: targetPath, chars: source.length });
@@ -46702,21 +46765,21 @@ var init_dev_server = __esm({
         }
         let targetDir;
         targetDir = this.providerLoader.getUserProviderDir(category, type);
-        const jsonPath = path23.join(targetDir, "provider.json");
-        if (fs14.existsSync(jsonPath)) {
+        const jsonPath = path24.join(targetDir, "provider.json");
+        if (fs15.existsSync(jsonPath)) {
           this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
           return;
         }
         try {
           const result = generateFiles(type, name, category, { cdpPorts, cli, processName, installPath, binary, extensionId, version: version2, osPaths, processNames });
-          fs14.mkdirSync(targetDir, { recursive: true });
-          fs14.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+          fs15.mkdirSync(targetDir, { recursive: true });
+          fs15.writeFileSync(jsonPath, result["provider.json"], "utf-8");
           const createdFiles = ["provider.json"];
           if (result.files) {
             for (const [relPath, content] of Object.entries(result.files)) {
-              const fullPath = path23.join(targetDir, relPath);
-              fs14.mkdirSync(path23.dirname(fullPath), { recursive: true });
-              fs14.writeFileSync(fullPath, content, "utf-8");
+              const fullPath = path24.join(targetDir, relPath);
+              fs15.mkdirSync(path24.dirname(fullPath), { recursive: true });
+              fs15.writeFileSync(fullPath, content, "utf-8");
               createdFiles.push(relPath);
             }
           }
@@ -46765,38 +46828,38 @@ var init_dev_server = __esm({
       }
       // ─── Phase 2: Auto-Implement Backend ───
       getLatestScriptVersionDir(scriptsDir) {
-        if (!fs14.existsSync(scriptsDir)) return null;
-        const versions = fs14.readdirSync(scriptsDir).filter((d) => {
+        if (!fs15.existsSync(scriptsDir)) return null;
+        const versions = fs15.readdirSync(scriptsDir).filter((d) => {
           try {
-            return fs14.statSync(path23.join(scriptsDir, d)).isDirectory();
+            return fs15.statSync(path24.join(scriptsDir, d)).isDirectory();
           } catch {
             return false;
           }
         }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
         if (versions.length === 0) return null;
-        return path23.join(scriptsDir, versions[0]);
+        return path24.join(scriptsDir, versions[0]);
       }
       resolveAutoImplWritableProviderDir(category, type, requestedDir) {
-        const canonicalUserDir = path23.resolve(this.providerLoader.getUserProviderDir(category, type));
-        const desiredDir = requestedDir ? path23.resolve(requestedDir) : canonicalUserDir;
-        const upstreamRoot = path23.resolve(this.providerLoader.getUpstreamDir());
-        if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path23.sep}`)) {
+        const canonicalUserDir = path24.resolve(this.providerLoader.getUserProviderDir(category, type));
+        const desiredDir = requestedDir ? path24.resolve(requestedDir) : canonicalUserDir;
+        const upstreamRoot = path24.resolve(this.providerLoader.getUpstreamDir());
+        if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path24.sep}`)) {
           return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
         }
-        if (path23.basename(desiredDir) !== type) {
+        if (path24.basename(desiredDir) !== type) {
           return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
         }
         const sourceDir = this.findProviderDir(type);
         if (!sourceDir) {
           return { dir: null, reason: `Provider source directory not found for '${type}'` };
         }
-        if (!fs14.existsSync(desiredDir)) {
-          fs14.mkdirSync(path23.dirname(desiredDir), { recursive: true });
-          fs14.cpSync(sourceDir, desiredDir, { recursive: true });
+        if (!fs15.existsSync(desiredDir)) {
+          fs15.mkdirSync(path24.dirname(desiredDir), { recursive: true });
+          fs15.cpSync(sourceDir, desiredDir, { recursive: true });
           this.log(`Auto-implement writable copy created: ${desiredDir}`);
         }
-        const providerJson = path23.join(desiredDir, "provider.json");
-        if (!fs14.existsSync(providerJson)) {
+        const providerJson = path24.join(desiredDir, "provider.json");
+        if (!fs15.existsSync(providerJson)) {
           return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
         }
         return { dir: desiredDir };
@@ -46831,7 +46894,7 @@ var init_dev_server = __esm({
           setMode: "set_mode.js"
         };
         const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-        const scriptsDir = path23.join(providerDir, "scripts");
+        const scriptsDir = path24.join(providerDir, "scripts");
         const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
         if (latestScriptsDir) {
           lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -46839,10 +46902,10 @@ var init_dev_server = __esm({
           lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
           lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
           lines.push("");
-          for (const file2 of fs14.readdirSync(latestScriptsDir)) {
+          for (const file2 of fs15.readdirSync(latestScriptsDir)) {
             if (file2.endsWith(".js") && targetFileNames.has(file2)) {
               try {
-                const content = fs14.readFileSync(path23.join(latestScriptsDir, file2), "utf-8");
+                const content = fs15.readFileSync(path24.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -46852,14 +46915,14 @@ var init_dev_server = __esm({
               }
             }
           }
-          const refFiles = fs14.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+          const refFiles = fs15.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
           if (refFiles.length > 0) {
             lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
             lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
             lines.push("");
             for (const file2 of refFiles) {
               try {
-                const content = fs14.readFileSync(path23.join(latestScriptsDir, file2), "utf-8");
+                const content = fs15.readFileSync(path24.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -46900,11 +46963,11 @@ var init_dev_server = __esm({
             lines.push("");
           }
         }
-        const docsDir = path23.join(providerDir, "../../docs");
+        const docsDir = path24.join(providerDir, "../../docs");
         const loadGuide = (name) => {
           try {
-            const p = path23.join(docsDir, name);
-            if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
+            const p = path24.join(docsDir, name);
+            if (fs15.existsSync(p)) return fs15.readFileSync(p, "utf-8");
           } catch {
           }
           return null;
@@ -47077,7 +47140,7 @@ var init_dev_server = __esm({
           parseApproval: "parse_approval.js"
         };
         const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-        const scriptsDir = path23.join(providerDir, "scripts");
+        const scriptsDir = path24.join(providerDir, "scripts");
         const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
         if (latestScriptsDir) {
           lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -47085,11 +47148,11 @@ var init_dev_server = __esm({
           lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
           lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
           lines.push("");
-          for (const file2 of fs14.readdirSync(latestScriptsDir)) {
+          for (const file2 of fs15.readdirSync(latestScriptsDir)) {
             if (!file2.endsWith(".js")) continue;
             if (!targetFileNames.has(file2)) continue;
             try {
-              const content = fs14.readFileSync(path23.join(latestScriptsDir, file2), "utf-8");
+              const content = fs15.readFileSync(path24.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -47098,14 +47161,14 @@ var init_dev_server = __esm({
             } catch {
             }
           }
-          const refFiles = fs14.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+          const refFiles = fs15.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
           if (refFiles.length > 0) {
             lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
             lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
             lines.push("");
             for (const file2 of refFiles) {
               try {
-                const content = fs14.readFileSync(path23.join(latestScriptsDir, file2), "utf-8");
+                const content = fs15.readFileSync(path24.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -47138,11 +47201,11 @@ var init_dev_server = __esm({
             lines.push("");
           }
         }
-        const docsDir = path23.join(providerDir, "../../docs");
+        const docsDir = path24.join(providerDir, "../../docs");
         const loadGuide = (name) => {
           try {
-            const p = path23.join(docsDir, name);
-            if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
+            const p = path24.join(docsDir, name);
+            if (fs15.existsSync(p)) return fs15.readFileSync(p, "utf-8");
           } catch {
           }
           return null;
@@ -47952,8 +48015,8 @@ async function installExtension(ide, extension) {
       const res = await fetch(extension.vsixUrl);
       if (res.ok) {
         const buffer = Buffer.from(await res.arrayBuffer());
-        const fs22 = await import("fs");
-        fs22.writeFileSync(vsixPath, buffer);
+        const fs23 = await import("fs");
+        fs23.writeFileSync(vsixPath, buffer);
         return new Promise((resolve18) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
           (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
@@ -60117,15 +60180,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path35 = [graph[toModel].parent, toModel];
+      const path36 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path35.unshift(graph[cur].parent);
+        path36.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path35;
+      fn.conversion = path36;
       return fn;
     }
     module2.exports = function(fromModel) {
@@ -60522,7 +60585,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os30 = require("os");
+    var os31 = require("os");
     var tty3 = require("tty");
     var hasFlag3 = require_has_flag();
     var { env: env3 } = process;
@@ -60570,7 +60633,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os30.release().split(".");
+        const osRelease = os31.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -63423,7 +63486,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join33(s) {
+        value: function join34(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -73546,10 +73609,10 @@ var require_lib = __commonJS({
     exports2.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve18, reject) => {
       let fd;
-      const fs22 = (0, node_1.default)();
+      const fs23 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs22.closeSync(fd);
+          fs23.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -73561,9 +73624,9 @@ var require_lib = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs22.openSync(filepath, "r");
+        fd = fs23.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs22.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs23.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -73575,22 +73638,22 @@ var require_lib = __commonJS({
         });
         return;
       }
-      fs22.readFile(filepath, handler);
+      fs23.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs22 = (0, node_1.default)();
+      const fs23 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs22.openSync(filepath, "r");
+        const fd = fs23.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs22.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs23.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs22.closeSync(fd);
+        fs23.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs22.readFileSync(filepath));
+      return (0, exports2.detect)(fs23.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -77482,7 +77545,7 @@ function splitStringBySpace(str) {
   }
   return pieces;
 }
-var import_chardet, import_child_process12, import_fs6, import_node_path2, import_node_os4, import_node_crypto, import_iconv_lite, ExternalEditor;
+var import_chardet, import_child_process12, import_fs6, import_node_path2, import_node_os4, import_node_crypto2, import_iconv_lite, ExternalEditor;
 var init_esm2 = __esm({
   "../../node_modules/@inquirer/external-editor/dist/esm/index.js"() {
     "use strict";
@@ -77491,7 +77554,7 @@ var init_esm2 = __esm({
     import_fs6 = require("fs");
     import_node_path2 = __toESM(require("path"), 1);
     import_node_os4 = __toESM(require("os"), 1);
-    import_node_crypto = require("crypto");
+    import_node_crypto2 = require("crypto");
     import_iconv_lite = __toESM(require_lib2(), 1);
     init_CreateFileError();
     init_LaunchEditorError();
@@ -77550,7 +77613,7 @@ var init_esm2 = __esm({
       createTemporaryFile() {
         try {
           const baseDir = this.fileOptions.dir ?? import_node_os4.default.tmpdir();
-          const id = (0, import_node_crypto.randomUUID)();
+          const id = (0, import_node_crypto2.randomUUID)();
           const prefix = sanitizeAffix(this.fileOptions.prefix);
           const postfix = sanitizeAffix(this.fileOptions.postfix);
           const filename = `${prefix}${id}${postfix}`;
@@ -77995,9 +78058,9 @@ var init_prompt = __esm({
     init_utils();
     init_baseUI();
     _ = {
-      set: (obj, path35 = "", value) => {
+      set: (obj, path36 = "", value) => {
         let pointer = obj;
-        path35.split(".").forEach((key, index, arr) => {
+        path36.split(".").forEach((key, index, arr) => {
           if (key === "__proto__" || key === "constructor") return;
           if (index === arr.length - 1) {
             pointer[key] = value;
@@ -78007,8 +78070,8 @@ var init_prompt = __esm({
           pointer = pointer[key];
         });
       },
-      get: (obj, path35 = "", defaultValue) => {
-        const travel = (regexp) => String.prototype.split.call(path35, regexp).filter(Boolean).reduce(
+      get: (obj, path36 = "", defaultValue) => {
+        const travel = (regexp) => String.prototype.split.call(path36, regexp).filter(Boolean).reduce(
           // @ts-expect-error implicit any on res[key]
           (res, key) => res !== null && res !== void 0 ? res[key] : res,
           obj
@@ -80053,12 +80116,14 @@ var init_data_channel_router = __esm({
 });
 
 // src/daemon-p2p/screenshot-sender.ts
-var CHUNK_SIZE, ScreenshotSender;
+var CHUNK_SIZE, MAX_INLINE_JSON_MESSAGE_BYTES, JSON_CHUNK_PAYLOAD_CHARS2, ScreenshotSender;
 var init_screenshot_sender = __esm({
   "src/daemon-p2p/screenshot-sender.ts"() {
     "use strict";
     init_log();
     CHUNK_SIZE = 6e4;
+    MAX_INLINE_JSON_MESSAGE_BYTES = 6e4;
+    JSON_CHUNK_PAYLOAD_CHARS2 = 16e3;
     ScreenshotSender = class {
       _ssDebugDone = false;
       sendStatus(peers, status) {
@@ -80097,16 +80162,43 @@ var init_screenshot_sender = __esm({
       }
       sendTopicUpdateToPeer(peer, update) {
         if (!peer?.dataChannel || peer.state !== "connected" || !peer.dataChannel.isOpen()) return false;
+        const json2 = JSON.stringify({
+          type: "topic_update",
+          update
+        });
+        if (Buffer.byteLength(json2, "utf8") > MAX_INLINE_JSON_MESSAGE_BYTES) {
+          return this.sendChunkedTopicUpdate(peer, update, json2);
+        }
         try {
-          peer.dataChannel.sendMessage(JSON.stringify({
-            type: "topic_update",
-            update
-          }));
+          peer.dataChannel.sendMessage(json2);
           return true;
         } catch {
           return false;
         }
       }
+      sendChunkedTopicUpdate(peer, update, json2) {
+        const topic = typeof update?.topic === "string" ? update.topic : "topic_update";
+        const key = typeof update?.key === "string" ? update.key : "";
+        const seq = typeof update?.seq === "number" ? update.seq : Date.now();
+        const chunkId = `${topic}:${key}:${seq}:${Math.random().toString(36).slice(2, 8)}`;
+        const total = Math.ceil(json2.length / JSON_CHUNK_PAYLOAD_CHARS2);
+        logDebug(`topic_update chunked: peer=${peer.peerId || "unknown"} topic=${topic} key=${key || "-"} chars=${json2.length} chunks=${total}`);
+        for (let index = 0; index < total; index += 1) {
+          const chunk = json2.slice(index * JSON_CHUNK_PAYLOAD_CHARS2, (index + 1) * JSON_CHUNK_PAYLOAD_CHARS2);
+          try {
+            peer.dataChannel?.sendMessage(JSON.stringify({
+              type: "topic_update_chunk",
+              chunkId,
+              index,
+              total,
+              data: chunk
+            }));
+          } catch {
+            return false;
+          }
+        }
+        return true;
+      }
       /** Broadcast runtime session output to all connected peers */
       broadcastSessionOutput(peers, sessionId, data) {
         const msg = JSON.stringify({ type: "session_output", sessionId, data });
@@ -80537,12 +80629,12 @@ var init_peer_connection_manager = __esm({
 });
 
 // src/daemon-p2p/index.ts
-var fs15, path25, import_node_module2, esmRequire, DaemonP2PSender;
+var fs16, path26, import_node_module2, esmRequire, DaemonP2PSender;
 var init_daemon_p2p = __esm({
   "src/daemon-p2p/index.ts"() {
     "use strict";
-    fs15 = __toESM(require("fs"));
-    path25 = __toESM(require("path"));
+    fs16 = __toESM(require("fs"));
+    path26 = __toESM(require("path"));
     import_node_module2 = require("module");
     init_src();
     init_data_channel_router();
@@ -80621,17 +80713,17 @@ ${e?.stack || ""}`);
         const prebuildKey = `${platform12}-${arch3}`;
         try {
           const candidates = [
-            path25.join(__dirname, "node_modules", "node-datachannel"),
-            path25.join(__dirname, "..", "node_modules", "node-datachannel"),
-            path25.join(__dirname, "..", "..", "node_modules", "node-datachannel")
+            path26.join(__dirname, "node_modules", "node-datachannel"),
+            path26.join(__dirname, "..", "node_modules", "node-datachannel"),
+            path26.join(__dirname, "..", "..", "node_modules", "node-datachannel")
           ];
           for (const candidate of candidates) {
-            const prebuildPath = path25.join(candidate, "prebuilds", prebuildKey, "node_datachannel.node");
-            if (fs15.existsSync(prebuildPath)) {
-              const targetDir = path25.join(candidate, "build", "Release");
-              const targetPath = path25.join(targetDir, "node_datachannel.node");
-              fs15.mkdirSync(targetDir, { recursive: true });
-              fs15.copyFileSync(prebuildPath, targetPath);
+            const prebuildPath = path26.join(candidate, "prebuilds", prebuildKey, "node_datachannel.node");
+            if (fs16.existsSync(prebuildPath)) {
+              const targetDir = path26.join(candidate, "build", "Release");
+              const targetPath = path26.join(targetDir, "node_datachannel.node");
+              fs16.mkdirSync(targetDir, { recursive: true });
+              fs16.copyFileSync(prebuildPath, targetPath);
               try {
                 delete esmRequire.cache[esmRequire.resolve("node-datachannel")];
               } catch {
@@ -80998,27 +81090,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "../../node_modules/detect-libc/lib/filesystem.js"(exports2, module2) {
     "use strict";
-    var fs22 = require("fs");
+    var fs23 = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync20 = (path35) => {
-      const fd = fs22.openSync(path35, "r");
+    var readFileSync20 = (path36) => {
+      const fd = fs23.openSync(path36, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs22.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs22.close(fd, () => {
+      const bytesRead = fs23.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs23.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile = (path35) => new Promise((resolve18, reject) => {
-      fs22.open(path35, "r", (err, fd) => {
+    var readFile = (path36) => new Promise((resolve18, reject) => {
+      fs23.open(path36, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs22.read(fd, buffer, 0, MAX_LENGTH, 0, (_2, bytesRead) => {
+          fs23.read(fd, buffer, 0, MAX_LENGTH, 0, (_2, bytesRead) => {
             resolve18(buffer.subarray(0, bytesRead));
-            fs22.close(fd, () => {
+            fs23.close(fd, () => {
             });
           });
         }
@@ -81130,11 +81222,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path35) => {
-      if (path35) {
-        if (path35.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path36) => {
+      if (path36) {
+        if (path36.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path35.includes("/ld-linux-")) {
+        } else if (path36.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -81181,8 +81273,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile(SELF_PATH);
-        const path35 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path35);
+        const path36 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path36);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -81194,8 +81286,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = readFileSync20(SELF_PATH);
-        const path35 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path35);
+        const path36 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path36);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -82914,18 +83006,18 @@ var require_sharp = __commonJS({
       `@img/sharp-${runtimePlatform}/sharp.node`,
       "@img/sharp-wasm32/sharp.node"
     ];
-    var path35;
+    var path36;
     var sharp;
     var errors = [];
-    for (path35 of paths) {
+    for (path36 of paths) {
       try {
-        sharp = require(path35);
+        sharp = require(path36);
         break;
       } catch (err) {
         errors.push(err);
       }
     }
-    if (sharp && path35.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
+    if (sharp && path36.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
       const err = new Error("Prebuilt binaries for linux-x64 require v2 microarchitecture");
       err.code = "Unsupported CPU";
       errors.push(err);
@@ -82934,7 +83026,7 @@ var require_sharp = __commonJS({
     if (sharp) {
       module2.exports = sharp;
     } else {
-      const [isLinux2, isMacOs, isWindows2] = ["linux", "darwin", "win32"].map((os30) => runtimePlatform.startsWith(os30));
+      const [isLinux2, isMacOs, isWindows2] = ["linux", "darwin", "win32"].map((os31) => runtimePlatform.startsWith(os31));
       const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
       errors.forEach((err) => {
         if (err.code !== "MODULE_NOT_FOUND") {
@@ -82951,15 +83043,15 @@ var require_sharp = __commonJS({
           `    Requires ${expected}`
         );
       } else if (prebuiltPlatforms.includes(runtimePlatform)) {
-        const [os30, cpu] = runtimePlatform.split("-");
-        const libc = os30.endsWith("musl") ? " --libc=musl" : "";
+        const [os31, cpu] = runtimePlatform.split("-");
+        const libc = os31.endsWith("musl") ? " --libc=musl" : "";
         help.push(
           "- Ensure optional dependencies can be installed:",
           "    npm install --include=optional sharp",
           "- Ensure your package manager supports multi-platform installation:",
           "    See https://sharp.pixelplumbing.com/install#cross-platform",
           "- Add platform-specific dependencies:",
-          `    npm install --os=${os30.replace("musl", "")}${libc} --cpu=${cpu} sharp`
+          `    npm install --os=${os31.replace("musl", "")}${libc} --cpu=${cpu} sharp`
         );
       } else {
         help.push(
@@ -85834,15 +85926,15 @@ var require_color = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path35 = [graph[toModel].parent, toModel];
+      const path36 = [graph[toModel].parent, toModel];
       let fn = conversions_default[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path35.unshift(graph[cur].parent);
+        path36.unshift(graph[cur].parent);
         fn = link(conversions_default[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path35;
+      fn.conversion = path36;
       return fn;
     }
     function route(fromModel) {
@@ -86459,7 +86551,7 @@ var require_channel = __commonJS({
 var require_output = __commonJS({
   "../../node_modules/sharp/lib/output.js"(exports2, module2) {
     "use strict";
-    var path35 = require("path");
+    var path36 = require("path");
     var is = require_is();
     var sharp = require_sharp();
     var formats = /* @__PURE__ */ new Map([
@@ -86490,9 +86582,9 @@ var require_output = __commonJS({
       let err;
       if (!is.string(fileOut)) {
         err = new Error("Missing output file path");
-      } else if (is.string(this.options.input.file) && path35.resolve(this.options.input.file) === path35.resolve(fileOut)) {
+      } else if (is.string(this.options.input.file) && path36.resolve(this.options.input.file) === path36.resolve(fileOut)) {
         err = new Error("Cannot use same file for input and output");
-      } else if (jp2Regex.test(path35.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+      } else if (jp2Regex.test(path36.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
         err = errJp2Save();
       }
       if (err) {
@@ -87766,21 +87858,21 @@ function quarantineLegacyStandaloneSessions(options) {
   if (shouldSkipForExplicitOverride(env3)) {
     return { movedCount: 0, skippedActiveCount: 0, backupDir: null };
   }
-  const homeDir = options.homeDir || os25.homedir();
+  const homeDir = options.homeDir || os26.homedir();
   const now = options.now || (() => /* @__PURE__ */ new Date());
   const isPidRunning = options.isPidRunning || defaultPidRunning;
-  const runtimesDir = path26.join(homeDir, ".adhdev", "session-host", options.appName, "runtimes");
-  if (!fs16.existsSync(runtimesDir)) {
+  const runtimesDir = path27.join(homeDir, ".adhdev", "session-host", options.appName, "runtimes");
+  if (!fs17.existsSync(runtimesDir)) {
     return { movedCount: 0, skippedActiveCount: 0, backupDir: null };
   }
-  const candidates = fs16.readdirSync(runtimesDir).filter((name) => name.endsWith(".json")).map((name) => path26.join(runtimesDir, name));
+  const candidates = fs17.readdirSync(runtimesDir).filter((name) => name.endsWith(".json")).map((name) => path27.join(runtimesDir, name));
   let movedCount = 0;
   let skippedActiveCount = 0;
   let backupDir = null;
   for (const sourcePath of candidates) {
     let parsed;
     try {
-      parsed = JSON.parse(fs16.readFileSync(sourcePath, "utf8"));
+      parsed = JSON.parse(fs17.readFileSync(sourcePath, "utf8"));
     } catch {
       continue;
     }
@@ -87791,26 +87883,26 @@ function quarantineLegacyStandaloneSessions(options) {
       continue;
     }
     if (!backupDir) {
-      backupDir = path26.join(
+      backupDir = path27.join(
         homeDir,
         ".adhdev",
         "session-host-backups",
         `legacy-standalone-${options.appName}-${formatTimestamp(now())}`
       );
-      fs16.mkdirSync(path26.join(backupDir, "runtimes"), { recursive: true });
+      fs17.mkdirSync(path27.join(backupDir, "runtimes"), { recursive: true });
     }
-    fs16.renameSync(sourcePath, path26.join(backupDir, "runtimes", path26.basename(sourcePath)));
+    fs17.renameSync(sourcePath, path27.join(backupDir, "runtimes", path27.basename(sourcePath)));
     movedCount += 1;
   }
   return { movedCount, skippedActiveCount, backupDir };
 }
-var fs16, os25, path26, LEGACY_STANDALONE_MANAGER_TAG;
+var fs17, os26, path27, LEGACY_STANDALONE_MANAGER_TAG;
 var init_session_host_hygiene = __esm({
   "src/session-host-hygiene.ts"() {
     "use strict";
-    fs16 = __toESM(require("fs"));
-    os25 = __toESM(require("os"));
-    path26 = __toESM(require("path"));
+    fs17 = __toESM(require("fs"));
+    os26 = __toESM(require("os"));
+    path27 = __toESM(require("path"));
     init_src();
     LEGACY_STANDALONE_MANAGER_TAG = "adhdev-standalone";
   }
@@ -87834,18 +87926,18 @@ function buildSessionHostEnv(baseEnv) {
 }
 function resolveSessionHostEntry() {
   const packagedCandidates = [
-    path27.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
-    path27.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
+    path28.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
+    path28.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
   ];
   for (const candidate of packagedCandidates) {
-    if (fs17.existsSync(candidate)) {
+    if (fs18.existsSync(candidate)) {
       return candidate;
     }
   }
   return require.resolve("@adhdev/session-host-daemon");
 }
 function getSessionHostPidFile() {
-  return path27.join(os26.homedir(), ".adhdev", `${SESSION_HOST_APP_NAME}-session-host.pid`);
+  return path28.join(os27.homedir(), ".adhdev", `${SESSION_HOST_APP_NAME}-session-host.pid`);
 }
 function getSessionHostStatusPaths() {
   return {
@@ -87856,8 +87948,8 @@ function getSessionHostStatusPaths() {
 function getSessionHostPid() {
   try {
     const pidFile = getSessionHostPidFile();
-    if (!fs17.existsSync(pidFile)) return null;
-    const pid = Number.parseInt(fs17.readFileSync(pidFile, "utf8").trim(), 10);
+    if (!fs18.existsSync(pidFile)) return null;
+    const pid = Number.parseInt(fs18.readFileSync(pidFile, "utf8").trim(), 10);
     return Number.isFinite(pid) ? pid : null;
   } catch {
     return null;
@@ -87927,8 +88019,8 @@ function stopManagedSessionHostProcess() {
   let stopped = false;
   const pidFile = getSessionHostPidFile();
   try {
-    if (fs17.existsSync(pidFile)) {
-      const pid = Number.parseInt(fs17.readFileSync(pidFile, "utf8").trim(), 10);
+    if (fs18.existsSync(pidFile)) {
+      const pid = Number.parseInt(fs18.readFileSync(pidFile, "utf8").trim(), 10);
       if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid2(pid)) {
         stopped = killPid2(pid) || stopped;
       }
@@ -87936,7 +88028,7 @@ function stopManagedSessionHostProcess() {
   } catch {
   } finally {
     try {
-      fs17.unlinkSync(pidFile);
+      fs18.unlinkSync(pidFile);
     } catch {
     }
   }
@@ -87964,9 +88056,9 @@ async function ensureSessionHostReady2() {
   }
   const spawnHost = () => {
     const entry = resolveSessionHostEntry();
-    const logDir = path27.join(os26.homedir(), ".adhdev", "logs");
-    fs17.mkdirSync(logDir, { recursive: true });
-    const logFd = fs17.openSync(path27.join(logDir, "session-host.log"), "a");
+    const logDir = path28.join(os27.homedir(), ".adhdev", "logs");
+    fs18.mkdirSync(logDir, { recursive: true });
+    const logFd = fs18.openSync(path28.join(logDir, "session-host.log"), "a");
     const child = (0, import_child_process13.spawn)(process.execPath, [entry], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
@@ -87975,7 +88067,7 @@ async function ensureSessionHostReady2() {
     });
     child.unref();
     try {
-      fs17.closeSync(logFd);
+      fs18.closeSync(logFd);
     } catch {
     }
   };
@@ -88028,14 +88120,14 @@ async function probeSessionHostStatus() {
     };
   }
 }
-var import_child_process13, fs17, os26, path27, SESSION_HOST_APP_NAME, SESSION_HOST_START_TIMEOUT_MS;
+var import_child_process13, fs18, os27, path28, SESSION_HOST_APP_NAME, SESSION_HOST_START_TIMEOUT_MS;
 var init_session_host = __esm({
   "src/session-host.ts"() {
     "use strict";
     import_child_process13 = require("child_process");
-    fs17 = __toESM(require("fs"));
-    os26 = __toESM(require("os"));
-    path27 = __toESM(require("path"));
+    fs18 = __toESM(require("fs"));
+    os27 = __toESM(require("os"));
+    path28 = __toESM(require("path"));
     init_src();
     init_dist();
     init_session_host_hygiene();
@@ -88266,22 +88358,22 @@ function resolveDaemonPort(ref = {}) {
   return Number.isFinite(ref.port) && Number(ref.port) > 0 ? Number(ref.port) : DEFAULT_DAEMON_PORT;
 }
 function getDaemonPidFile(ref = {}) {
-  const dir = path28.join(ref.homeDir || os27.homedir(), ".adhdev");
-  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
+  const dir = path29.join(ref.homeDir || os28.homedir(), ".adhdev");
+  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
   const port = resolveDaemonPort(ref);
-  return path28.join(dir, port === DEFAULT_DAEMON_PORT ? "daemon.pid" : `daemon-${port}.pid`);
+  return path29.join(dir, port === DEFAULT_DAEMON_PORT ? "daemon.pid" : `daemon-${port}.pid`);
 }
 function writeDaemonPid(pid, ref = {}) {
   const pidFile = getDaemonPidFile(ref);
   try {
-    fs18.writeFileSync(pidFile, String(pid), { encoding: "utf-8", flag: "wx" });
+    fs19.writeFileSync(pidFile, String(pid), { encoding: "utf-8", flag: "wx" });
   } catch {
-    fs18.writeFileSync(pidFile, String(pid), "utf-8");
+    fs19.writeFileSync(pidFile, String(pid), "utf-8");
   }
 }
 function removeDaemonPid(ref = {}) {
   try {
-    fs18.unlinkSync(getDaemonPidFile(ref));
+    fs19.unlinkSync(getDaemonPidFile(ref));
   } catch (e) {
   }
 }
@@ -88308,8 +88400,8 @@ function isDaemonRunning(ref = {}) {
   }
   const pidFile = getDaemonPidFile(ref);
   try {
-    if (!fs18.existsSync(pidFile)) return false;
-    const pid = parseInt(fs18.readFileSync(pidFile, "utf-8").trim());
+    if (!fs19.existsSync(pidFile)) return false;
+    const pid = parseInt(fs19.readFileSync(pidFile, "utf-8").trim());
     process.kill(pid, 0);
     if (!isAdhdevProcess(pid)) {
       removeDaemonPid(ref);
@@ -88386,8 +88478,8 @@ function getDaemonHealthPid(ref = {}) {
 function getDaemonPid(ref = {}) {
   const pidFile = getDaemonPidFile(ref);
   try {
-    if (fs18.existsSync(pidFile)) {
-      const pid = parseInt(fs18.readFileSync(pidFile, "utf-8").trim(), 10);
+    if (fs19.existsSync(pidFile)) {
+      const pid = parseInt(fs19.readFileSync(pidFile, "utf-8").trim(), 10);
       if (Number.isFinite(pid)) return pid;
     }
   } catch {
@@ -88398,8 +88490,8 @@ function stopDaemon(ref = {}) {
   const pidFile = getDaemonPidFile(ref);
   let pid = null;
   try {
-    if (fs18.existsSync(pidFile)) {
-      const pidFromFile = parseInt(fs18.readFileSync(pidFile, "utf-8").trim(), 10);
+    if (fs19.existsSync(pidFile)) {
+      const pidFromFile = parseInt(fs19.readFileSync(pidFile, "utf-8").trim(), 10);
       if (Number.isFinite(pidFromFile)) pid = pidFromFile;
     }
   } catch {
@@ -88418,7 +88510,7 @@ function stopDaemon(ref = {}) {
     return false;
   }
 }
-var os27, fs18, path28, import_http, import_child_process14, import_ws3, pkgVersion, AdhdevDaemon;
+var os28, fs19, path29, import_http, import_child_process14, import_ws3, pkgVersion, AdhdevDaemon;
 var init_adhdev_daemon = __esm({
   "src/adhdev-daemon.ts"() {
     "use strict";
@@ -88430,9 +88522,9 @@ var init_adhdev_daemon = __esm({
     init_startup_restore_policy();
     init_dist();
     init_session_host_controller();
-    os27 = __toESM(require("os"));
-    fs18 = __toESM(require("fs"));
-    path28 = __toESM(require("path"));
+    os28 = __toESM(require("os"));
+    fs19 = __toESM(require("fs"));
+    path29 = __toESM(require("path"));
     import_http = require("http");
     import_child_process14 = require("child_process");
     import_ws3 = require("ws");
@@ -88440,7 +88532,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.50" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.52" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -88964,8 +89056,8 @@ ${err?.stack || ""}`);
             cliInfo: {
               type: "adhdev-daemon",
               version: pkgVersion,
-              platform: os27.platform(),
-              hostname: os27.hostname(),
+              platform: os28.platform(),
+              hostname: os28.hostname(),
               machineId: config2.machineId,
               instanceId
             }
@@ -89723,15 +89815,15 @@ async function loginFlow() {
   let verificationUrl;
   try {
     const config2 = loadConfig();
-    const os30 = await import("os");
+    const os31 = await import("os");
     const res = await fetch(`${SERVER_URL}/auth/cli/init`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         clientMachineId: config2.machineId,
-        hostname: os30.hostname(),
-        platform: os30.platform(),
-        arch: os30.arch()
+        hostname: os31.hostname(),
+        platform: os31.platform(),
+        arch: os31.arch()
       })
     });
     if (!res.ok) {
@@ -89836,8 +89928,8 @@ async function startDaemonFlow() {
     const { execSync: execSync8 } = await import("child_process");
     const { getCurrentDaemonLogPath: getCurrentDaemonLogPath2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     const logPath = getCurrentDaemonLogPath2();
-    const os30 = await import("os");
-    const platform12 = os30.platform();
+    const os31 = await import("os");
+    const platform12 = os31.platform();
     try {
       if (platform12 === "win32") {
         execSync8("start /B adhdev daemon >NUL 2>&1", {
@@ -91730,9 +91822,9 @@ function registerSetupCommands(program2, getProviderLoader2) {
   });
   program2.command("uninstall").description("Completely wipe all setting, configuration, stop daemon and uninstall service").option("-f, --force", "Skip confirmation prompt").action(async (options) => {
     const inquirer2 = await Promise.resolve().then(() => (init_lib(), lib_exports));
-    const fs22 = await import("fs");
-    const path35 = await import("path");
-    const os30 = await import("os");
+    const fs23 = await import("fs");
+    const path36 = await import("path");
+    const os31 = await import("os");
     const { spawnSync: spawnSync3 } = await import("child_process");
     if (!options.force) {
       const { confirm } = await inquirer2.default.prompt([
@@ -91757,11 +91849,11 @@ function registerSetupCommands(program2, getProviderLoader2) {
     }
     console.log(source_default.gray("  Removing OS background service..."));
     spawnSync3(process.execPath, [process.argv[1], "service", "uninstall"], { stdio: "inherit" });
-    const adhdevDir = path35.join(os30.homedir(), ".adhdev");
-    if (fs22.existsSync(adhdevDir)) {
+    const adhdevDir = path36.join(os31.homedir(), ".adhdev");
+    if (fs23.existsSync(adhdevDir)) {
       console.log(source_default.gray(`  Deleting ${adhdevDir}...`));
       try {
-        fs22.rmSync(adhdevDir, { recursive: true, force: true });
+        fs23.rmSync(adhdevDir, { recursive: true, force: true });
         console.log(source_default.green("  \u2713 Data wiped."));
       } catch (e) {
         console.log(source_default.red(`  \u2717 Failed to delete ~/.adhdev: ${e.message}`));
@@ -91780,11 +91872,11 @@ init_source();
 init_src();
 
 // src/cli/runtime-tools.ts
-var fs19 = __toESM(require("fs"));
-var path30 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
+var path31 = __toESM(require("path"));
 function defaultPackageRoot() {
-  const currentCliPath = process.argv[1] ? fs19.realpathSync.native(process.argv[1]) : process.cwd();
-  return path30.resolve(path30.dirname(currentCliPath), "../..");
+  const currentCliPath = process.argv[1] ? fs20.realpathSync.native(process.argv[1]) : process.cwd();
+  return path31.resolve(path31.dirname(currentCliPath), "../..");
 }
 function normalizePath2(value) {
   return value.replace(/\\/g, "/").toLowerCase();
@@ -91793,19 +91885,19 @@ function shouldPreferSource(currentCliPath, packageRoot) {
   const normalizedCliPath = normalizePath2(currentCliPath || "");
   if (normalizedCliPath.includes("/src/cli/")) return true;
   if (normalizedCliPath.includes("/dist/cli/")) return false;
-  return fs19.existsSync(path30.join(packageRoot, "src", "cli", "index.ts"));
+  return fs20.existsSync(path31.join(packageRoot, "src", "cli", "index.ts"));
 }
 function getVendoredToolEntry(packageRoot, tool) {
   if (tool === "session-host-daemon") {
-    return path30.join(packageRoot, "vendor", "session-host-daemon", "index.js");
+    return path31.join(packageRoot, "vendor", "session-host-daemon", "index.js");
   }
-  return path30.join(packageRoot, "vendor", "terminal-mux-cli", "index.js");
+  return path31.join(packageRoot, "vendor", "terminal-mux-cli", "index.js");
 }
 function getSourceToolEntry(packageRoot, tool) {
   if (tool === "session-host-daemon") {
-    return path30.resolve(packageRoot, "../../oss/packages/session-host-daemon/src/index.ts");
+    return path31.resolve(packageRoot, "../../oss/packages/session-host-daemon/src/index.ts");
   }
-  return path30.resolve(packageRoot, "../../oss/packages/terminal-mux-cli/src/index.ts");
+  return path31.resolve(packageRoot, "../../oss/packages/terminal-mux-cli/src/index.ts");
 }
 function getGlobalToolCommand(tool) {
   return tool === "session-host-daemon" ? "adhdev-sessiond" : "adhmux";
@@ -91818,7 +91910,7 @@ function resolveRuntimeToolLaunch(tool, context = {}) {
   const vendoredEntry = getVendoredToolEntry(packageRoot, tool);
   const resolutionOrder = preferSource ? ["source", "vendored", "global"] : ["vendored", "source", "global"];
   for (const resolution of resolutionOrder) {
-    if (resolution === "source" && fs19.existsSync(sourceEntry)) {
+    if (resolution === "source" && fs20.existsSync(sourceEntry)) {
       return {
         tool,
         resolvedVia: "source",
@@ -91827,7 +91919,7 @@ function resolveRuntimeToolLaunch(tool, context = {}) {
         env: env3
       };
     }
-    if (resolution === "vendored" && fs19.existsSync(vendoredEntry)) {
+    if (resolution === "vendored" && fs20.existsSync(vendoredEntry)) {
       return {
         tool,
         resolvedVia: "vendored",
@@ -92960,9 +93052,9 @@ function registerDaemonCommands(program2, pkgVersion3) {
 // src/cli/doctor-commands.ts
 init_source();
 var import_child_process15 = require("child_process");
-var fs21 = __toESM(require("fs"));
-var os29 = __toESM(require("os"));
-var path33 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
+var os30 = __toESM(require("os"));
+var path34 = __toESM(require("path"));
 init_src();
 init_session_host();
 
@@ -93445,11 +93537,11 @@ function formatBytes(bytes) {
 
 // src/cli/doctor-commands.ts
 function resolvePackageRoot() {
-  return path33.resolve(__dirname, "..", "..");
+  return path34.resolve(__dirname, "..", "..");
 }
 function isLinkedInstall(packageRoot) {
-  const normalized = path33.normalize(packageRoot);
-  return !normalized.includes(`${path33.sep}node_modules${path33.sep}adhdev`);
+  const normalized = path34.normalize(packageRoot);
+  return !normalized.includes(`${path34.sep}node_modules${path34.sep}adhdev`);
 }
 function formatCheck(check2) {
   const icon = check2.ok ? source_default.green("\u2713") : source_default.red("\u2717");
@@ -93533,11 +93625,11 @@ function probeSharpRuntime(packageRoot, nativeSharpPackage) {
   }
 }
 function probeConfigAccess() {
-  const configDir = path33.join(os29.homedir(), ".adhdev");
-  const configPath = path33.join(configDir, "config.json");
+  const configDir = path34.join(os30.homedir(), ".adhdev");
+  const configPath = path34.join(configDir, "config.json");
   const checks = [];
   try {
-    fs21.mkdirSync(configDir, { recursive: true });
+    fs22.mkdirSync(configDir, { recursive: true });
     checks.push({
       label: "Config directory",
       ok: true,
@@ -93552,8 +93644,8 @@ function probeConfigAccess() {
     }];
   }
   try {
-    if (fs21.existsSync(configPath)) {
-      fs21.readFileSync(configPath, "utf-8");
+    if (fs22.existsSync(configPath)) {
+      fs22.readFileSync(configPath, "utf-8");
       checks.push({
         label: "Config file",
         ok: true,
@@ -93574,10 +93666,10 @@ function probeConfigAccess() {
       fatal: true
     });
   }
-  const probePath = path33.join(configDir, `.doctor-write-${process.pid}-${Date.now()}.tmp`);
+  const probePath = path34.join(configDir, `.doctor-write-${process.pid}-${Date.now()}.tmp`);
   try {
-    fs21.writeFileSync(probePath, "ok", "utf-8");
-    fs21.rmSync(probePath, { force: true });
+    fs22.writeFileSync(probePath, "ok", "utf-8");
+    fs22.rmSync(probePath, { force: true });
     checks.push({
       label: "Config write",
       ok: true,
@@ -93585,7 +93677,7 @@ function probeConfigAccess() {
     });
   } catch (error48) {
     try {
-      fs21.rmSync(probePath, { force: true });
+      fs22.rmSync(probePath, { force: true });
     } catch {
     }
     checks.push({
@@ -93641,9 +93733,9 @@ function probeCliBinary(commandPath, currentVersion) {
   return probe;
 }
 function readLogHints(logPath) {
-  if (!fs21.existsSync(logPath)) return [];
+  if (!fs22.existsSync(logPath)) return [];
   try {
-    const content = fs21.readFileSync(logPath, "utf-8");
+    const content = fs22.readFileSync(logPath, "utf-8");
     const lines = content.split(/\r?\n/);
     const recent = lines.slice(-400);
     const hits = recent.filter(
@@ -93657,11 +93749,11 @@ function readLogHints(logPath) {
 function buildBrowseProbeChecks() {
   const probes = process.platform === "win32" ? [
     process.env.SystemDrive ? `${process.env.SystemDrive.replace(/[\\/]+$/, "")}\\` : "C:\\",
-    os29.homedir()
-  ] : ["/", os29.homedir()];
+    os30.homedir()
+  ] : ["/", os30.homedir()];
   return probes.map((probePath, index) => {
     try {
-      const entries = fs21.readdirSync(probePath, { withFileTypes: true });
+      const entries = fs22.readdirSync(probePath, { withFileTypes: true });
       const directoryCount = entries.filter((entry) => entry.isDirectory()).length;
       return {
         label: index === 0 ? "Folder browse root" : "Folder browse home",
@@ -93681,7 +93773,7 @@ function buildBrowseProbeChecks() {
 function registerDoctorCommands(program2, pkgVersion3) {
   program2.command("doctor").description("Diagnose install, native dependencies, CLI resolution, and folder browse access").action(async () => {
     const packageRoot = resolvePackageRoot();
-    const cliPath = fs21.realpathSync(process.argv[1]);
+    const cliPath = fs22.realpathSync(process.argv[1]);
     const linked = isLinkedInstall(packageRoot);
     const logPath = getCurrentDaemonLogPath();
     const claudePaths = findCommandPaths("claude");
@@ -93763,12 +93855,12 @@ function registerDoctorCommands(program2, pkgVersion3) {
       });
     }
     if (process.platform === "darwin") {
-      serviceDefinitionPath = path33.join(os29.homedir(), "Library", "LaunchAgents", "dev.adhf.daemon.plist");
-      if (fs21.existsSync(serviceDefinitionPath)) {
+      serviceDefinitionPath = path34.join(os30.homedir(), "Library", "LaunchAgents", "dev.adhf.daemon.plist");
+      if (fs22.existsSync(serviceDefinitionPath)) {
         serviceDefinitionCheck = evaluateServiceDefinitionDrift({
           serviceKind: "launchd",
           servicePath: serviceDefinitionPath,
-          installedDefinition: fs21.readFileSync(serviceDefinitionPath, "utf8"),
+          installedDefinition: fs22.readFileSync(serviceDefinitionPath, "utf8"),
           expectedDefinition: buildPlist(process.execPath, cliPath)
         });
         checks.push({
@@ -93836,12 +93928,12 @@ function registerDoctorCommands(program2, pkgVersion3) {
       serviceCheck: serviceDefinitionCheck || void 0,
       sourceCliExample: "node --import tsx packages/daemon-cloud/src/cli/index.ts doctor"
     });
-    const sessionHostLogPath = path33.join(os29.homedir(), ".adhdev", "logs", "session-host.log");
+    const sessionHostLogPath = path34.join(os30.homedir(), ".adhdev", "logs", "session-host.log");
     console.log(source_default.bold("\n\u{1FA7A} ADHDev Doctor\n"));
     console.log(source_default.gray(`  Version:   ${pkgVersion3}`));
     console.log(source_default.gray(`  Platform:  ${process.platform} ${process.arch}`));
     console.log(source_default.gray(`  Node:      ${process.version}`));
-    console.log(source_default.gray(`  Home:      ${os29.homedir()}`));
+    console.log(source_default.gray(`  Home:      ${os30.homedir()}`));
     console.log(source_default.gray(`  Log file:  ${logPath}`));
     console.log(source_default.gray(`  SH log:    ${sessionHostLogPath}`));
     console.log();
@@ -93878,7 +93970,7 @@ function registerDoctorCommands(program2, pkgVersion3) {
 
 // src/cli/provider-commands.ts
 init_source();
-var path34 = __toESM(require("path"));
+var path35 = __toESM(require("path"));
 init_cdp_utils();
 var DEV_SERVER_PORT3 = 19280;
 var IDE_AUTO_FIX_FUNCTIONS = [
@@ -93961,7 +94053,7 @@ function getProviderSourceCandidatePaths(options) {
   const results = [];
   for (const root of roots) {
     for (const name of relativeNames) {
-      results.push(path34.join(root, options.category, options.type, name));
+      results.push(path35.join(root, options.category, options.type, name));
     }
   }
   return results;
@@ -94096,35 +94188,35 @@ function registerProviderCommands(program2) {
       let osPaths = {};
       let processNames = {};
       if (category === "ide") {
-        const fs22 = await import("fs");
-        const path35 = await import("path");
-        const os30 = await import("os");
-        if (os30.platform() === "darwin") {
+        const fs23 = await import("fs");
+        const path36 = await import("path");
+        const os31 = await import("os");
+        if (os31.platform() === "darwin") {
           while (true) {
             const p = (await rl.question(`macOS Application Path (e.g. /Applications/${defaultName}.app): `)).trim() || `/Applications/${defaultName}.app`;
             if (p === "skip") break;
-            if (!fs22.existsSync(p)) {
+            if (!fs23.existsSync(p)) {
               console.log(source_default.red(`  \u2717 Path not found: ${p}`));
               console.log(source_default.gray(`    (Please provide the exact absolute path to the .app or binary, or type 'skip')`));
               continue;
             }
             console.log(source_default.green(`  \u2713 Path verified: ${p}`));
             osPaths["darwin"] = [p];
-            processNames["darwin"] = path35.basename(p, ".app");
+            processNames["darwin"] = path36.basename(p, ".app");
             break;
           }
-        } else if (os30.platform() === "win32") {
+        } else if (os31.platform() === "win32") {
           while (true) {
             const p = (await rl.question(`Windows Executable Path (e.g. C:\\Program Files\\${defaultName}\\${defaultName}.exe): `)).trim();
             if (!p || p === "skip") break;
-            if (!fs22.existsSync(p)) {
+            if (!fs23.existsSync(p)) {
               console.log(source_default.red(`  \u2717 Path not found: ${p}`));
               console.log(source_default.gray(`    (Please provide the exact absolute path, or type 'skip')`));
               continue;
             }
             console.log(source_default.green(`  \u2713 Path verified: ${p}`));
             osPaths["win32"] = [p];
-            processNames["win32"] = path35.basename(p, ".exe");
+            processNames["win32"] = path36.basename(p, ".exe");
             break;
           }
         }
@@ -94811,8 +94903,8 @@ function registerCdpCommands(program2) {
       }
       const output = typeof result === "string" ? result : JSON.stringify(result, null, 2);
       if (options.output) {
-        const fs22 = await import("fs");
-        fs22.writeFileSync(options.output, output, "utf-8");
+        const fs23 = await import("fs");
+        fs23.writeFileSync(options.output, output, "utf-8");
         console.log(source_default.green(`
   \u2713 Saved to ${options.output} (${output.length} chars)
 `));
@@ -94915,8 +95007,8 @@ function registerCdpCommands(program2) {
         ws.on("message", async (data) => {
           const msg = JSON.parse(data.toString());
           if (msg.id === 1 && msg.result?.data) {
-            const fs22 = await import("fs");
-            fs22.writeFileSync(options.output, Buffer.from(msg.result.data, "base64"));
+            const fs23 = await import("fs");
+            fs23.writeFileSync(options.output, Buffer.from(msg.result.data, "base64"));
             console.log(source_default.green(`
   \u2713 Screenshot saved to ${options.output}
 `));