@adhdev/daemon-core 0.8.29 → 0.8.31

package/dist/index.mjs

@@ -93,12 +93,10 @@ function ensureMachineId(config) {
   if (isStableMachineId(config.machineId)) {
     return { config, changed: false };
   }
-  const legacyRegisteredMachineId = !config.registeredMachineId && config.machineSecret && config.machineId ? config.machineId : config.registeredMachineId;
   return {
     config: {
       ...config,
-      machineId: generateMachineId(),
-      registeredMachineId: legacyRegisteredMachineId
+      machineId: generateMachineId()
     },
     changed: true
   };
@@ -450,7 +448,7 @@ var init_logger = __esm({
 function isModuleNotFoundError(error, ref) {
   if (!(error instanceof Error)) return false;
   const message = error.message || "";
-  const code = error.code;
+  const code = "code" in error ? error.code : void 0;
   return code === "MODULE_NOT_FOUND" && message.includes(ref);
 }
 function normalizeBinding(mod, ref) {
@@ -795,12 +793,7 @@ var init_pty_transport = __esm({
   }
 });
 
-// src/cli-adapters/provider-cli-adapter.ts
-var provider_cli_adapter_exports = {};
-__export(provider_cli_adapter_exports, {
-  ProviderCliAdapter: () => ProviderCliAdapter,
-  normalizeCliProviderForRuntime: () => normalizeCliProviderForRuntime
-});
+// src/cli-adapters/provider-cli-shared.ts
 import * as os8 from "os";
 import * as path9 from "path";
 import { execSync as execSync3 } from "child_process";
@@ -813,6 +806,10 @@ function stripTerminalNoise(str) {
 function sanitizeTerminalText(str) {
   return stripTerminalNoise(stripAnsi(str));
 }
+function listCliScriptNames(scripts) {
+  if (!scripts) return [];
+  return Object.entries(scripts).filter(([, fn]) => typeof fn === "function").map(([name]) => name);
+}
 function splitCliScreenLines(text) {
   return String(text || "").replace(/\u0007/g, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n").map((line) => line.replace(/\s+$/, ""));
 }
@@ -860,18 +857,6 @@ function buildCliScreenSnapshot(text) {
     linesBelowPrompt: promptLineIndex >= 0 ? lines.slice(promptLineIndex + 1) : []
   };
 }
-function computeTerminalQueryTail(buffer) {
-  const prefixes = ["\x1B[6n", "\x1B[?6n"];
-  const maxLength = prefixes.reduce((n, value) => Math.max(n, value.length), 0) - 1;
-  const start = Math.max(0, buffer.length - maxLength);
-  for (let i = start; i < buffer.length; i++) {
-    const suffix = buffer.slice(i);
-    if (prefixes.some((pattern) => suffix.length < pattern.length && pattern.startsWith(suffix))) {
-      return suffix;
-    }
-  }
-  return "";
-}
 function findBinary(name) {
   const trimmed = String(name || "").trim();
   if (!trimmed) return trimmed;
@@ -1021,22 +1006,302 @@ function coercePatternArray(raw) {
   return raw.map(parsePatternEntry).filter((r) => r != null);
 }
 function normalizeCliProviderForRuntime(raw) {
-  const patterns = raw?.patterns || {};
+  const patterns = raw && typeof raw === "object" ? raw.patterns : void 0;
   return {
     patterns: {
-      approval: coercePatternArray(patterns.approval)
+      approval: coercePatternArray(
+        patterns && typeof patterns === "object" ? patterns.approval : void 0
+      )
+    }
+  };
+}
+var buildCliSpawnEnv;
+var init_provider_cli_shared = __esm({
+  "src/cli-adapters/provider-cli-shared.ts"() {
+    "use strict";
+    init_spawn_env();
+    buildCliSpawnEnv = sanitizeSpawnEnv;
+  }
+});
+
+// src/cli-adapters/provider-cli-parse.ts
+function sliceFromOffset(text, start) {
+  if (!text) return "";
+  if (!Number.isFinite(start) || start <= 0) return text;
+  if (start >= text.length) return "";
+  return text.slice(start);
+}
+function hydrateCliParsedMessages(parsedMessages, options) {
+  const { committedMessages, scope, lastOutputAt } = options;
+  const referenceMessages = [...committedMessages];
+  const usedReferenceIndexes = /* @__PURE__ */ new Set();
+  const now = options.now ?? Date.now();
+  const findReferenceTimestamp = (role, content, parsedIndex) => {
+    const normalizedContent = normalizeComparableMessageContent(content);
+    if (!normalizedContent) return void 0;
+    const sameIndex = referenceMessages[parsedIndex];
+    if (sameIndex && !usedReferenceIndexes.has(parsedIndex) && sameIndex.role === role && normalizeComparableMessageContent(sameIndex.content) === normalizedContent && typeof sameIndex.timestamp === "number" && Number.isFinite(sameIndex.timestamp)) {
+      usedReferenceIndexes.add(parsedIndex);
+      return sameIndex.timestamp;
+    }
+    for (let i = 0; i < referenceMessages.length; i++) {
+      if (usedReferenceIndexes.has(i)) continue;
+      const candidate = referenceMessages[i];
+      if (!candidate || candidate.role !== role) continue;
+      const candidateContent = normalizeComparableMessageContent(candidate.content);
+      if (!candidateContent) continue;
+      const exactMatch = candidateContent === normalizedContent;
+      const fuzzyMatch = candidateContent.includes(normalizedContent) || normalizedContent.includes(candidateContent);
+      if (!exactMatch && !fuzzyMatch) continue;
+      if (typeof candidate.timestamp === "number" && Number.isFinite(candidate.timestamp)) {
+        usedReferenceIndexes.add(i);
+        return candidate.timestamp;
+      }
     }
+    return void 0;
   };
+  return parsedMessages.filter((message) => message && (message.role === "user" || message.role === "assistant")).map((message, index) => {
+    const role = message.role;
+    const content = typeof message.content === "string" ? message.content : String(message.content || "");
+    const parsedTimestamp = typeof message.timestamp === "number" && Number.isFinite(message.timestamp) ? message.timestamp : void 0;
+    const referenceTimestamp = parsedTimestamp ?? findReferenceTimestamp(role, content, index);
+    const fallbackTimestamp = role === "user" ? scope?.startedAt || now : lastOutputAt || scope?.startedAt || now;
+    const timestamp = referenceTimestamp ?? fallbackTimestamp;
+    return {
+      ...message,
+      role,
+      content,
+      timestamp,
+      receivedAt: typeof message.receivedAt === "number" && Number.isFinite(message.receivedAt) ? message.receivedAt : timestamp
+    };
+  });
+}
+function normalizeCliParsedMessages(parsedMessages, options) {
+  return hydrateCliParsedMessages(parsedMessages, options).map((message) => ({
+    role: message.role,
+    content: message.content,
+    timestamp: message.timestamp,
+    receivedAt: message.receivedAt,
+    kind: message.kind,
+    id: message.id,
+    index: message.index,
+    meta: message.meta,
+    senderName: message.senderName
+  }));
+}
+function buildCliParseInput(options) {
+  const {
+    accumulatedBuffer,
+    accumulatedRawBuffer,
+    recentOutputBuffer,
+    terminalScreenText,
+    baseMessages,
+    partialResponse,
+    scope,
+    runtimeSettings
+  } = options;
+  const buffer = scope ? sliceFromOffset(accumulatedBuffer, scope.bufferStart) || accumulatedBuffer : accumulatedBuffer;
+  const rawBuffer = scope ? sliceFromOffset(accumulatedRawBuffer, scope.rawBufferStart) || accumulatedRawBuffer : accumulatedRawBuffer;
+  const screenText = terminalScreenText;
+  const recentBuffer = buffer.slice(-1e3) || recentOutputBuffer;
+  return {
+    buffer,
+    rawBuffer,
+    recentBuffer,
+    screenText,
+    screen: buildCliScreenSnapshot(screenText),
+    bufferScreen: buildCliScreenSnapshot(buffer),
+    recentScreen: buildCliScreenSnapshot(recentBuffer),
+    messages: [...baseMessages],
+    partialResponse,
+    promptText: scope?.prompt || "",
+    settings: { ...runtimeSettings }
+  };
+}
+function summarizeCliTraceText(text, max = 800) {
+  const value = sanitizeTerminalText(String(text || ""));
+  if (value.length <= max) return value;
+  return `\u2026${value.slice(-max)}`;
+}
+function summarizeCliTraceMessages(messages, limit = 3) {
+  return messages.slice(-limit).map((message) => ({
+    role: message.role,
+    content: summarizeCliTraceText(message.content, 240),
+    timestamp: message.timestamp
+  }));
+}
+function buildCliTraceParseSnapshot(options) {
+  const { accumulatedBuffer, accumulatedRawBuffer, responseBuffer, partialResponse, scope } = options;
+  const scopedBuffer = scope ? sliceFromOffset(accumulatedBuffer, scope.bufferStart) || accumulatedBuffer : accumulatedBuffer;
+  const scopedRawBuffer = scope ? sliceFromOffset(accumulatedRawBuffer, scope.rawBufferStart) || accumulatedRawBuffer : accumulatedRawBuffer;
+  return {
+    currentTurnScope: scope || null,
+    responseBuffer: summarizeCliTraceText(responseBuffer, 1200),
+    partialResponse: summarizeCliTraceText(partialResponse || responseBuffer, 1200),
+    turnBuffer: summarizeCliTraceText(scopedBuffer, 1600),
+    turnRawPreview: summarizeCliTraceText(scopedRawBuffer, 1600),
+    turnSanitizedRawPreview: summarizeCliTraceText(sanitizeTerminalText(scopedRawBuffer), 1600)
+  };
+}
+var init_provider_cli_parse = __esm({
+  "src/cli-adapters/provider-cli-parse.ts"() {
+    "use strict";
+    init_provider_cli_shared();
+  }
+});
+
+// src/cli-adapters/provider-cli-config.ts
+function resolveCliAdapterConfig(provider) {
+  const t = provider.timeouts || {};
+  const rawKeys = provider.approvalKeys;
+  return {
+    timeouts: {
+      ptyFlush: t.ptyFlush ?? 50,
+      dialogAccept: t.dialogAccept ?? 300,
+      approvalCooldown: t.approvalCooldown ?? 3e3,
+      generatingIdle: t.generatingIdle ?? 6e3,
+      idleFinish: t.idleFinish ?? 5e3,
+      maxResponse: t.maxResponse ?? 3e5,
+      shutdownGrace: t.shutdownGrace ?? 1e3,
+      outputSettle: t.outputSettle ?? 300
+    },
+    approvalKeys: rawKeys && typeof rawKeys === "object" ? rawKeys : {},
+    sendDelayMs: typeof provider.sendDelayMs === "number" ? Math.max(0, provider.sendDelayMs) : 0,
+    sendKey: typeof provider.sendKey === "string" && provider.sendKey.length > 0 ? provider.sendKey : "\r",
+    submitStrategy: provider.submitStrategy === "immediate" ? "immediate" : "wait_for_echo",
+    providerResolutionMeta: {
+      type: provider.type,
+      name: provider.name,
+      resolvedVersion: provider._resolvedVersion || null,
+      resolvedOs: provider._resolvedOs || null,
+      providerDir: provider._resolvedProviderDir || null,
+      scriptDir: provider._resolvedScriptDir || null,
+      scriptsPath: provider._resolvedScriptsPath || null,
+      scriptsSource: provider._resolvedScriptsSource || null,
+      versionWarning: provider._versionWarning || null
+    }
+  };
+}
+var init_provider_cli_config = __esm({
+  "src/cli-adapters/provider-cli-config.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli-adapters/provider-cli-runtime.ts
+import * as os9 from "os";
+import * as path10 from "path";
+function resolveCliSpawnPlan(options) {
+  const { provider, runtimeSettings, workingDir, extraArgs } = 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 = os9.platform() === "win32";
+  const allArgs = [...spawnConfig.args, ...extraArgs];
+  let shellCmd;
+  let shellArgs;
+  const useShellUnix = !isWin && (!!spawnConfig.shell || !path10.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
+  const isCmdShim = isWin && /\.(cmd|bat)$/i.test(binaryPath);
+  const useShellWin = !!spawnConfig.shell || isCmdShim || !path10.isAbsolute(binaryPath) || isScriptBinary(binaryPath);
+  const useShell = isWin ? useShellWin : useShellUnix;
+  if (useShell) {
+    shellCmd = isWin ? "cmd.exe" : process.env.SHELL || "/bin/zsh";
+    if (isWin) {
+      shellArgs = ["/c", binaryPath, ...allArgs];
+    } else {
+      const fullCmd = [binaryPath, ...allArgs].map(shSingleQuote).join(" ");
+      shellArgs = ["-l", "-c", fullCmd];
+    }
+  } else {
+    shellCmd = binaryPath;
+    shellArgs = allArgs;
+  }
+  return {
+    binaryPath,
+    allArgs,
+    shellCmd,
+    shellArgs,
+    isWin,
+    useShell,
+    ptyOptions: {
+      cols: 80,
+      rows: 24,
+      cwd: workingDir,
+      env: buildCliSpawnEnv(process.env, spawnConfig.env)
+    }
+  };
+}
+function buildCliLoginShellRetry(plan) {
+  const shellCmd = process.env.SHELL || "/bin/zsh";
+  const fullCmd = [plan.binaryPath, ...plan.allArgs].map(shSingleQuote).join(" ");
+  return {
+    shellCmd,
+    shellArgs: ["-l", "-c", fullCmd]
+  };
+}
+function getCliSpawnErrorHint(message, shellCmd, isWin) {
+  if (!isWin) return null;
+  if (/error code 267|ERROR_DIRECTORY/i.test(message)) {
+    return " (working directory does not exist or is not a directory)";
+  }
+  if (/error code 740|elevation/i.test(message)) {
+    return " (requires administrator privileges)";
+  }
+  if (/error code 2|ENOENT|not found/i.test(message)) {
+    return ` (executable not found: ${shellCmd})`;
+  }
+  return null;
+}
+function respondToCliTerminalQueries(options) {
+  const { ptyProcess, pendingTail, data, terminalScreen } = options;
+  if (!ptyProcess || !data) return pendingTail;
+  const combined = pendingTail + data;
+  const regex = /\x1b\[(\?)?6n/g;
+  let match;
+  while ((match = regex.exec(combined)) !== null) {
+    const cursor = terminalScreen.getCursorPosition();
+    const row = Math.max(1, (cursor.row | 0) + 1);
+    const col = Math.max(1, (cursor.col | 0) + 1);
+    const response = match[1] ? `\x1B[?${row};${col}R` : `\x1B[${row};${col}R`;
+    ptyProcess.write(response);
+  }
+  const prefixes = ["\x1B[6n", "\x1B[?6n"];
+  const maxLength = prefixes.reduce((n, value) => Math.max(n, value.length), 0) - 1;
+  const start = Math.max(0, combined.length - maxLength);
+  for (let i = start; i < combined.length; i++) {
+    const suffix = combined.slice(i);
+    if (prefixes.some((pattern) => suffix.length < pattern.length && pattern.startsWith(suffix))) {
+      return suffix;
+    }
+  }
+  return "";
 }
-var buildCliSpawnEnv, ProviderCliAdapter;
+var init_provider_cli_runtime = __esm({
+  "src/cli-adapters/provider-cli-runtime.ts"() {
+    "use strict";
+    init_provider_cli_shared();
+  }
+});
+
+// src/cli-adapters/provider-cli-adapter.ts
+var provider_cli_adapter_exports = {};
+__export(provider_cli_adapter_exports, {
+  ProviderCliAdapter: () => ProviderCliAdapter,
+  normalizeCliProviderForRuntime: () => normalizeCliProviderForRuntime
+});
+import * as os10 from "os";
+var ProviderCliAdapter;
 var init_provider_cli_adapter = __esm({
   "src/cli-adapters/provider-cli-adapter.ts"() {
     "use strict";
     init_logger();
     init_terminal_screen();
     init_pty_transport();
-    init_spawn_env();
-    buildCliSpawnEnv = sanitizeSpawnEnv;
+    init_provider_cli_shared();
+    init_provider_cli_parse();
+    init_provider_cli_config();
+    init_provider_cli_runtime();
+    init_provider_cli_shared();
     ProviderCliAdapter = class _ProviderCliAdapter {
       constructor(provider, workingDir, extraArgs = [], transportFactory = new NodePtyTransportFactory()) {
         this.extraArgs = extraArgs;
@@ -1044,36 +1309,16 @@ var init_provider_cli_adapter = __esm({
         this.transportFactory = transportFactory;
         this.cliType = provider.type;
         this.cliName = provider.name;
-        this.workingDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os8.homedir()) : workingDir;
-        const t = provider.timeouts || {};
-        this.timeouts = {
-          ptyFlush: t.ptyFlush ?? 50,
-          dialogAccept: t.dialogAccept ?? 300,
-          approvalCooldown: t.approvalCooldown ?? 3e3,
-          generatingIdle: t.generatingIdle ?? 6e3,
-          idleFinish: t.idleFinish ?? 5e3,
-          maxResponse: t.maxResponse ?? 3e5,
-          shutdownGrace: t.shutdownGrace ?? 1e3,
-          outputSettle: t.outputSettle ?? 300
-        };
-        const rawKeys = provider.approvalKeys;
-        this.approvalKeys = rawKeys && typeof rawKeys === "object" ? rawKeys : {};
-        this.sendDelayMs = typeof provider.sendDelayMs === "number" ? Math.max(0, provider.sendDelayMs) : 0;
-        this.sendKey = typeof provider.sendKey === "string" && provider.sendKey.length > 0 ? provider.sendKey : "\r";
-        this.submitStrategy = provider.submitStrategy === "immediate" ? "immediate" : "wait_for_echo";
-        this.providerResolutionMeta = {
-          type: provider.type,
-          name: provider.name,
-          resolvedVersion: provider._resolvedVersion || null,
-          resolvedOs: provider._resolvedOs || null,
-          providerDir: provider._resolvedProviderDir || null,
-          scriptDir: provider._resolvedScriptDir || null,
-          scriptsPath: provider._resolvedScriptsPath || null,
-          scriptsSource: provider._resolvedScriptsSource || null,
-          versionWarning: provider._versionWarning || null
-        };
+        this.workingDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os10.homedir()) : workingDir;
+        const resolvedConfig = resolveCliAdapterConfig(provider);
+        this.timeouts = resolvedConfig.timeouts;
+        this.approvalKeys = resolvedConfig.approvalKeys;
+        this.sendDelayMs = resolvedConfig.sendDelayMs;
+        this.sendKey = resolvedConfig.sendKey;
+        this.submitStrategy = resolvedConfig.submitStrategy;
+        this.providerResolutionMeta = resolvedConfig.providerResolutionMeta;
         this.cliScripts = provider.scripts || {};
-        const scriptNames = Object.keys(this.cliScripts).filter((k) => typeof this.cliScripts[k] === "function");
+        const scriptNames = listCliScriptNames(this.cliScripts);
         if (scriptNames.length > 0) {
           LOG.info("CLI", `[${this.cliType}] CLI scripts: [${scriptNames.join(", ")}]`);
           LOG.info(
@@ -1170,88 +1415,6 @@ var init_provider_cli_adapter = __esm({
         this.messages = [...this.committedMessages];
         this.structuredMessages = [...this.committedMessages];
       }
-      hydrateParsedMessages(parsedMessages, scope) {
-        const referenceMessages = [...this.committedMessages];
-        const usedReferenceIndexes = /* @__PURE__ */ new Set();
-        const now = Date.now();
-        const findReferenceTimestamp = (role, content, parsedIndex) => {
-          const normalizedContent = normalizeComparableMessageContent(content);
-          if (!normalizedContent) return void 0;
-          const sameIndex = referenceMessages[parsedIndex];
-          if (sameIndex && !usedReferenceIndexes.has(parsedIndex) && sameIndex.role === role && normalizeComparableMessageContent(sameIndex.content) === normalizedContent && typeof sameIndex.timestamp === "number" && Number.isFinite(sameIndex.timestamp)) {
-            usedReferenceIndexes.add(parsedIndex);
-            return sameIndex.timestamp;
-          }
-          for (let i = 0; i < referenceMessages.length; i++) {
-            if (usedReferenceIndexes.has(i)) continue;
-            const candidate = referenceMessages[i];
-            if (!candidate || candidate.role !== role) continue;
-            const candidateContent = normalizeComparableMessageContent(candidate.content);
-            if (!candidateContent) continue;
-            const exactMatch = candidateContent === normalizedContent;
-            const fuzzyMatch = candidateContent.includes(normalizedContent) || normalizedContent.includes(candidateContent);
-            if (!exactMatch && !fuzzyMatch) continue;
-            if (typeof candidate.timestamp === "number" && Number.isFinite(candidate.timestamp)) {
-              usedReferenceIndexes.add(i);
-              return candidate.timestamp;
-            }
-          }
-          return void 0;
-        };
-        return parsedMessages.filter((message) => message && (message.role === "user" || message.role === "assistant")).map((message, index) => {
-          const role = message.role;
-          const content = typeof message.content === "string" ? message.content : String(message.content || "");
-          const parsedTimestamp = typeof message.timestamp === "number" && Number.isFinite(message.timestamp) ? message.timestamp : void 0;
-          const referenceTimestamp = parsedTimestamp ?? findReferenceTimestamp(role, content, index);
-          const fallbackTimestamp = role === "user" ? scope?.startedAt || now : this.lastOutputAt || scope?.startedAt || now;
-          const timestamp = referenceTimestamp ?? fallbackTimestamp;
-          return {
-            ...message,
-            role,
-            content,
-            timestamp,
-            receivedAt: typeof message.receivedAt === "number" && Number.isFinite(message.receivedAt) ? message.receivedAt : timestamp
-          };
-        });
-      }
-      normalizeParsedMessages(parsedMessages, scope) {
-        return this.hydrateParsedMessages(parsedMessages, scope).map((message) => ({
-          role: message.role,
-          content: message.content,
-          timestamp: message.timestamp,
-          receivedAt: message.receivedAt,
-          kind: message.kind,
-          id: message.id,
-          index: message.index,
-          meta: message.meta,
-          senderName: message.senderName
-        }));
-      }
-      sliceFromOffset(text, start) {
-        if (!text) return "";
-        if (!Number.isFinite(start) || start <= 0) return text;
-        if (start >= text.length) return "";
-        return text.slice(start);
-      }
-      buildParseInput(baseMessages, partialResponse, scope) {
-        const buffer = scope ? this.sliceFromOffset(this.accumulatedBuffer, scope.bufferStart) || this.accumulatedBuffer : this.accumulatedBuffer;
-        const rawBuffer = scope ? this.sliceFromOffset(this.accumulatedRawBuffer, scope.rawBufferStart) || this.accumulatedRawBuffer : this.accumulatedRawBuffer;
-        const screenText = this.terminalScreen.getText();
-        const recentBuffer = buffer.slice(-1e3) || this.recentOutputBuffer;
-        return {
-          buffer,
-          rawBuffer,
-          recentBuffer,
-          screenText,
-          screen: buildCliScreenSnapshot(screenText),
-          bufferScreen: buildCliScreenSnapshot(buffer),
-          recentScreen: buildCliScreenSnapshot(recentBuffer),
-          messages: [...baseMessages],
-          partialResponse,
-          promptText: scope?.prompt || "",
-          settings: { ...this.runtimeSettings }
-        };
-      }
       setStatus(status, trigger) {
         const prev = this.currentStatus;
         if (prev === status) return;
@@ -1284,7 +1447,13 @@ var init_provider_cli_adapter = __esm({
         this.recordTrace("idle_candidate_armed", {
           confirmMs: _ProviderCliAdapter.IDLE_FINISH_CONFIRM_MS,
           candidate: this.idleFinishCandidate,
-          ...this.buildTraceParseSnapshot(this.currentTurnScope, this.responseBuffer)
+          ...buildCliTraceParseSnapshot({
+            accumulatedBuffer: this.accumulatedBuffer,
+            accumulatedRawBuffer: this.accumulatedRawBuffer,
+            responseBuffer: this.responseBuffer,
+            partialResponse: this.responseBuffer,
+            scope: this.currentTurnScope
+          })
         });
         if (this.settleTimer) clearTimeout(this.settleTimer);
         this.settleTimer = setTimeout(() => {
@@ -1293,30 +1462,6 @@ var init_provider_cli_adapter = __esm({
           this.evaluateSettled();
         }, _ProviderCliAdapter.IDLE_FINISH_CONFIRM_MS);
       }
-      summarizeTraceText(text, max = 800) {
-        const value = sanitizeTerminalText(String(text || ""));
-        if (value.length <= max) return value;
-        return `\u2026${value.slice(-max)}`;
-      }
-      summarizeTraceMessages(messages, limit = 3) {
-        return messages.slice(-limit).map((message) => ({
-          role: message.role,
-          content: this.summarizeTraceText(message.content, 240),
-          timestamp: message.timestamp
-        }));
-      }
-      buildTraceParseSnapshot(scope, partialResponse = "") {
-        const scopedBuffer = scope ? this.sliceFromOffset(this.accumulatedBuffer, scope.bufferStart) || this.accumulatedBuffer : this.accumulatedBuffer;
-        const scopedRawBuffer = scope ? this.sliceFromOffset(this.accumulatedRawBuffer, scope.rawBufferStart) || this.accumulatedRawBuffer : this.accumulatedRawBuffer;
-        return {
-          currentTurnScope: scope || null,
-          responseBuffer: this.summarizeTraceText(this.responseBuffer, 1200),
-          partialResponse: this.summarizeTraceText(partialResponse || this.responseBuffer, 1200),
-          turnBuffer: this.summarizeTraceText(scopedBuffer, 1600),
-          turnRawPreview: this.summarizeTraceText(scopedRawBuffer, 1600),
-          turnSanitizedRawPreview: this.summarizeTraceText(sanitizeTerminalText(scopedRawBuffer), 1600)
-        };
-      }
       recordTrace(type, payload = {}) {
         const entry = {
           id: ++this.traceSeq,
@@ -1352,7 +1497,7 @@ var init_provider_cli_adapter = __esm({
       /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
       setCliScripts(scripts) {
         this.cliScripts = scripts;
-        const scriptNames = Object.keys(scripts).filter((k) => typeof scripts[k] === "function");
+        const scriptNames = listCliScriptNames(scripts);
         LOG.info("CLI", `[${this.cliType}] CLI scripts injected: [${scriptNames.join(", ")}]`);
       }
       updateRuntimeSettings(settings) {
@@ -1384,72 +1529,42 @@ var init_provider_cli_adapter = __esm({
       }
       async spawn() {
         if (this.ptyProcess) return;
-        const { spawn: spawnConfig } = this.provider;
-        const configuredCommand = typeof this.runtimeSettings.executablePath === "string" && this.runtimeSettings.executablePath.trim() ? this.runtimeSettings.executablePath.trim() : spawnConfig.command;
-        const binaryPath = findBinary(configuredCommand);
-        const isWin = os8.platform() === "win32";
-        const allArgs = [...spawnConfig.args, ...this.extraArgs];
+        const spawnPlan = resolveCliSpawnPlan({
+          provider: this.provider,
+          runtimeSettings: this.runtimeSettings,
+          workingDir: this.workingDir,
+          extraArgs: this.extraArgs
+        });
         LOG.info("CLI", `[${this.cliType}] Spawning in ${this.workingDir}`);
         this.resetTraceSession();
-        let shellCmd;
-        let shellArgs;
-        const useShellUnix = !isWin && (!!spawnConfig.shell || !path9.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
-        const isCmdShim = isWin && /\.(cmd|bat)$/i.test(binaryPath);
-        const useShellWin = !!spawnConfig.shell || isCmdShim || !path9.isAbsolute(binaryPath) || isScriptBinary(binaryPath);
-        const useShell = isWin ? useShellWin : useShellUnix;
-        if (useShell) {
-          if (!spawnConfig.shell && !isWin) {
-            LOG.info("CLI", `[${this.cliType}] Using login shell (script shim or non-native binary)`);
-          }
-          if (isCmdShim) {
-            LOG.info("CLI", `[${this.cliType}] Using cmd.exe shell for .cmd/.bat shim: ${binaryPath}`);
-          } else if (isWin) {
-            LOG.info("CLI", `[${this.cliType}] Using cmd.exe shell on Windows: ${binaryPath}`);
-          }
-          shellCmd = isWin ? "cmd.exe" : process.env.SHELL || "/bin/zsh";
-          if (isWin) {
-            shellArgs = ["/c", binaryPath, ...allArgs];
-          } else {
-            const fullCmd = [binaryPath, ...allArgs].map(shSingleQuote).join(" ");
-            shellArgs = ["-l", "-c", fullCmd];
-          }
-        } else {
-          if (isWin && spawnConfig.shell) {
-            LOG.info("CLI", `[${this.cliType}] Spawning Windows binary directly without cmd.exe: ${binaryPath}`);
-          }
-          shellCmd = binaryPath;
-          shellArgs = allArgs;
-        }
-        const ptyOpts = {
-          cols: 80,
-          rows: 24,
-          cwd: this.workingDir,
-          env: buildCliSpawnEnv(process.env, spawnConfig.env)
-        };
         this.recordTrace("spawn", {
-          shellCommand: shellCmd,
-          shellArgs,
-          cwd: ptyOpts.cwd,
-          cols: ptyOpts.cols,
-          rows: ptyOpts.rows,
+          shellCommand: spawnPlan.shellCmd,
+          shellArgs: spawnPlan.shellArgs,
+          cwd: spawnPlan.ptyOptions.cwd,
+          cols: spawnPlan.ptyOptions.cols,
+          rows: spawnPlan.ptyOptions.rows,
           providerResolution: this.providerResolutionMeta
         });
         try {
-          this.ptyProcess = this.transportFactory.spawn(shellCmd, shellArgs, ptyOpts);
+          this.ptyProcess = this.transportFactory.spawn(
+            spawnPlan.shellCmd,
+            spawnPlan.shellArgs,
+            spawnPlan.ptyOptions
+          );
         } catch (err) {
           const msg = err?.message || String(err);
-          if (!isWin && !useShell && /posix_spawn|spawn/i.test(msg)) {
+          if (!spawnPlan.isWin && !spawnPlan.useShell && /posix_spawn|spawn/i.test(msg)) {
             LOG.warn("CLI", `[${this.cliType}] Direct spawn failed (${msg}), retrying via login shell`);
-            shellCmd = process.env.SHELL || "/bin/zsh";
-            const fullCmd = [binaryPath, ...allArgs].map(shSingleQuote).join(" ");
-            shellArgs = ["-l", "-c", fullCmd];
-            this.ptyProcess = this.transportFactory.spawn(shellCmd, shellArgs, ptyOpts);
+            const retryPlan = buildCliLoginShellRetry(spawnPlan);
+            this.ptyProcess = this.transportFactory.spawn(
+              retryPlan.shellCmd,
+              retryPlan.shellArgs,
+              spawnPlan.ptyOptions
+            );
           } else {
-            if (isWin) {
-              const hint = /error code 267|ERROR_DIRECTORY/i.test(msg) ? " (working directory does not exist or is not a directory)" : /error code 740|elevation/i.test(msg) ? " (requires administrator privileges)" : /error code 2|ENOENT|not found/i.test(msg) ? ` (executable not found: ${shellCmd})` : "";
-              if (hint) {
-                throw new Error(`Failed to spawn CLI${hint}: ${msg}`);
-              }
+            const hint = getCliSpawnErrorHint(msg, spawnPlan.shellCmd, spawnPlan.isWin);
+            if (hint) {
+              throw new Error(`Failed to spawn CLI${hint}: ${msg}`);
             }
             throw err;
           }
@@ -1457,7 +1572,12 @@ var init_provider_cli_adapter = __esm({
         this.ptyProcess.onData((data) => {
           if (Date.now() < this.resizeSuppressUntil) return;
           if (!this.ptyProcess?.terminalQueriesHandled) {
-            this.respondToTerminalQueries(data);
+            this.pendingTerminalQueryTail = respondToCliTerminalQueries({
+              ptyProcess: this.ptyProcess,
+              pendingTail: this.pendingTerminalQueryTail,
+              data,
+              terminalScreen: this.terminalScreen
+            });
           }
           this.pendingOutputParseBuffer += data;
           if (!this.pendingOutputParseTimer) {
@@ -1536,9 +1656,9 @@ var init_provider_cli_adapter = __esm({
         this.recordTrace("output", {
           rawLength: rawData.length,
           cleanLength: cleanData.length,
-          rawPreview: this.summarizeTraceText(rawData, 300),
-          cleanPreview: this.summarizeTraceText(cleanData, 300),
-          screenText: this.summarizeTraceText(this.terminalScreen.getText(), 1200)
+          rawPreview: summarizeCliTraceText(rawData, 300),
+          cleanPreview: summarizeCliTraceText(cleanData, 300),
+          screenText: summarizeCliTraceText(this.terminalScreen.getText(), 1200)
         });
         if (this.startupParseGate) {
           this.scheduleStartupSettleCheck();
@@ -1769,7 +1889,7 @@ var init_provider_cli_adapter = __esm({
             loggedWait = true;
             LOG.info(
               "CLI",
-              `[${this.cliType}] Waiting for interactive prompt: hasPrompt=${hasPrompt} stableMs=${stableMs} recentOutputMs=${recentlyOutput} status=${status} startup=${startupLikelyActive} screen=${JSON.stringify(this.summarizeTraceText(screenText, 220)).slice(0, 260)}`
+              `[${this.cliType}] Waiting for interactive prompt: hasPrompt=${hasPrompt} stableMs=${stableMs} recentOutputMs=${recentlyOutput} status=${status} startup=${startupLikelyActive} screen=${JSON.stringify(summarizeCliTraceText(screenText, 220)).slice(0, 260)}`
             );
           }
           await new Promise((resolve12) => setTimeout(resolve12, 50));
@@ -1777,7 +1897,7 @@ var init_provider_cli_adapter = __esm({
         const finalScreenText = this.terminalScreen.getText() || "";
         LOG.warn(
           "CLI",
-          `[${this.cliType}] Interactive prompt wait timed out after ${maxWaitMs}ms; proceeding with screen=${JSON.stringify(this.summarizeTraceText(finalScreenText, 240)).slice(0, 280)}`
+          `[${this.cliType}] Interactive prompt wait timed out after ${maxWaitMs}ms; proceeding with screen=${JSON.stringify(summarizeCliTraceText(finalScreenText, 240)).slice(0, 280)}`
         );
       }
       evaluateSettled() {
@@ -1807,23 +1927,33 @@ var init_provider_cli_adapter = __esm({
           this.responseBuffer,
           this.currentTurnScope
         );
-        const parsedMessages = Array.isArray(parsedTranscript?.messages) ? this.normalizeParsedMessages(parsedTranscript.messages) : [];
+        const parsedMessages = Array.isArray(parsedTranscript?.messages) ? normalizeCliParsedMessages(parsedTranscript.messages, {
+          committedMessages: this.committedMessages,
+          scope: this.currentTurnScope,
+          lastOutputAt: this.lastOutputAt
+        }) : [];
         const lastParsedAssistant = [...parsedMessages].reverse().find((message) => message.role === "assistant");
         this.recordTrace("settled", {
-          tail: this.summarizeTraceText(tail, 500),
-          screenText: this.summarizeTraceText(screenText, 1200),
+          tail: summarizeCliTraceText(tail, 500),
+          screenText: summarizeCliTraceText(screenText, 1200),
           detectStatus: scriptStatus,
           parsedStatus: parsedTranscript?.status || null,
           parsedMessageCount: parsedMessages.length,
-          parsedLastAssistant: lastParsedAssistant ? this.summarizeTraceText(lastParsedAssistant.content, 280) : "",
+          parsedLastAssistant: lastParsedAssistant ? summarizeCliTraceText(lastParsedAssistant.content, 280) : "",
           parsedActiveModal: parsedTranscript?.activeModal ?? null,
           approval: modal,
-          ...this.buildTraceParseSnapshot(this.currentTurnScope, this.responseBuffer)
+          ...buildCliTraceParseSnapshot({
+            accumulatedBuffer: this.accumulatedBuffer,
+            accumulatedRawBuffer: this.accumulatedRawBuffer,
+            responseBuffer: this.responseBuffer,
+            partialResponse: this.responseBuffer,
+            scope: this.currentTurnScope
+          })
         });
         if (this.currentTurnScope && !lastParsedAssistant) {
           LOG.info(
             "CLI",
-            `[${this.cliType}] Settled without assistant: prompt=${JSON.stringify(this.currentTurnScope.prompt).slice(0, 140)} responseBuffer=${JSON.stringify(this.summarizeTraceText(this.responseBuffer, 220)).slice(0, 260)} screen=${JSON.stringify(this.summarizeTraceText(screenText, 220)).slice(0, 260)} providerDir=${this.providerResolutionMeta.providerDir || "-"} scriptDir=${this.providerResolutionMeta.scriptDir || "-"}`
+            `[${this.cliType}] Settled without assistant: prompt=${JSON.stringify(this.currentTurnScope.prompt).slice(0, 140)} responseBuffer=${JSON.stringify(summarizeCliTraceText(this.responseBuffer, 220)).slice(0, 260)} screen=${JSON.stringify(summarizeCliTraceText(screenText, 220)).slice(0, 260)} providerDir=${this.providerResolutionMeta.providerDir || "-"} scriptDir=${this.providerResolutionMeta.scriptDir || "-"}`
           );
         }
         if (!scriptStatus) return;
@@ -1877,7 +2007,13 @@ var init_provider_cli_adapter = __esm({
             lastNonEmptyOutputAt: this.lastNonEmptyOutputAt,
             lastScreenChangeAt: this.lastScreenChangeAt,
             holdMs: _ProviderCliAdapter.STATUS_ACTIVITY_HOLD_MS,
-            ...this.buildTraceParseSnapshot(this.currentTurnScope, this.responseBuffer)
+            ...buildCliTraceParseSnapshot({
+              accumulatedBuffer: this.accumulatedBuffer,
+              accumulatedRawBuffer: this.accumulatedRawBuffer,
+              responseBuffer: this.responseBuffer,
+              partialResponse: this.responseBuffer,
+              scope: this.currentTurnScope
+            })
           });
           this.onStatusChange?.();
           return;
@@ -1981,7 +2117,13 @@ var init_provider_cli_adapter = __esm({
               canFinishImmediately,
               submitPendingUntil: this.submitPendingUntil,
               responseSettleIgnoreUntil: this.responseSettleIgnoreUntil,
-              ...this.buildTraceParseSnapshot(this.currentTurnScope, this.responseBuffer)
+              ...buildCliTraceParseSnapshot({
+                accumulatedBuffer: this.accumulatedBuffer,
+                accumulatedRawBuffer: this.accumulatedRawBuffer,
+                responseBuffer: this.responseBuffer,
+                partialResponse: this.responseBuffer,
+                scope: this.currentTurnScope
+              })
             });
             if (canFinishImmediately) {
               this.clearIdleFinishCandidate("finish_response");
@@ -2016,7 +2158,13 @@ var init_provider_cli_adapter = __esm({
         if (this.responseSettleIgnoreUntil > Date.now()) return;
         this.clearIdleFinishCandidate("finish_response_enter");
         this.recordTrace("finish_response", {
-          ...this.buildTraceParseSnapshot(this.currentTurnScope, this.responseBuffer)
+          ...buildCliTraceParseSnapshot({
+            accumulatedBuffer: this.accumulatedBuffer,
+            accumulatedRawBuffer: this.accumulatedRawBuffer,
+            responseBuffer: this.responseBuffer,
+            partialResponse: this.responseBuffer,
+            scope: this.currentTurnScope
+          })
         });
         const commitResult = this.commitCurrentTranscript();
         if (this.shouldRetryFinishResponse(commitResult)) {
@@ -2024,8 +2172,14 @@ var init_provider_cli_adapter = __esm({
           this.recordTrace("finish_response_retry", {
             retryCount: this.finishRetryCount,
             retryDelayMs: _ProviderCliAdapter.FINISH_RETRY_DELAY_MS,
-            assistantContent: this.summarizeTraceText(commitResult.assistantContent, 220),
-            ...this.buildTraceParseSnapshot(this.currentTurnScope, this.responseBuffer)
+            assistantContent: summarizeCliTraceText(commitResult.assistantContent, 220),
+            ...buildCliTraceParseSnapshot({
+              accumulatedBuffer: this.accumulatedBuffer,
+              accumulatedRawBuffer: this.accumulatedRawBuffer,
+              responseBuffer: this.responseBuffer,
+              partialResponse: this.responseBuffer,
+              scope: this.currentTurnScope
+            })
           });
           if (this.finishRetryTimer) clearTimeout(this.finishRetryTimer);
           this.finishRetryTimer = setTimeout(() => {
@@ -2074,7 +2228,11 @@ var init_provider_cli_adapter = __esm({
           this.currentTurnScope
         );
         if (parsed && Array.isArray(parsed.messages)) {
-          this.committedMessages = this.normalizeParsedMessages(parsed.messages, this.currentTurnScope);
+          this.committedMessages = normalizeCliParsedMessages(parsed.messages, {
+            committedMessages: this.committedMessages,
+            scope: this.currentTurnScope,
+            lastOutputAt: this.lastOutputAt
+          });
           const promptForTrim = this.currentTurnScope?.prompt || getLastUserPromptText(this.committedMessages);
           if (promptForTrim) {
             const lastAssistantForTrim = [...this.committedMessages].reverse().find((message) => message.role === "assistant");
@@ -2087,14 +2245,20 @@ var init_provider_cli_adapter = __esm({
           this.recordTrace("commit_transcript", {
             parsedStatus: parsed.status || null,
             messageCount: this.committedMessages.length,
-            lastAssistant: lastAssistant ? this.summarizeTraceText(lastAssistant.content, 320) : "",
-            messages: this.summarizeTraceMessages(this.committedMessages),
-            ...this.buildTraceParseSnapshot(this.currentTurnScope, this.responseBuffer)
+            lastAssistant: lastAssistant ? summarizeCliTraceText(lastAssistant.content, 320) : "",
+            messages: summarizeCliTraceMessages(this.committedMessages),
+            ...buildCliTraceParseSnapshot({
+              accumulatedBuffer: this.accumulatedBuffer,
+              accumulatedRawBuffer: this.accumulatedRawBuffer,
+              responseBuffer: this.responseBuffer,
+              partialResponse: this.responseBuffer,
+              scope: this.currentTurnScope
+            })
           });
           if (!lastAssistant && this.currentTurnScope) {
             LOG.warn(
               "CLI",
-              `[${this.cliType}] Commit without assistant turn: prompt=${JSON.stringify(this.currentTurnScope.prompt).slice(0, 140)} responseBuffer=${JSON.stringify(this.summarizeTraceText(this.responseBuffer, 220)).slice(0, 260)} providerDir=${this.providerResolutionMeta.providerDir || "-"} scriptDir=${this.providerResolutionMeta.scriptDir || "-"} scriptsPath=${this.providerResolutionMeta.scriptsPath || "-"}`
+              `[${this.cliType}] Commit without assistant turn: prompt=${JSON.stringify(this.currentTurnScope.prompt).slice(0, 140)} responseBuffer=${JSON.stringify(summarizeCliTraceText(this.responseBuffer, 220)).slice(0, 260)} providerDir=${this.providerResolutionMeta.providerDir || "-"} scriptDir=${this.providerResolutionMeta.scriptDir || "-"} scriptsPath=${this.providerResolutionMeta.scriptsPath || "-"}`
             );
           }
           return {
@@ -2186,7 +2350,11 @@ var init_provider_cli_adapter = __esm({
             index: typeof message.index === "number" ? message.index : index,
             kind: message.kind || "standard",
             receivedAt: typeof message.receivedAt === "number" ? message.receivedAt : message.timestamp
-          })) : this.hydrateParsedMessages(parsed.messages, this.currentTurnScope);
+          })) : hydrateCliParsedMessages(parsed.messages, {
+            committedMessages: this.committedMessages,
+            scope: this.currentTurnScope,
+            lastOutputAt: this.lastOutputAt
+          });
           return {
             id: parsed.id || "cli_session",
             status: parsed.status || this.currentStatus,
@@ -2217,11 +2385,16 @@ var init_provider_cli_adapter = __esm({
         if (typeof fn !== "function") {
           throw new Error(`CLI script '${scriptName}' not available`);
         }
-        const input = this.buildParseInput(
-          this.committedMessages,
-          this.responseBuffer,
-          this.currentTurnScope
-        );
+        const input = buildCliParseInput({
+          accumulatedBuffer: this.accumulatedBuffer,
+          accumulatedRawBuffer: this.accumulatedRawBuffer,
+          recentOutputBuffer: this.recentOutputBuffer,
+          terminalScreenText: this.terminalScreen.getText(),
+          baseMessages: this.committedMessages,
+          partialResponse: this.responseBuffer,
+          scope: this.currentTurnScope,
+          runtimeSettings: this.runtimeSettings
+        });
         return await Promise.resolve(fn({
           ...input,
           args: args && typeof args === "object" ? { ...args } : {}
@@ -2230,7 +2403,16 @@ var init_provider_cli_adapter = __esm({
       parseCurrentTranscript(baseMessages, partialResponse, scope) {
         if (!this.cliScripts?.parseOutput) return null;
         try {
-          const input = this.buildParseInput(baseMessages, partialResponse, scope);
+          const input = buildCliParseInput({
+            accumulatedBuffer: this.accumulatedBuffer,
+            accumulatedRawBuffer: this.accumulatedRawBuffer,
+            recentOutputBuffer: this.recentOutputBuffer,
+            terminalScreenText: this.terminalScreen.getText(),
+            baseMessages,
+            partialResponse,
+            scope,
+            runtimeSettings: this.runtimeSettings
+          });
           const parsed = this.cliScripts.parseOutput(input);
           const refinedStatus = this.refineDetectedStatus(typeof parsed?.status === "string" ? parsed.status : null, input.recentBuffer, input.screenText);
           if (parsed && refinedStatus && parsed.status !== refinedStatus) {
@@ -2320,7 +2502,7 @@ ${data.message || ""}`.trim();
           rawBufferStart: this.accumulatedRawBuffer.length
         };
         this.recordTrace("send_message", {
-          text: this.summarizeTraceText(text, 500),
+          text: summarizeCliTraceText(text, 500),
           estimatedLines: estimatePromptDisplayLines(text),
           turnScope: this.currentTurnScope
         });
@@ -2354,7 +2536,7 @@ ${data.message || ""}`.trim();
           this.recordTrace("submit_write", {
             mode: "submit_key",
             sendKey: this.sendKey,
-            screenText: this.summarizeTraceText(this.terminalScreen.getText(), 500)
+            screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500)
           });
           this.ptyProcess.write(this.sendKey);
           const retrySubmitIfStuck = (attempt) => {
@@ -2371,7 +2553,7 @@ ${data.message || ""}`.trim();
               mode: "submit_retry",
               attempt,
               sendKey: this.sendKey,
-              screenText: this.summarizeTraceText(screenText, 500)
+              screenText: summarizeCliTraceText(screenText, 500)
             });
             this.ptyProcess.write(this.sendKey);
             if (attempt >= 3) {
@@ -2387,9 +2569,9 @@ ${data.message || ""}`.trim();
           this.submitPendingUntil = 0;
           this.recordTrace("submit_write", {
             mode: "immediate",
-            text: this.summarizeTraceText(text, 500),
+            text: summarizeCliTraceText(text, 500),
             sendKey: this.sendKey,
-            screenText: this.summarizeTraceText(this.terminalScreen.getText(), 500)
+            screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500)
           });
           this.ptyProcess.write(text + this.sendKey);
           this.submitRetryTimer = setTimeout(() => {
@@ -2405,7 +2587,7 @@ ${data.message || ""}`.trim();
               mode: "immediate_retry",
               attempt: 1,
               sendKey: this.sendKey,
-              screenText: this.summarizeTraceText(screenText, 500)
+              screenText: summarizeCliTraceText(screenText, 500)
             });
             this.ptyProcess.write(this.sendKey);
             this.submitRetryUsed = true;
@@ -2419,9 +2601,9 @@ ${data.message || ""}`.trim();
         this.ptyProcess.write(text);
         this.recordTrace("submit_write", {
           mode: "type_then_submit",
-          text: this.summarizeTraceText(text, 500),
+          text: summarizeCliTraceText(text, 500),
           sendKey: this.sendKey,
-          screenText: this.summarizeTraceText(this.terminalScreen.getText(), 500)
+          screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500)
         });
         const submitStartedAt = Date.now();
         let lastNormalizedScreen = "";
@@ -2756,7 +2938,7 @@ ${data.message || ""}`.trim();
           responseSettleIgnoreUntil: this.responseSettleIgnoreUntil,
           resizeSuppressUntil: this.resizeSuppressUntil,
           hasCliScripts: this.hasCliScripts(),
-          scriptNames: Object.keys(this.cliScripts).filter((k) => typeof this.cliScripts[k] === "function"),
+          scriptNames: listCliScriptNames(this.cliScripts),
           traceSessionId: this.traceSessionId,
           traceEntryCount: this.traceEntries.length,
           statusHistory: this.statusHistory.slice(-30),
@@ -2773,32 +2955,18 @@ ${data.message || ""}`.trim();
           providerResolution: this.providerResolutionMeta,
           entryCount: this.traceEntries.length,
           entries: this.traceEntries.slice(-cappedLimit),
-          screenText: this.summarizeTraceText(this.terminalScreen.getText(), 4e3),
-          recentOutputBuffer: this.summarizeTraceText(this.recentOutputBuffer, 1e3),
-          responseBuffer: this.summarizeTraceText(this.responseBuffer, 1200),
+          screenText: summarizeCliTraceText(this.terminalScreen.getText(), 4e3),
+          recentOutputBuffer: summarizeCliTraceText(this.recentOutputBuffer, 1e3),
+          responseBuffer: summarizeCliTraceText(this.responseBuffer, 1200),
           status: this.currentStatus,
           activeModal: this.activeModal,
           currentTurnScope: this.currentTurnScope,
-          messages: this.summarizeTraceMessages(this.committedMessages, 5)
+          messages: summarizeCliTraceMessages(this.committedMessages, 5)
         };
       }
       getProviderResolutionMeta() {
         return { ...this.providerResolutionMeta };
       }
-      respondToTerminalQueries(data) {
-        if (!this.ptyProcess || !data) return;
-        const combined = this.pendingTerminalQueryTail + data;
-        const regex = /\x1b\[(\?)?6n/g;
-        let match;
-        while ((match = regex.exec(combined)) !== null) {
-          const cursor = this.terminalScreen.getCursorPosition();
-          const row = Math.max(1, (cursor.row | 0) + 1);
-          const col = Math.max(1, (cursor.col | 0) + 1);
-          const response = match[1] ? `\x1B[?${row};${col}R` : `\x1B[${row};${col}R`;
-          this.ptyProcess.write(response);
-        }
-        this.pendingTerminalQueryTail = computeTerminalQueryTail(combined);
-      }
     };
   }
 });
@@ -3195,17 +3363,17 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs(providerLoader) {
-  const os18 = platform();
+  const os20 = 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[os18] || []) || []);
+    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os20] || []) || []);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os18 === "darwin") {
+    if (!resolvedCli && appPath && os20 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if (existsSync4(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os18 === "win32") {
+    if (!resolvedCli && appPath && os20 === "win32") {
       const { dirname: dirname6 } = await import("path");
       const appDir = dirname6(appPath);
       const candidates = [
@@ -3222,7 +3390,7 @@ async function detectIDEs(providerLoader) {
         }
       }
     }
-    const installed = os18 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
+    const installed = os20 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
     const version = resolvedCli ? getIdeVersion(resolvedCli) : null;
     results.push({
       id: def.id,
@@ -3283,8 +3451,8 @@ function execAsync(cmd, timeoutMs = 5e3) {
   });
 }
 async function detectCLIs(providerLoader, options) {
-  const platform9 = os2.platform();
-  const whichCmd = platform9 === "win32" ? "where" : "which";
+  const platform10 = os2.platform();
+  const whichCmd = platform10 === "win32" ? "where" : "which";
   const includeVersion = options?.includeVersion !== false;
   const cliList = providerLoader ? providerLoader.getCliDetectionList() : [];
   const results = await Promise.all(
@@ -3327,8 +3495,8 @@ async function detectCLI(cliId, providerLoader, options) {
     const cliList = providerLoader.getCliDetectionList();
     const target = cliList.find((c) => c.id === resolvedId);
     if (target) {
-      const platform9 = os2.platform();
-      const whichCmd = platform9 === "win32" ? "where" : "which";
+      const platform10 = os2.platform();
+      const whichCmd = platform10 === "win32" ? "where" : "which";
       try {
         const explicitPath = resolveCommandPath(target.command);
         const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(target.command)}`);
@@ -3449,6 +3617,10 @@ var DaemonCdpManager = class {
   setTargetFilter(filter) {
     this._targetFilter = filter;
   }
+  /** Clear a previously pinned target so the next connect can reselect a page. */
+  clearTargetId() {
+    this._targetId = null;
+  }
   /**
    * Check if a page title should be excluded (non-main page).
    * Uses provider-configured titleExcludes, falls back to default pattern.
@@ -5714,6 +5886,55 @@ ${effect.notification.body || ""}`.trim();
 
 // src/providers/ide-provider-instance.ts
 init_logger();
+
+// src/providers/approval-utils.ts
+var DEFAULT_APPROVAL_POSITIVE_HINTS = [
+  "run",
+  "approve",
+  "accept",
+  "allow once",
+  "always allow",
+  "allow",
+  "yes",
+  "proceed",
+  "continue",
+  "confirm",
+  "save",
+  "ok",
+  "trust"
+];
+function normalizeApprovalLabel(value) {
+  return String(value || "").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+function getApprovalPositiveHints(provider) {
+  const customHints = Array.isArray(provider?.approvalPositiveHints) ? provider.approvalPositiveHints.map((hint) => normalizeApprovalLabel(String(hint || ""))).filter(Boolean) : [];
+  return customHints.length > 0 ? customHints : DEFAULT_APPROVAL_POSITIVE_HINTS;
+}
+function pickApprovalButton(buttons, provider) {
+  const labels = (buttons || []).map((button) => String(button || "").trim()).filter(Boolean);
+  if (labels.length === 0) {
+    return { index: 0, label: "Approve" };
+  }
+  const normalizedButtons = labels.map((label) => normalizeApprovalLabel(label));
+  const hints = getApprovalPositiveHints(provider);
+  for (const hint of hints) {
+    const exactIndex = normalizedButtons.findIndex((label) => label === hint);
+    if (exactIndex >= 0) return { index: exactIndex, label: labels[exactIndex] };
+    const prefixIndex = normalizedButtons.findIndex((label) => label.startsWith(hint));
+    if (prefixIndex >= 0) return { index: prefixIndex, label: labels[prefixIndex] };
+    const includeIndex = normalizedButtons.findIndex((label) => label.includes(hint));
+    if (includeIndex >= 0) return { index: includeIndex, label: labels[includeIndex] };
+  }
+  return { index: 0, label: labels[0] };
+}
+function formatAutoApprovalMessage(modalMessage, buttonLabel) {
+  const lines = [`Auto-approved${buttonLabel ? `: ${buttonLabel}` : ""}`];
+  const cleanMessage = String(modalMessage || "").trim();
+  if (cleanMessage) lines.push(cleanMessage);
+  return lines.join("\n");
+}
+
+// src/providers/ide-provider-instance.ts
 var IdeProviderInstance = class {
   type;
   category = "ide";
@@ -5780,6 +6001,8 @@ var IdeProviderInstance = class {
   }
   getState() {
     const cdp = this.context?.cdp;
+    const autoApproveActive = (this.currentStatus === "waiting_approval" || this.cachedChat?.status === "waiting_approval") && this.canAutoApprove();
+    const visibleStatus = autoApproveActive ? "generating" : this.currentStatus;
     const extensionStates = [];
     for (const ext of this.extensions.values()) {
       extensionStates.push(ext.getState());
@@ -5788,13 +6011,13 @@ var IdeProviderInstance = class {
       type: this.type,
       name: this.provider.name,
       category: "ide",
-      status: this.currentStatus,
+      status: visibleStatus,
       activeChat: this.cachedChat ? {
         id: this.cachedChat.id || "active_session",
         title: this.cachedChat.title || this.type,
-        status: this.cachedChat.status || this.currentStatus,
+        status: autoApproveActive && this.cachedChat.status === "waiting_approval" ? "generating" : this.cachedChat.status || visibleStatus,
         messages: this.mergeConversationMessages(this.cachedChat.messages || []),
-        activeModal: this.cachedChat.activeModal || null,
+        activeModal: autoApproveActive ? null : this.cachedChat.activeModal || null,
         inputContent: this.cachedChat.inputContent || ""
       } : null,
       workspace: this.workspace || null,
@@ -5941,7 +6164,8 @@ var IdeProviderInstance = class {
         }
       }
       if (!raw || typeof raw !== "object") return;
-      let { activeModal } = raw;
+      const chat = raw;
+      let { activeModal } = chat;
       if (activeModal) {
         const w = activeModal.width ?? Infinity;
         const h = activeModal.height ?? Infinity;
@@ -5961,26 +6185,28 @@ var IdeProviderInstance = class {
         if (pm.receivedAt) prevByHash.set(h, pm.receivedAt);
       }
       const now = Date.now();
-      for (const msg of raw.messages || []) {
+      const messages = chat.messages || [];
+      for (const msg of messages) {
         const h = `${msg.role}:${(msg.content || "").slice(0, 100)}`;
         msg.receivedAt = prevByHash.get(h) || now;
       }
-      if (raw.messages?.length > 0) {
+      if (messages.length > 0) {
         const hiddenKinds = /* @__PURE__ */ new Set();
         if (this.settings.showThinking === false) hiddenKinds.add("thought");
         if (this.settings.showToolCalls === false) hiddenKinds.add("tool");
         if (this.settings.showTerminal === false) hiddenKinds.add("terminal");
         if (hiddenKinds.size > 0) {
-          raw.messages = raw.messages.filter((m) => !hiddenKinds.has(m.kind));
+          chat.messages = messages.filter((m) => !hiddenKinds.has(m.kind || ""));
         }
       }
-      const controlValues = extractProviderControlValues(this.provider.controls, raw);
-      if (controlValues) raw.controlValues = controlValues;
-      this.cachedChat = { ...raw, activeModal };
-      this.detectAgentTransitions(raw, now);
-      if (raw.messages?.length > 0) {
-        let toSave = raw.messages;
-        if (raw.status === "generating" || raw.status === "long_generating") {
+      const controlValues = extractProviderControlValues(this.provider.controls, chat);
+      if (controlValues) chat.controlValues = controlValues;
+      this.cachedChat = { ...chat, activeModal };
+      this.detectAgentTransitions(chat, now);
+      const persistedMessages = chat.messages || messages;
+      if (persistedMessages.length > 0) {
+        let toSave = persistedMessages;
+        if (chat.status === "generating" || chat.status === "long_generating") {
           const lastIdx = toSave.length - 1;
           if (lastIdx >= 0 && toSave[lastIdx].role === "assistant") {
             toSave = toSave.slice(0, lastIdx);
@@ -5990,7 +6216,7 @@ var IdeProviderInstance = class {
           this.historyWriter.appendNewMessages(
             this.type,
             toSave,
-            raw.title,
+            chat.title,
             this.instanceId
           );
         }
@@ -6006,14 +6232,16 @@ var IdeProviderInstance = class {
   getReadChatScript() {
     const scripts = this.provider.scripts;
     if (!scripts?.readChat) return null;
-    return typeof scripts.readChat === "function" ? scripts.readChat({}) : scripts.readChat;
+    return scripts.readChat({});
   }
   // ─── status transition detect ─────────────────────────────
   detectAgentTransitions(chatData, now) {
     const chatStatus = chatData?.status;
     if (!chatStatus) return;
     const agentKey = `${this.type}:native`;
-    const agentStatus = chatStatus === "streaming" || chatStatus === "generating" ? "generating" : chatStatus === "waiting_approval" ? "waiting_approval" : "idle";
+    const rawAgentStatus = chatStatus === "streaming" || chatStatus === "generating" ? "generating" : chatStatus === "waiting_approval" ? "waiting_approval" : "idle";
+    const autoApproveActive = rawAgentStatus === "waiting_approval" && this.canAutoApprove();
+    const agentStatus = autoApproveActive ? "generating" : rawAgentStatus;
     const lastMsg = Array.isArray(chatData?.messages) && chatData.messages.length > 0 ? chatData.messages[chatData.messages.length - 1] : null;
     const progressFingerprint = agentStatus === "generating" ? `${lastMsg?.role || ""}:${typeof lastMsg?.content === "string" ? lastMsg.content : JSON.stringify(lastMsg?.content || "")}`.slice(-2e3) : void 0;
     this.currentStatus = agentStatus;
@@ -6045,7 +6273,7 @@ var IdeProviderInstance = class {
     this.applyProviderResponse(chatData, {
       phase: agentStatus === "idle" && (lastStatus === "generating" || lastStatus === "waiting_approval") ? "turn_completed" : "immediate"
     });
-    if (agentStatus === "waiting_approval" && this.settings.autoApprove && !this.autoApproveBusy) {
+    if (rawAgentStatus === "waiting_approval" && autoApproveActive && !this.autoApproveBusy) {
       this.autoApproveViaScript(chatData);
     }
     const monitorEvents = this.monitor.check(agentKey, agentStatus, now, progressFingerprint);
@@ -6196,6 +6424,9 @@ ${effect.notification.body || ""}`.trim();
   updateCdp(cdp) {
     if (this.context) this.context.cdp = cdp;
   }
+  canAutoApprove() {
+    return this.settings.autoApprove !== false && typeof this.provider.scripts?.resolveAction === "function" && !!this.context?.cdp?.isConnected;
+  }
   // ─── Auto-approve via CDP script ────────────────────
   async autoApproveViaScript(_chatData) {
     const cdp = this.context?.cdp;
@@ -6207,17 +6438,15 @@ ${effect.notification.body || ""}`.trim();
     }
     this.autoApproveBusy = true;
     try {
-      let targetButton = _chatData?.activeModal?.buttons?.[0] || "Run";
-      const buttons = _chatData?.activeModal?.buttons || [];
-      for (const b of buttons) {
-        const lower = String(b).toLowerCase().replace(/[^\w]/g, "");
-        if (/^(run|approve|accept|yes|allow|always|proceed|save)/.test(lower)) {
-          targetButton = b;
-          break;
-        }
-      }
+      const { label: targetButton } = pickApprovalButton(_chatData?.activeModal?.buttons, this.provider);
       const script = scriptFn({ action: "approve", button: targetButton, buttonText: targetButton });
       if (!script) return;
+      const now = Date.now();
+      this.appendRuntimeSystemMessage(
+        formatAutoApprovalMessage(_chatData?.activeModal?.message, targetButton),
+        `auto_approval:${now}:${targetButton}`,
+        now
+      );
       LOG.info("IdeInstance", `[IdeInstance:${this.type}] autoApprove: executing resolveAction for "${targetButton}"`);
       let rawResult = await cdp.evaluate(script, 1e4);
       if (typeof rawResult === "string") {
@@ -6239,12 +6468,6 @@ ${effect.notification.body || ""}`.trim();
           LOG.warn("IdeInstance", `[IdeInstance:${this.type}] autoApprove: cdp.send() not available for coordinate click`);
         }
       }
-      this.pushEvent({
-        event: "agent:auto_approved",
-        chatTitle: _chatData?.title || this.provider.name,
-        timestamp: Date.now(),
-        ideType: this.type
-      });
     } catch (e) {
       LOG.warn("IdeInstance", `[IdeInstance:${this.type}] autoApprove error: ${e?.message}`);
     } finally {
@@ -7080,7 +7303,7 @@ function getTargetInstance(h, args) {
   const targetSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
   const sessionId = targetSessionId || h.currentSession?.sessionId || "";
   if (!sessionId) return null;
-  return h.ctx.instanceManager?.getInstance(sessionId);
+  return h.ctx.instanceManager?.getInstance(sessionId) || null;
 }
 function getTargetTransport(h, provider) {
   if (h.currentSession?.transport) return h.currentSession.transport;
@@ -7118,6 +7341,10 @@ function getHistorySessionId(h, args) {
   const providerSessionId = typeof state?.providerSessionId === "string" ? state.providerSessionId.trim() : "";
   return providerSessionId || targetSessionId;
 }
+function callLegacyTextScript(script, text) {
+  if (typeof script !== "function") return null;
+  return script(text);
+}
 function isRecentDuplicateSend(key) {
   const now = Date.now();
   for (const [candidate, ts2] of recentSendByTarget.entries()) {
@@ -7207,7 +7434,7 @@ async function handleReadChat(h, args) {
     const adapter = getTargetedCliAdapter(h, args, provider?.type);
     if (adapter) {
       _log(`${transport} adapter: ${adapter.cliType}`);
-      const status = adapter.getStatus?.();
+      const status = adapter.getStatus();
       if (status) {
         return {
           success: true,
@@ -7447,7 +7674,7 @@ async function handleSendChat(h, args) {
       }
       if (parsed?.needsTypeAndSend && provider?.webviewMatchText && provider?.scripts?.webviewSendMessage) {
         try {
-          const webviewScript = provider.scripts.webviewSendMessage(text);
+          const webviewScript = callLegacyTextScript(provider.scripts.webviewSendMessage, text);
           if (webviewScript && targetCdp.evaluateInWebviewFrame) {
             const matchText = provider.webviewMatchText;
             const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
@@ -7470,7 +7697,7 @@ async function handleSendChat(h, args) {
   }
   if (provider?.webviewMatchText && provider?.scripts?.webviewSendMessage) {
     try {
-      const webviewScript = provider.scripts.webviewSendMessage(text);
+      const webviewScript = callLegacyTextScript(provider.scripts.webviewSendMessage, text);
       if (webviewScript && targetCdp.evaluateInWebviewFrame) {
         const matchText = provider.webviewMatchText;
         const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
@@ -7702,12 +7929,10 @@ async function handleSetMode(h, args) {
   const mode = args?.mode || "agent";
   if (transport === "acp") {
     const adapter = getTargetedCliAdapter(h, args, provider?.type);
-    if (adapter) {
-      const acpInstance = adapter._acpInstance;
-      if (acpInstance && typeof acpInstance.setMode === "function") {
-        await acpInstance.setMode(mode);
-        return { success: true, mode };
-      }
+    const acpInstance = adapter?._acpInstance;
+    if (acpInstance && typeof acpInstance.setMode === "function") {
+      await acpInstance.setMode(mode);
+      return { success: true, mode };
     }
     return { success: false, error: "ACP adapter not found" };
   }
@@ -7760,13 +7985,11 @@ async function handleChangeModel(h, args) {
   if (transport === "acp") {
     const adapter = getTargetedCliAdapter(h, args, provider?.type);
     LOG.info("Command", `[change_model] ACP adapter found: ${!!adapter}, type=${adapter?.cliType}, hasAcpInstance=${!!adapter?._acpInstance}`);
-    if (adapter) {
-      const acpInstance = adapter._acpInstance;
-      if (acpInstance && typeof acpInstance.setConfigOption === "function") {
-        await acpInstance.setConfigOption("model", model);
-        LOG.info("Command", `[change_model] Updated ACP model to ${model}`);
-        return { success: true, model };
-      }
+    const acpInstance = adapter?._acpInstance;
+    if (acpInstance && typeof acpInstance.setConfigOption === "function") {
+      await acpInstance.setConfigOption("model", model);
+      LOG.info("Command", `[change_model] Updated ACP model to ${model}`);
+      return { success: true, model };
     }
     return { success: false, error: "ACP adapter not found" };
   }
@@ -7823,6 +8046,9 @@ async function handleSetThoughtLevel(h, args) {
   const adapter = getTargetedCliAdapter(h, args, provider?.type);
   const acpInstance = adapter?._acpInstance;
   if (!acpInstance) return { success: false, error: "ACP instance not found" };
+  if (typeof acpInstance.setConfigOption !== "function") {
+    return { success: false, error: "ACP setConfigOption not available" };
+  }
   try {
     await acpInstance.setConfigOption(configId, value);
     LOG.info("Command", `[set_thought_level] ${configId}=${value} for ${provider?.type || "unknown_acp"}`);
@@ -7849,7 +8075,7 @@ async function handleResolveAction(h, args) {
         return { success: false, error: `CLI resolveAction failed: ${e.message}` };
       }
     }
-    const status = adapter.getStatus?.();
+    const status = adapter.getStatus();
     if (status?.status !== "waiting_approval") {
       return { success: false, error: "Not in approval state" };
     }
@@ -7888,6 +8114,9 @@ async function handleResolveAction(h, args) {
     const adapter = getTargetedCliAdapter(h, args, provider?.type);
     const acpInstance = adapter?._acpInstance;
     if (!acpInstance) return { success: false, error: "ACP instance not found" };
+    if (typeof acpInstance.resolvePermission !== "function") {
+      return { success: false, error: "ACP resolvePermission not available" };
+    }
     try {
       await acpInstance.resolvePermission(action === "approve" || action === "accept" || action === "always");
       LOG.info("Command", `[resolveAction] ACP \u2192 ${action}`);
@@ -8049,11 +8278,16 @@ async function handleCdpCommand(h, args) {
 }
 async function handleCdpBatch(h, args) {
   if (!h.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
-  const commands = args?.commands;
+  const commands = Array.isArray(args?.commands) ? args.commands : null;
   const stopOnError = args?.stopOnError !== false;
   if (!commands?.length) return { success: false, error: "commands array required" };
   const results = [];
   for (const cmd of commands) {
+    if (!cmd || typeof cmd !== "object" || typeof cmd.method !== "string") {
+      results.push({ method: null, success: false, error: "Invalid command entry" });
+      if (stopOnError) break;
+      continue;
+    }
     try {
       const result = await h.getCdp().sendCdpCommand(cmd.method, cmd.params || {});
       results.push({ method: cmd.method, success: true, result });
@@ -8348,11 +8582,12 @@ function handlePtyResize(h, args) {
   if (!adapter || typeof adapter.resize !== "function") {
     return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || "unknown"}` };
   }
+  const resize = adapter.resize;
   if (force) {
-    adapter.resize(cols - 1, rows);
-    setTimeout(() => adapter.resize(cols, rows), 50);
+    resize(cols - 1, rows);
+    setTimeout(() => resize(cols, rows), 50);
   } else {
-    adapter.resize(cols, rows);
+    resize(cols, rows);
   }
   return { success: true };
 }
@@ -8410,7 +8645,7 @@ function parseScriptResult(result) {
       return { success: true, payload: { result } };
     }
   }
-  if (result && typeof result === "object" && result.success === false) {
+  if (result && typeof result === "object" && "success" in result && result.success === false) {
     return { success: false, payload: result };
   }
   return { success: true, payload: result };
@@ -8833,24 +9068,25 @@ var DaemonCommandHandler = class {
     if (provider?.scripts) {
       const fn = provider.scripts[scriptName];
       if (typeof fn === "function") {
+        const callScript = fn;
         if (params && Object.keys(params).length > 0) {
           const firstVal = Object.values(params)[0];
           if (scriptName === "sendMessage" && typeof firstVal === "string") {
-            const legacyScript = fn(firstVal);
+            const legacyScript = callScript(firstVal);
             if (legacyScript) return legacyScript;
           }
-          const script = fn(params);
+          const script = callScript(params);
           if (script) {
             const likelyLegacyObjectLeak = typeof script === "string" && script.includes("[object Object]") && typeof firstVal === "string";
             if (!likelyLegacyObjectLeak) return script;
           }
           if (firstVal !== void 0) {
-            const legacyScript = fn(firstVal);
+            const legacyScript = callScript(firstVal);
             if (legacyScript) return legacyScript;
           }
           if (script) return script;
         } else {
-          const script = fn();
+          const script = callScript();
           if (script) return script;
         }
       }
@@ -9231,16 +9467,16 @@ var DaemonCommandHandler = class {
 
 // src/commands/cli-manager.ts
 init_provider_cli_adapter();
-import * as os10 from "os";
-import * as path11 from "path";
+import * as os12 from "os";
+import * as path12 from "path";
 import * as crypto4 from "crypto";
 import chalk from "chalk";
 init_config();
 
 // src/providers/cli-provider-instance.ts
 init_provider_cli_adapter();
-import * as os9 from "os";
-import * as path10 from "path";
+import * as os11 from "os";
+import * as path11 from "path";
 import * as crypto3 from "crypto";
 import * as fs5 from "fs";
 import { createRequire } from "module";
@@ -9248,7 +9484,7 @@ init_logger();
 var CachedDatabaseSync = null;
 function getDatabaseSync() {
   if (CachedDatabaseSync) return CachedDatabaseSync;
-  const requireFn = typeof __require === "function" ? __require : createRequire(path10.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
+  const requireFn = typeof __require === "function" ? __require : createRequire(path11.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
   const sqliteModule = requireFn(`node:${"sqlite"}`);
   CachedDatabaseSync = sqliteModule.DatabaseSync;
   if (!CachedDatabaseSync) {
@@ -9388,7 +9624,7 @@ var CliProviderInstance = class {
    * Replaces the previously duplicated probeOpenCode/Codex/Goose functions.
    */
   probeSessionIdFromConfig(probe) {
-    const resolvedDbPath = probe.dbPath.replace(/^~/, os9.homedir());
+    const resolvedDbPath = probe.dbPath.replace(/^~/, os11.homedir());
     if (!fs5.existsSync(resolvedDbPath)) return null;
     const directories = this.getProbeDirectories();
     const minCreatedAt = Math.max(0, this.startedAt - 6e4);
@@ -9412,6 +9648,8 @@ var CliProviderInstance = class {
   getState() {
     const adapterStatus = this.adapter.getStatus();
     const parsedStatus = this.adapter.getScriptParsedStatus?.() || null;
+    const autoApproveActive = adapterStatus.status === "waiting_approval" && this.shouldAutoApprove();
+    const visibleStatus = autoApproveActive ? "generating" : adapterStatus.status;
     const parsedProviderSessionId = typeof parsedStatus?.providerSessionId === "string" ? parsedStatus.providerSessionId.trim() : "";
     if (parsedProviderSessionId) {
       this.promoteProviderSessionId(parsedProviderSessionId);
@@ -9451,14 +9689,14 @@ var CliProviderInstance = class {
       type: this.type,
       name: this.provider.name,
       category: "cli",
-      status: adapterStatus.status,
+      status: visibleStatus,
       mode: this.presentationMode,
       activeChat: {
         id: `${this.type}_${this.workingDir}`,
         title: parsedStatus?.title || dirName,
-        status: parsedStatus?.status || adapterStatus.status,
+        status: autoApproveActive && parsedStatus?.status === "waiting_approval" ? "generating" : parsedStatus?.status || visibleStatus,
         messages: mergedMessages,
-        activeModal: parsedStatus?.activeModal ?? adapterStatus.activeModal,
+        activeModal: autoApproveActive ? null : parsedStatus?.activeModal ?? adapterStatus.activeModal,
         inputContent: ""
       },
       workspace: this.workingDir,
@@ -9522,7 +9760,16 @@ var CliProviderInstance = class {
     const now = Date.now();
     const adapterStatus = this.adapter.getStatus();
     const parsedStatus = this.adapter.getScriptParsedStatus?.() || null;
-    const newStatus = adapterStatus.status;
+    const rawStatus = adapterStatus.status;
+    const autoApproveActive = rawStatus === "waiting_approval" && this.shouldAutoApprove();
+    if (autoApproveActive) {
+      const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(adapterStatus.activeModal?.buttons, this.provider);
+      this.recordAutoApproval(adapterStatus.activeModal?.message, buttonLabel, now);
+      setTimeout(() => {
+        this.adapter.resolveModal(buttonIndex);
+      }, 0);
+    }
+    const newStatus = autoApproveActive ? "generating" : rawStatus;
     const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
     const chatTitle = `${this.provider.name} \xB7 ${dirName}`;
     const partial = this.adapter.getPartialResponse();
@@ -9732,6 +9979,16 @@ ${effect.notification.body || ""}`.trim();
   get cliName() {
     return this.provider.name;
   }
+  shouldAutoApprove() {
+    return this.settings.autoApprove !== false;
+  }
+  recordAutoApproval(modalMessage, buttonLabel, now = Date.now()) {
+    this.appendRuntimeSystemMessage(
+      formatAutoApprovalMessage(modalMessage, buttonLabel),
+      `auto_approval:${now}:${buttonLabel || "approve"}`,
+      now
+    );
+  }
   recordApprovalSelection(buttonText) {
     const cleanButton = String(buttonText || "").trim();
     if (!cleanButton) return;
@@ -10310,8 +10567,10 @@ var AcpProviderInstance = class {
             input: tc.rawInput ? typeof tc.rawInput === "string" ? tc.rawInput : JSON.stringify(tc.rawInput) : void 0
           });
         }
-        if (this.settings.autoApprove) {
-          this.log.info(`[${this.type}] Auto-approving: ${tc.title || tc.toolCallId}`);
+        if (this.settings.autoApprove !== false) {
+          const toolTitle = tc.title || tc.toolCallId || "tool call";
+          this.log.info(`[${this.type}] Auto-approving: ${toolTitle}`);
+          this.appendSystemMessage(`Auto-approved: ${toolTitle}`);
           const allowOption = params.options.find((o) => o.kind === "allow_once") || params.options.find((o) => o.kind === "allow_always");
           if (allowOption) {
             return { outcome: { outcome: "selected", optionId: allowOption.optionId } };
@@ -10763,6 +11022,18 @@ var AcpProviderInstance = class {
     this.events.push(event);
     if (this.events.length > 50) this.events = this.events.slice(-50);
   }
+  appendSystemMessage(content, timestamp = Date.now()) {
+    const normalizedContent = String(content || "").trim();
+    if (!normalizedContent) return;
+    this.messages.push({
+      role: "system",
+      content: normalizedContent,
+      timestamp
+    });
+    if (this.messages.length > 200) {
+      this.messages = this.messages.slice(-100);
+    }
+  }
   flushEvents() {
     const events = [...this.events];
     this.events = [];
@@ -10783,7 +11054,8 @@ var AcpProviderInstance = class {
 
 // src/commands/cli-manager.ts
 init_logger();
-var chalkApi = chalk?.yellow ? chalk : chalk?.default || null;
+var chalkModule = chalk;
+var chalkApi = typeof chalkModule.yellow === "function" ? chalkModule : chalkModule.default || null;
 function colorize(color, text) {
   const fn = chalkApi?.[color];
   return typeof fn === "function" ? fn(text) : text;
@@ -11033,7 +11305,7 @@ var DaemonCliManager = class {
   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(/^~/, os10.homedir()) : path11.resolve(trimmed);
+    const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os12.homedir()) : path12.resolve(trimmed);
     const normalizedType = this.providerLoader.resolveAlias(cliType);
     const provider = this.providerLoader.getByAlias(cliType);
     const key = crypto4.randomUUID();
@@ -11072,6 +11344,7 @@ ${installInfo}`
       });
       this.adapters.set(key, {
         cliType: normalizedType,
+        cliName: provider.name,
         workingDir: resolvedDir,
         _acpInstance: acpInstance,
         spawn: async () => {
@@ -11090,6 +11363,12 @@ ${installInfo}`
             activeModal: state.activeChat?.activeModal || null
           };
         },
+        getPartialResponse: () => "",
+        cancel: () => {
+          instanceManager2.removeInstance(key);
+        },
+        isProcessing: () => false,
+        isReady: () => true,
         setOnStatusChange: () => {
         },
         setOnPtyData: () => {
@@ -11496,13 +11775,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
 // src/launch.ts
 import { execSync as execSync4, spawn as spawn2 } from "child_process";
 import * as net from "net";
-import * as os12 from "os";
-import * as path13 from "path";
+import * as os14 from "os";
+import * as path14 from "path";
 
 // src/providers/provider-loader.ts
 import * as fs6 from "fs";
-import * as path12 from "path";
-import * as os11 from "os";
+import * as path13 from "path";
+import * as os13 from "os";
 import * as chokidar from "chokidar";
 init_logger();
 var ProviderLoader = class _ProviderLoader {
@@ -11523,12 +11802,12 @@ var ProviderLoader = class _ProviderLoader {
   static META_FILE = ".meta.json";
   constructor(options) {
     this.logFn = options?.logFn || LOG.forComponent("Provider").asLogFn();
-    const defaultProvidersDir = path12.join(os11.homedir(), ".adhdev", "providers");
+    const defaultProvidersDir = path13.join(os13.homedir(), ".adhdev", "providers");
     if (options?.userDir) {
       this.userDir = options.userDir;
       this.log(`Config 'providerDir' applied: ${this.userDir}`);
     } else {
-      const localRepoPath = path12.resolve(__dirname, "../../../../../adhdev-providers");
+      const localRepoPath = path13.resolve(__dirname, "../../../../../adhdev-providers");
       if (fs6.existsSync(localRepoPath)) {
         this.userDir = localRepoPath;
         this.log(`Auto-detected local public repository: ${this.userDir} (Dev workspace speedup)`);
@@ -11537,7 +11816,7 @@ var ProviderLoader = class _ProviderLoader {
         this.log(`Using default user providers directory: ${this.userDir}`);
       }
     }
-    this.upstreamDir = path12.join(defaultProvidersDir, ".upstream");
+    this.upstreamDir = path13.join(defaultProvidersDir, ".upstream");
     this.disableUpstream = options?.disableUpstream ?? false;
   }
   log(msg) {
@@ -11567,7 +11846,7 @@ var ProviderLoader = class _ProviderLoader {
   * Canonical provider directory shape for a given root.
   */
   getProviderDir(root, category, type) {
-    return path12.join(root, category, type);
+    return path13.join(root, category, type);
   }
   /**
   * Canonical user override directory for a provider.
@@ -11594,7 +11873,7 @@ var ProviderLoader = class _ProviderLoader {
   resolveProviderFile(type, ...segments) {
     const dir = this.findProviderDirInternal(type);
     if (!dir) return null;
-    return path12.join(dir, ...segments);
+    return path13.join(dir, ...segments);
   }
   /**
   * Load all providers (3-tier priority)
@@ -11633,7 +11912,7 @@ var ProviderLoader = class _ProviderLoader {
     if (!fs6.existsSync(this.upstreamDir)) return false;
     try {
       return fs6.readdirSync(this.upstreamDir).some(
-        (d) => fs6.statSync(path12.join(this.upstreamDir, d)).isDirectory()
+        (d) => fs6.statSync(path13.join(this.upstreamDir, d)).isDirectory()
       );
     } catch {
       return false;
@@ -11674,8 +11953,7 @@ var ProviderLoader = class _ProviderLoader {
     const result = [];
     for (const p of this.providers.values()) {
       if ((p.category === "cli" || p.category === "acp") && p.spawn?.command) {
-        const verCmdConfig = p.versionCommand;
-        const versionCommand = typeof verCmdConfig === "object" && verCmdConfig !== null ? verCmdConfig[process.platform] : verCmdConfig;
+        const versionCommand = this.getPlatformVersionCommand(p.versionCommand);
         const command = this.getSpawnCommand(p.type, p.spawn.command);
         result.push({
           id: p.type,
@@ -11729,8 +12007,8 @@ var ProviderLoader = class _ProviderLoader {
   * that runtime attach/remove uses.
   */
   getIdeExtensionEnabledState(ideType, extensionType) {
-    const { loadConfig: loadConfig2 } = (init_config(), __toCommonJS(config_exports));
-    const config = loadConfig2();
+    const config = this.readConfig();
+    if (!config) return false;
     const baseIdeType = ideType.split("_")[0];
     const val = config.ideSettings?.[baseIdeType]?.extensions?.[extensionType]?.enabled;
     return val === true;
@@ -11739,15 +12017,15 @@ var ProviderLoader = class _ProviderLoader {
   * Save IDE extension enabled setting
   */
   setIdeExtensionEnabled(ideType, extensionType, enabled) {
+    const config = this.readConfig();
+    if (!config) return false;
     try {
-      const { loadConfig: loadConfig2, saveConfig: saveConfig3 } = (init_config(), __toCommonJS(config_exports));
-      const config = loadConfig2();
       const baseIdeType = ideType.split("_")[0];
       if (!config.ideSettings) config.ideSettings = {};
       if (!config.ideSettings[baseIdeType]) config.ideSettings[baseIdeType] = {};
       if (!config.ideSettings[baseIdeType].extensions) config.ideSettings[baseIdeType].extensions = {};
       config.ideSettings[baseIdeType].extensions[extensionType] = { enabled };
-      saveConfig3(config);
+      this.writeConfig(config);
       this.log(`IDE extension setting: ${ideType}.${extensionType}.enabled = ${enabled}`);
       return true;
     } catch (e) {
@@ -11937,7 +12215,7 @@ var ProviderLoader = class _ProviderLoader {
     }
     if (currentVersion) {
       resolved._resolvedVersion = currentVersion;
-      if (Array.isArray(base.compatibility)) {
+      if (base.compatibility) {
         const compat = base.compatibility;
         let matched = false;
         for (const entry of compat) {
@@ -11949,8 +12227,8 @@ var ProviderLoader = class _ProviderLoader {
               resolved._resolvedScriptDir = entry.scriptDir;
               resolved._resolvedScriptsSource = `compatibility:${entry.ideVersion}`;
               if (providerDir) {
-                const fullDir = path12.join(providerDir, entry.scriptDir);
-                resolved._resolvedScriptsPath = fs6.existsSync(path12.join(fullDir, "scripts.js")) ? path12.join(fullDir, "scripts.js") : fullDir;
+                const fullDir = path13.join(providerDir, entry.scriptDir);
+                resolved._resolvedScriptsPath = fs6.existsSync(path13.join(fullDir, "scripts.js")) ? path13.join(fullDir, "scripts.js") : fullDir;
               }
               matched = true;
             }
@@ -11965,8 +12243,8 @@ var ProviderLoader = class _ProviderLoader {
             resolved._resolvedScriptDir = base.defaultScriptDir;
             resolved._resolvedScriptsSource = "defaultScriptDir:version_miss";
             if (providerDir) {
-              const fullDir = path12.join(providerDir, base.defaultScriptDir);
-              resolved._resolvedScriptsPath = fs6.existsSync(path12.join(fullDir, "scripts.js")) ? path12.join(fullDir, "scripts.js") : fullDir;
+              const fullDir = path13.join(providerDir, base.defaultScriptDir);
+              resolved._resolvedScriptsPath = fs6.existsSync(path13.join(fullDir, "scripts.js")) ? path13.join(fullDir, "scripts.js") : fullDir;
             }
           }
           resolved._versionWarning = `Version ${currentVersion} not in compatibility matrix. Using default scripts.`;
@@ -11983,8 +12261,8 @@ var ProviderLoader = class _ProviderLoader {
               resolved._resolvedScriptDir = dirOverride;
               resolved._resolvedScriptsSource = `versions:${range}`;
               if (providerDir) {
-                const fullDir = path12.join(providerDir, dirOverride);
-                resolved._resolvedScriptsPath = fs6.existsSync(path12.join(fullDir, "scripts.js")) ? path12.join(fullDir, "scripts.js") : fullDir;
+                const fullDir = path13.join(providerDir, dirOverride);
+                resolved._resolvedScriptsPath = fs6.existsSync(path13.join(fullDir, "scripts.js")) ? path13.join(fullDir, "scripts.js") : fullDir;
               }
             }
           } else if (override.scripts) {
@@ -11992,7 +12270,7 @@ var ProviderLoader = class _ProviderLoader {
           }
         }
       }
-    } else if (Array.isArray(base.compatibility) && base.defaultScriptDir) {
+    } else if (base.compatibility && base.defaultScriptDir) {
       const loaded = this.loadScriptsFromDir(type, base.defaultScriptDir);
       if (loaded) {
         resolved.scripts = loaded;
@@ -12000,8 +12278,8 @@ var ProviderLoader = class _ProviderLoader {
         resolved._resolvedScriptDir = base.defaultScriptDir;
         resolved._resolvedScriptsSource = "defaultScriptDir:no_version";
         if (providerDir) {
-          const fullDir = path12.join(providerDir, base.defaultScriptDir);
-          resolved._resolvedScriptsPath = fs6.existsSync(path12.join(fullDir, "scripts.js")) ? path12.join(fullDir, "scripts.js") : fullDir;
+          const fullDir = path13.join(providerDir, base.defaultScriptDir);
+          resolved._resolvedScriptsPath = fs6.existsSync(path13.join(fullDir, "scripts.js")) ? path13.join(fullDir, "scripts.js") : fullDir;
         }
       }
     }
@@ -12026,14 +12304,14 @@ var ProviderLoader = class _ProviderLoader {
       this.log(`  [loadScriptsFromDir] ${type}: providerDir not found`);
       return null;
     }
-    const dir = path12.join(providerDir, scriptDir);
+    const dir = path13.join(providerDir, scriptDir);
     if (!fs6.existsSync(dir)) {
       this.log(`  [loadScriptsFromDir] ${type}: dir not found: ${dir}`);
       return null;
     }
     const cached = this.scriptsCache.get(dir);
     if (cached) return cached;
-    const scriptsJs = path12.join(dir, "scripts.js");
+    const scriptsJs = path13.join(dir, "scripts.js");
     if (fs6.existsSync(scriptsJs)) {
       try {
         delete __require.cache[__require.resolve(scriptsJs)];
@@ -12075,7 +12353,7 @@ var ProviderLoader = class _ProviderLoader {
             return;
           }
           if (filePath.endsWith(".js") || filePath.endsWith(".json")) {
-            this.log(`File changed: ${path12.basename(filePath)}, reloading...`);
+            this.log(`File changed: ${path13.basename(filePath)}, reloading...`);
             this.reload();
           }
         };
@@ -12130,7 +12408,7 @@ var ProviderLoader = class _ProviderLoader {
     }
     const https = __require("https");
     const { execSync: execSync7 } = __require("child_process");
-    const metaPath = path12.join(this.upstreamDir, _ProviderLoader.META_FILE);
+    const metaPath = path13.join(this.upstreamDir, _ProviderLoader.META_FILE);
     let prevEtag = "";
     let prevTimestamp = 0;
     try {
@@ -12190,17 +12468,17 @@ var ProviderLoader = class _ProviderLoader {
         return { updated: false };
       }
       this.log("Downloading latest providers from GitHub...");
-      const tmpTar = path12.join(os11.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
-      const tmpExtract = path12.join(os11.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
+      const tmpTar = path13.join(os13.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
+      const tmpExtract = path13.join(os13.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
       await this.downloadFile(_ProviderLoader.GITHUB_TARBALL_URL, tmpTar);
       fs6.mkdirSync(tmpExtract, { recursive: true });
       execSync7(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
       const extracted = fs6.readdirSync(tmpExtract);
       const rootDir = extracted.find(
-        (d) => fs6.statSync(path12.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
+        (d) => fs6.statSync(path13.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
       );
       if (!rootDir) throw new Error("Unexpected tarball structure");
-      const sourceDir = path12.join(tmpExtract, rootDir);
+      const sourceDir = path13.join(tmpExtract, rootDir);
       const backupDir = this.upstreamDir + ".bak";
       if (fs6.existsSync(this.upstreamDir)) {
         if (fs6.existsSync(backupDir)) fs6.rmSync(backupDir, { recursive: true, force: true });
@@ -12275,8 +12553,8 @@ var ProviderLoader = class _ProviderLoader {
   copyDirRecursive(src, dest) {
     fs6.mkdirSync(dest, { recursive: true });
     for (const entry of fs6.readdirSync(src, { withFileTypes: true })) {
-      const srcPath = path12.join(src, entry.name);
-      const destPath = path12.join(dest, entry.name);
+      const srcPath = path13.join(src, entry.name);
+      const destPath = path13.join(dest, entry.name);
       if (entry.isDirectory()) {
         this.copyDirRecursive(srcPath, destPath);
       } else {
@@ -12287,7 +12565,7 @@ var ProviderLoader = class _ProviderLoader {
   /** .meta.json save */
   writeMeta(metaPath, etag, timestamp) {
     try {
-      fs6.mkdirSync(path12.dirname(metaPath), { recursive: true });
+      fs6.mkdirSync(path13.dirname(metaPath), { recursive: true });
       fs6.writeFileSync(metaPath, JSON.stringify({
         etag,
         timestamp,
@@ -12304,7 +12582,7 @@ var ProviderLoader = class _ProviderLoader {
     const scan = (d) => {
       try {
         for (const entry of fs6.readdirSync(d, { withFileTypes: true })) {
-          if (entry.isDirectory()) scan(path12.join(d, entry.name));
+          if (entry.isDirectory()) scan(path13.join(d, entry.name));
           else if (entry.name === "provider.json") count++;
         }
       } catch {
@@ -12337,15 +12615,10 @@ var ProviderLoader = class _ProviderLoader {
   */
   getSettingValue(type, key) {
     const schemaDef = this.getSettingsSchema(type)[key];
-    const defaultVal = schemaDef ? schemaDef.default : void 0;
-    try {
-      const { loadConfig: loadConfig2 } = (init_config(), __toCommonJS(config_exports));
-      const config = loadConfig2();
-      const userVal = config.providerSettings?.[type]?.[key];
-      return userVal !== void 0 ? userVal : defaultVal;
-    } catch {
-      return defaultVal;
-    }
+    const defaultVal = schemaDef ? key === "autoApprove" && schemaDef.type === "boolean" ? true : schemaDef.default : void 0;
+    const config = this.readConfig();
+    const userVal = config?.providerSettings?.[type]?.[key];
+    return userVal !== void 0 ? userVal : defaultVal;
   }
   /**
   * All resolved settings for a provider (default + user override)
@@ -12373,13 +12646,13 @@ var ProviderLoader = class _ProviderLoader {
       if (schemaDef.max !== void 0 && value > schemaDef.max) return false;
     }
     if (schemaDef.type === "select" && schemaDef.options && !schemaDef.options.includes(value)) return false;
+    const config = this.readConfig();
+    if (!config) return false;
     try {
-      const { loadConfig: loadConfig2, saveConfig: saveConfig3 } = (init_config(), __toCommonJS(config_exports));
-      const config = loadConfig2();
       if (!config.providerSettings) config.providerSettings = {};
       if (!config.providerSettings[type]) config.providerSettings[type] = {};
       config.providerSettings[type][key] = value;
-      saveConfig3(config);
+      this.writeConfig(config);
       this.log(`Setting updated: ${type}.${key} = ${JSON.stringify(value)}`);
       return true;
     } catch (e) {
@@ -12393,16 +12666,63 @@ var ProviderLoader = class _ProviderLoader {
     const trimmed = value.trim();
     return trimmed ? trimmed : null;
   }
+  readConfig() {
+    try {
+      const { loadConfig: loadConfig2 } = (init_config(), __toCommonJS(config_exports));
+      return loadConfig2();
+    } catch {
+      return null;
+    }
+  }
+  writeConfig(config) {
+    const { saveConfig: saveConfig3 } = (init_config(), __toCommonJS(config_exports));
+    saveConfig3(config);
+  }
+  getPlatformVersionCommand(versionCommand) {
+    if (!versionCommand) return void 0;
+    if (typeof versionCommand === "string") {
+      const trimmed = versionCommand.trim();
+      return trimmed || void 0;
+    }
+    const platformValue = versionCommand[process.platform];
+    if (typeof platformValue === "string" && platformValue.trim()) {
+      return platformValue.trim();
+    }
+    const defaultValue = versionCommand.default;
+    if (typeof defaultValue === "string" && defaultValue.trim()) {
+      return defaultValue.trim();
+    }
+    return void 0;
+  }
   getSettingsSchema(type) {
     const provider = this.providers.get(type);
     if (!provider) return {};
-    return {
+    const result = {
       ...this.getSyntheticSettings(type, provider),
       ...provider.settings || {}
     };
+    if (result.autoApprove?.type === "boolean") {
+      result.autoApprove = {
+        ...result.autoApprove,
+        default: true,
+        public: true,
+        label: result.autoApprove.label || "Auto Approve",
+        description: result.autoApprove.description || "Automatically approve actionable prompts without sending approval alerts."
+      };
+    }
+    return result;
   }
   getSyntheticSettings(type, provider) {
     const result = {};
+    if (!provider.settings?.autoApprove) {
+      result.autoApprove = {
+        type: "boolean",
+        default: true,
+        public: true,
+        label: "Auto Approve",
+        description: "Automatically approve actionable prompts without sending approval alerts."
+      };
+    }
     if ((provider.category === "cli" || provider.category === "acp") && provider.spawn?.command && !provider.settings?.executablePath) {
       result.executablePath = {
         type: "string",
@@ -12447,17 +12767,17 @@ var ProviderLoader = class _ProviderLoader {
     for (const root of searchRoots) {
       if (!fs6.existsSync(root)) continue;
       const candidate = this.getProviderDir(root, cat, type);
-      if (fs6.existsSync(path12.join(candidate, "provider.json"))) return candidate;
-      const catDir = path12.join(root, cat);
+      if (fs6.existsSync(path13.join(candidate, "provider.json"))) return candidate;
+      const catDir = path13.join(root, cat);
       if (fs6.existsSync(catDir)) {
         try {
           for (const entry of fs6.readdirSync(catDir, { withFileTypes: true })) {
             if (!entry.isDirectory()) continue;
-            const jsonPath = path12.join(catDir, entry.name, "provider.json");
+            const jsonPath = path13.join(catDir, entry.name, "provider.json");
             if (fs6.existsSync(jsonPath)) {
               try {
                 const data = JSON.parse(fs6.readFileSync(jsonPath, "utf-8"));
-                if (data.type === type) return path12.join(catDir, entry.name);
+                if (data.type === type) return path13.join(catDir, entry.name);
               } catch {
               }
             }
@@ -12474,7 +12794,7 @@ var ProviderLoader = class _ProviderLoader {
    * (template substitution is NOT applied here — scripts.js handles that)
    */
   buildScriptWrappersFromDir(dir) {
-    const scriptsJs = path12.join(dir, "scripts.js");
+    const scriptsJs = path13.join(dir, "scripts.js");
     if (fs6.existsSync(scriptsJs)) {
       try {
         delete __require.cache[__require.resolve(scriptsJs)];
@@ -12488,7 +12808,7 @@ var ProviderLoader = class _ProviderLoader {
       for (const file of fs6.readdirSync(dir)) {
         if (!file.endsWith(".js")) continue;
         const scriptName = toCamel(file.replace(".js", ""));
-        const filePath = path12.join(dir, file);
+        const filePath = path13.join(dir, file);
         result[scriptName] = (...args) => {
           try {
             let content = fs6.readFileSync(filePath, "utf-8");
@@ -12548,35 +12868,39 @@ var ProviderLoader = class _ProviderLoader {
       }
       const hasJson = entries.some((e) => e.name === "provider.json");
       if (hasJson) {
-        const jsonPath = path12.join(d, "provider.json");
+        const jsonPath = path13.join(d, "provider.json");
         try {
           const raw = fs6.readFileSync(jsonPath, "utf-8");
           const mod = JSON.parse(raw);
           if (!mod.type || !mod.name || !mod.category) {
             this.log(`\u26A0 Invalid provider at ${jsonPath}: missing type/name/category`);
           } else {
-            if (mod.extensionIdPattern && typeof mod.extensionIdPattern === "string") {
+            if (typeof mod.extensionIdPattern === "string") {
               const flags = mod.extensionIdPattern_flags || "";
               mod.extensionIdPattern = new RegExp(mod.extensionIdPattern, flags);
-              delete mod.extensionIdPattern_flags;
             }
-            const hasCompatibility = Array.isArray(mod.compatibility);
-            const scriptsPath = path12.join(d, "scripts.js");
+            const { extensionIdPattern_flags, extensionIdPattern, ...providerFields } = mod;
+            const normalizedProvider = {
+              ...providerFields,
+              ...extensionIdPattern instanceof RegExp ? { extensionIdPattern } : {}
+            };
+            const hasCompatibility = Array.isArray(normalizedProvider.compatibility);
+            const scriptsPath = path13.join(d, "scripts.js");
             if (!hasCompatibility && fs6.existsSync(scriptsPath)) {
               try {
                 delete __require.cache[__require.resolve(scriptsPath)];
                 const scripts = __require(scriptsPath);
-                mod.scripts = scripts;
+                normalizedProvider.scripts = scripts;
               } catch (e) {
                 this.log(`\u26A0 Failed to load scripts: ${scriptsPath}: ${e.message}`);
               }
             }
-            const existed = this.providers.has(mod.type);
-            this.providers.set(mod.type, mod);
+            const existed = this.providers.has(normalizedProvider.type);
+            this.providers.set(normalizedProvider.type, normalizedProvider);
             count++;
             const source = d.startsWith(this.userDir) && !d.includes(".upstream") ? "user" : "upstream";
             const overrideWarning = existed && source === "user" ? " \u26A0 OVERRIDES upstream" : "";
-            this.log(`  ${existed ? "\u{1F504}" : "\u2705"} ${mod.type} (${mod.category}) \u2014 ${mod.name} [${source}]${overrideWarning}`);
+            this.log(`  ${existed ? "\u{1F504}" : "\u2705"} ${normalizedProvider.type} (${normalizedProvider.category}) \u2014 ${normalizedProvider.name} [${source}]${overrideWarning}`);
           }
         } catch (e) {
           this.log(`\u26A0 Failed to load ${jsonPath}: ${e.message}`);
@@ -12587,7 +12911,7 @@ var ProviderLoader = class _ProviderLoader {
           if (!entry.isDirectory()) continue;
           if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
           if (excludeDirs && d === dir && excludeDirs.includes(entry.name)) continue;
-          scan(path12.join(d, entry.name));
+          scan(path13.join(d, entry.name));
         }
       }
     };
@@ -12657,9 +12981,9 @@ function getWinProcessNames() {
 function getProviderMeta(ideId) {
   return getProviderLoader().getMeta(ideId);
 }
-function getPreferredLaunchMethod(ideId, platform9) {
+function getPreferredLaunchMethod(ideId, platform10) {
   const prefer = getProviderMeta(ideId)?.launch?.prefer;
-  const value = prefer?.[platform9];
+  const value = prefer?.[platform10];
   return value === "cli" || value === "app" || value === "auto" ? value : "auto";
 }
 function getCdpStartupTimeoutMs(ideId) {
@@ -12716,7 +13040,7 @@ async function isCdpActive(port) {
   });
 }
 async function killIdeProcess(ideId) {
-  const plat = os12.platform();
+  const plat = os14.platform();
   const appName = getMacAppIdentifiers()[ideId];
   const winProcesses = getWinProcessNames()[ideId];
   try {
@@ -12775,7 +13099,7 @@ async function killIdeProcess(ideId) {
   }
 }
 function isIdeRunning(ideId) {
-  const plat = os12.platform();
+  const plat = os14.platform();
   try {
     if (plat === "darwin") {
       const appName = getMacAppIdentifiers()[ideId];
@@ -12826,7 +13150,7 @@ function isIdeRunning(ideId) {
   }
 }
 function detectCurrentWorkspace(ideId) {
-  const plat = os12.platform();
+  const plat = os14.platform();
   if (plat === "darwin") {
     try {
       const appName = getMacAppIdentifiers()[ideId];
@@ -12845,8 +13169,8 @@ function detectCurrentWorkspace(ideId) {
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
-        const storagePath = path13.join(
-          process.env.APPDATA || path13.join(os12.homedir(), "AppData", "Roaming"),
+        const storagePath = path14.join(
+          process.env.APPDATA || path14.join(os14.homedir(), "AppData", "Roaming"),
           appName,
           "storage.json"
         );
@@ -12868,7 +13192,7 @@ function detectCurrentWorkspace(ideId) {
   return void 0;
 }
 async function launchWithCdp(options = {}) {
-  const platform9 = os12.platform();
+  const platform10 = os14.platform();
   let targetIde;
   const ides = await detectIDEs(getProviderLoader());
   if (options.ideId) {
@@ -12937,9 +13261,9 @@ async function launchWithCdp(options = {}) {
   }
   const port = await findFreePort(portPair);
   try {
-    if (platform9 === "darwin") {
+    if (platform10 === "darwin") {
       await launchMacOS(targetIde, port, workspace, options.newWindow);
-    } else if (platform9 === "win32") {
+    } else if (platform10 === "win32") {
       await launchWindows(targetIde, port, workspace, options.newWindow);
     } else {
       await launchLinux(targetIde, port, workspace, options.newWindow);
@@ -13024,9 +13348,9 @@ init_logger();
 
 // src/logging/command-log.ts
 import * as fs7 from "fs";
-import * as path14 from "path";
-import * as os13 from "os";
-var LOG_DIR2 = process.platform === "win32" ? path14.join(process.env.LOCALAPPDATA || process.env.APPDATA || path14.join(os13.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path14.join(os13.homedir(), "Library", "Logs", "adhdev") : path14.join(os13.homedir(), ".local", "share", "adhdev", "logs");
+import * as path15 from "path";
+import * as os15 from "os";
+var LOG_DIR2 = process.platform === "win32" ? path15.join(process.env.LOCALAPPDATA || process.env.APPDATA || path15.join(os15.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path15.join(os15.homedir(), "Library", "Logs", "adhdev") : path15.join(os15.homedir(), ".local", "share", "adhdev", "logs");
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var MAX_DAYS = 7;
 try {
@@ -13064,13 +13388,13 @@ function getDateStr2() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
 var currentDate2 = getDateStr2();
-var currentFile = path14.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+var currentFile = path15.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
 var writeCount2 = 0;
 function checkRotation() {
   const today = getDateStr2();
   if (today !== currentDate2) {
     currentDate2 = today;
-    currentFile = path14.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+    currentFile = path15.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
     cleanOldFiles();
   }
 }
@@ -13084,7 +13408,7 @@ function cleanOldFiles() {
       const dateMatch = file.match(/commands-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs7.unlinkSync(path14.join(LOG_DIR2, file));
+          fs7.unlinkSync(path15.join(LOG_DIR2, file));
         } catch {
         }
       }
@@ -13162,7 +13486,7 @@ init_logger();
 
 // src/status/snapshot.ts
 init_config();
-import * as os14 from "os";
+import * as os16 from "os";
 init_terminal_screen();
 init_logger();
 var READ_DEBUG_ENABLED = process.argv.includes("--dev") || process.env.ADHDEV_READ_DEBUG === "1";
@@ -13281,16 +13605,16 @@ function buildStatusSnapshot(options) {
     version: options.version,
     daemonMode: options.daemonMode,
     machine: {
-      hostname: os14.hostname(),
-      platform: os14.platform(),
-      arch: os14.arch(),
-      cpus: os14.cpus().length,
+      hostname: os16.hostname(),
+      platform: os16.platform(),
+      arch: os16.arch(),
+      cpus: os16.cpus().length,
       totalMem: memSnap.totalMem,
       freeMem: memSnap.freeMem,
       availableMem: memSnap.availableMem,
-      loadavg: os14.loadavg(),
-      uptime: os14.uptime(),
-      release: os14.release()
+      loadavg: os16.loadavg(),
+      uptime: os16.uptime(),
+      release: os16.release()
     },
     machineNickname: options.machineNickname ?? cfg.machineNickname ?? null,
     timestamp: options.timestamp ?? Date.now(),
@@ -13311,14 +13635,14 @@ function buildStatusSnapshot(options) {
 import { execFileSync } from "child_process";
 import { spawn as spawn3 } from "child_process";
 import * as fs8 from "fs";
-import * as os15 from "os";
-import * as path15 from "path";
+import * as os17 from "os";
+import * as path16 from "path";
 var UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
 function getUpgradeLogPath() {
-  const home = os15.homedir();
-  const dir = path15.join(home, ".adhdev");
+  const home = os17.homedir();
+  const dir = path16.join(home, ".adhdev");
   fs8.mkdirSync(dir, { recursive: true });
-  return path15.join(dir, "daemon-upgrade.log");
+  return path16.join(dir, "daemon-upgrade.log");
 }
 function appendUpgradeLog(message) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
@@ -13358,7 +13682,7 @@ async function waitForPidExit(pid, timeoutMs) {
   }
 }
 function stopSessionHostProcesses(appName) {
-  const pidFile = path15.join(os15.homedir(), ".adhdev", `${appName}-session-host.pid`);
+  const pidFile = path16.join(os17.homedir(), ".adhdev", `${appName}-session-host.pid`);
   try {
     if (fs8.existsSync(pidFile)) {
       const pid = Number.parseInt(fs8.readFileSync(pidFile, "utf8").trim(), 10);
@@ -13387,7 +13711,7 @@ function stopSessionHostProcesses(appName) {
   }
 }
 function removeDaemonPidFile() {
-  const pidFile = path15.join(os15.homedir(), ".adhdev", "daemon.pid");
+  const pidFile = path16.join(os17.homedir(), ".adhdev", "daemon.pid");
   try {
     fs8.unlinkSync(pidFile);
   } catch {
@@ -13398,7 +13722,7 @@ function cleanupStaleGlobalInstallDirs(pkgName) {
   const npmRoot = execFileSync(getNpmExecutable(), ["root", "-g"], { encoding: "utf8", ...npmExecOpts }).trim();
   if (!npmRoot) return;
   const npmPrefix = execFileSync(getNpmExecutable(), ["prefix", "-g"], { encoding: "utf8", ...npmExecOpts }).trim();
-  const binDir = process.platform === "win32" ? npmPrefix : path15.join(npmPrefix, "bin");
+  const binDir = process.platform === "win32" ? npmPrefix : path16.join(npmPrefix, "bin");
   const packageBaseName = pkgName.startsWith("@") ? pkgName.split("/")[1] : pkgName;
   const binNames = /* @__PURE__ */ new Set([packageBaseName]);
   if (pkgName === "@adhdev/daemon-standalone") {
@@ -13406,25 +13730,25 @@ function cleanupStaleGlobalInstallDirs(pkgName) {
   }
   if (pkgName.startsWith("@")) {
     const [scope, name] = pkgName.split("/");
-    const scopeDir = path15.join(npmRoot, scope);
+    const scopeDir = path16.join(npmRoot, scope);
     if (!fs8.existsSync(scopeDir)) return;
     for (const entry of fs8.readdirSync(scopeDir)) {
       if (!entry.startsWith(`.${name}-`)) continue;
-      fs8.rmSync(path15.join(scopeDir, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale scoped staging dir: ${path15.join(scopeDir, entry)}`);
+      fs8.rmSync(path16.join(scopeDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale scoped staging dir: ${path16.join(scopeDir, entry)}`);
     }
   } else {
     for (const entry of fs8.readdirSync(npmRoot)) {
       if (!entry.startsWith(`.${pkgName}-`)) continue;
-      fs8.rmSync(path15.join(npmRoot, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale staging dir: ${path15.join(npmRoot, entry)}`);
+      fs8.rmSync(path16.join(npmRoot, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale staging dir: ${path16.join(npmRoot, entry)}`);
     }
   }
   if (fs8.existsSync(binDir)) {
     for (const entry of fs8.readdirSync(binDir)) {
       if (![...binNames].some((name) => entry.startsWith(`.${name}-`))) continue;
-      fs8.rmSync(path15.join(binDir, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale bin staging entry: ${path15.join(binDir, entry)}`);
+      fs8.rmSync(path16.join(binDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale bin staging entry: ${path16.join(binDir, entry)}`);
     }
   }
 }
@@ -13510,6 +13834,18 @@ var CHAT_COMMANDS = [
   "change_model"
 ];
 var READ_DEBUG_ENABLED2 = process.argv.includes("--dev") || process.env.ADHDEV_READ_DEBUG === "1";
+function normalizeCommandSource(source) {
+  switch (source) {
+    case "ws":
+    case "p2p":
+    case "ext":
+    case "api":
+    case "standalone":
+      return source;
+    default:
+      return "unknown";
+  }
+}
 function toHostedCliRuntimeDescriptor(record) {
   if (!record || typeof record !== "object") return null;
   const runtimeId = typeof record.sessionId === "string" ? record.sessionId : "";
@@ -13547,20 +13883,21 @@ var DaemonCommandRouter = class {
    */
   async execute(cmd, args, source = "unknown") {
     const cmdStart = Date.now();
+    const logSource = normalizeCommandSource(source);
     try {
       const daemonResult = await this.executeDaemonCommand(cmd, args);
       if (daemonResult) {
-        logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd, source, args, success: daemonResult.success, durationMs: Date.now() - cmdStart });
+        logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd, source: logSource, args, success: daemonResult.success, durationMs: Date.now() - cmdStart });
         return daemonResult;
       }
       const handlerResult = await this.deps.commandHandler.handle(cmd, args);
-      logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd, source, args, success: handlerResult.success, durationMs: Date.now() - cmdStart });
+      logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd, source: logSource, args, success: handlerResult.success, durationMs: Date.now() - cmdStart });
       if (CHAT_COMMANDS.includes(cmd) && this.deps.onPostChatCommand) {
         this.deps.onPostChatCommand();
       }
       return handlerResult;
     } catch (e) {
-      logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd, source, args, success: false, error: e.message, durationMs: Date.now() - cmdStart });
+      logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd, source: logSource, args, success: false, error: e.message, durationMs: Date.now() - cmdStart });
       throw e;
     }
   }
@@ -13830,7 +14167,7 @@ var DaemonCommandRouter = class {
           } catch {
           }
         }
-        return { success: result.success, ...result };
+        return { ...result };
       }
       // ─── Detect IDEs ───
       case "detect_ides": {
@@ -13960,16 +14297,14 @@ var DaemonCommandRouter = class {
       }
     }
     for (const instanceKey of keysToRemove) {
-      const ideInstance = this.deps.instanceManager.getInstance(instanceKey);
-      if (ideInstance) {
+      if (this.deps.instanceManager.getInstance(instanceKey)) {
         this.deps.instanceManager.removeInstance(instanceKey);
         LOG.info("StopIDE", `Instance removed: ${instanceKey}`);
       }
     }
     if (keysToRemove.length === 0) {
       const instanceKey = `ide:${ideType}`;
-      const ideInstance = this.deps.instanceManager.getInstance(instanceKey);
-      if (ideInstance) {
+      if (this.deps.instanceManager.getInstance(instanceKey)) {
         this.deps.instanceManager.removeInstance(instanceKey);
         LOG.info("StopIDE", `Instance removed: ${instanceKey}`);
       }
@@ -14184,11 +14519,11 @@ var DaemonStatusReporter = class {
   // ─── P2P ─────────────────────────────────────────
   sendP2PPayload(payload) {
     const { timestamp: _ts, system: _sys, ...hashTarget } = payload;
-    if (hashTarget.machine) {
+    const hashPayload = hashTarget.machine ? (() => {
       const { freeMem: _f, availableMem: _a, loadavg: _l, uptime: _u, ...stableMachine } = hashTarget.machine;
-      hashTarget.machine = stableMachine;
-    }
-    const h = this.simpleHash(JSON.stringify(hashTarget));
+      return { ...hashTarget, machine: stableMachine };
+    })() : hashTarget;
+    const h = this.simpleHash(JSON.stringify(hashPayload));
     if (h !== this.lastP2PStatusHash) {
       this.lastP2PStatusHash = h;
       this.deps.p2p?.sendStatus(payload);
@@ -14236,6 +14571,9 @@ var ProviderStreamAdapter = class {
   hasScript(name) {
     return typeof this.provider.scripts?.[name] === "function";
   }
+  getStateTitle(state) {
+    return typeof state.title === "string" ? state.title : "";
+  }
   parseMaybeJson(raw) {
     if (typeof raw !== "string") return raw;
     try {
@@ -14439,7 +14777,7 @@ var ProviderStreamAdapter = class {
     for (let attempt = 0; attempt < 6; attempt += 1) {
       await new Promise((resolve12) => setTimeout(resolve12, 250));
       const state = await this.readChat(evaluate);
-      const title = typeof state.title === "string" ? state.title : "";
+      const title = this.getStateTitle(state);
       if (this.titlesMatch(title, sessionId)) return true;
     }
     return false;
@@ -14536,6 +14874,11 @@ var DaemonAgentStreamManager = class {
     const child = (this.sessionRegistry?.listChildren(parentSessionId) || []).find((entry) => entry.transport === "cdp-webview" && entry.providerType === agentType);
     return child?.sessionId || null;
   }
+  getStateError(state) {
+    if (typeof state.error === "string" && state.error.trim()) return state.error.trim();
+    if (typeof state._error === "string" && state._error.trim()) return state._error.trim();
+    return "unknown";
+  }
   async connectManagedSession(cdp, parentSessionId, runtimeSessionId) {
     const target = this.getSessionTarget(runtimeSessionId);
     if (!target || target.transport !== "cdp-webview") return null;
@@ -14598,8 +14941,8 @@ var DaemonAgentStreamManager = class {
     try {
       const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
       const state = await agent.adapter.readChat(evaluate);
-      LOG.debug("AgentStream", `[AgentStream] readChat(${type}) result: status=${state.status} msgs=${state.messages?.length || 0} model=${state.model || ""}${state.status === "error" ? " error=" + JSON.stringify(state.error || state._error || "unknown") : ""}`);
-      const stateError = String(state.error || state._error || "");
+      const stateError = this.getStateError(state);
+      LOG.debug("AgentStream", `[AgentStream] readChat(${type}) result: status=${state.status} msgs=${state.messages?.length || 0} model=${state.model || ""}${state.status === "error" ? " error=" + JSON.stringify(stateError) : ""}`);
       if (state.status === "error" && this.isRecoverableSessionError(stateError)) {
         throw new Error(stateError);
       }
@@ -14888,7 +15231,43 @@ var AgentStreamPoller = class {
       }
       try {
         await agentStreamManager.syncActiveSession(cdp, parentSessionId);
-        const stream = await agentStreamManager.collectActiveSession(cdp, parentSessionId);
+        let stream = await agentStreamManager.collectActiveSession(cdp, parentSessionId);
+        if (stream?.status === "waiting_approval") {
+          const autoApprove = providerLoader.getSettings(stream.agentType).autoApprove !== false;
+          if (autoApprove && resolvedActiveSessionId) {
+            const provider = providerLoader.getMeta(stream.agentType);
+            const { label: buttonLabel } = pickApprovalButton(stream.activeModal?.buttons, provider);
+            const approved = await agentStreamManager.resolveSessionAction(cdp, resolvedActiveSessionId, "approve", buttonLabel);
+            if (approved) {
+              const effectId = [
+                "auto_approval",
+                resolvedActiveSessionId,
+                String(stream.messages?.length || 0),
+                buttonLabel,
+                String(stream.activeModal?.message || "").trim()
+              ].join(":");
+              stream = {
+                ...stream,
+                status: "streaming",
+                activeModal: void 0,
+                effects: [
+                  ...stream.effects || [],
+                  {
+                    type: "message",
+                    id: effectId,
+                    persist: true,
+                    message: {
+                      role: "system",
+                      senderName: "System",
+                      kind: "system",
+                      content: formatAutoApprovalMessage(stream.activeModal?.message, buttonLabel)
+                    }
+                  }
+                ]
+              };
+            }
+          }
+        }
         this.deps.onStreamsUpdated?.(ideType, stream ? [stream] : []);
       } catch {
       }
@@ -15132,11 +15511,11 @@ var ProviderInstanceManager = class {
 
 // src/providers/version-archive.ts
 import * as fs10 from "fs";
-import * as path16 from "path";
-import * as os16 from "os";
+import * as path17 from "path";
+import * as os18 from "os";
 import { execSync as execSync5 } from "child_process";
-import { platform as platform7 } from "os";
-var ARCHIVE_PATH = path16.join(os16.homedir(), ".adhdev", "version-history.json");
+import { platform as platform8 } from "os";
+var ARCHIVE_PATH = path17.join(os18.homedir(), ".adhdev", "version-history.json");
 var MAX_ENTRIES_PER_PROVIDER = 20;
 var VersionArchive = class {
   history = {};
@@ -15161,7 +15540,7 @@ var VersionArchive = class {
     entries.push({
       version,
       detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      os: platform7()
+      os: platform8()
     });
     if (entries.length > MAX_ENTRIES_PER_PROVIDER) {
       this.history[type] = entries.slice(-MAX_ENTRIES_PER_PROVIDER);
@@ -15183,7 +15562,7 @@ var VersionArchive = class {
   }
   save() {
     try {
-      fs10.mkdirSync(path16.dirname(ARCHIVE_PATH), { recursive: true });
+      fs10.mkdirSync(path17.dirname(ARCHIVE_PATH), { recursive: true });
       fs10.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
     } catch {
     }
@@ -15201,7 +15580,7 @@ function runCommand(cmd, timeout = 1e4) {
   }
 }
 function findBinary2(name) {
-  const cmd = platform7() === "win32" ? `where ${name}` : `which ${name}`;
+  const cmd = platform8() === "win32" ? `where ${name}` : `which ${name}`;
   const result = runCommand(cmd, 5e3);
   return result ? result.split("\n")[0] : null;
 }
@@ -15209,6 +15588,22 @@ function parseVersion2(raw) {
   const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
   return match ? match[1] : raw.split("\n")[0].substring(0, 100);
 }
+function getPlatformVersionCommand(versionCommand, currentOs) {
+  if (!versionCommand) return void 0;
+  if (typeof versionCommand === "string") {
+    const trimmed = versionCommand.trim();
+    return trimmed || void 0;
+  }
+  const platformValue = versionCommand[currentOs];
+  if (typeof platformValue === "string" && platformValue.trim()) {
+    return platformValue.trim();
+  }
+  const defaultValue = versionCommand.default;
+  if (typeof defaultValue === "string" && defaultValue.trim()) {
+    return defaultValue.trim();
+  }
+  return void 0;
+}
 function getVersion(binary, versionCommand) {
   if (versionCommand) {
     const raw = runCommand(versionCommand);
@@ -15223,8 +15618,8 @@ function getVersion(binary, versionCommand) {
 function checkPathExists2(paths) {
   for (const p of paths) {
     if (p.includes("*")) {
-      const home = os16.homedir();
-      const resolved = p.replace(/\*/g, home.split(path16.sep).pop() || "");
+      const home = os18.homedir();
+      const resolved = p.replace(/\*/g, home.split(path17.sep).pop() || "");
       if (fs10.existsSync(resolved)) return resolved;
     } else {
       if (fs10.existsSync(p)) return p;
@@ -15233,15 +15628,15 @@ function checkPathExists2(paths) {
   return null;
 }
 function getMacAppVersion(appPath) {
-  if (platform7() !== "darwin" || !appPath.endsWith(".app")) return null;
-  const plistPath = path16.join(appPath, "Contents", "Info.plist");
+  if (platform8() !== "darwin" || !appPath.endsWith(".app")) return null;
+  const plistPath = path17.join(appPath, "Contents", "Info.plist");
   if (!fs10.existsSync(plistPath)) return null;
   const raw = runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
 }
 async function detectAllVersions(loader, archive) {
   const results = [];
-  const currentOs = platform7();
+  const currentOs = platform8();
   for (const provider of loader.getAll()) {
     const info = {
       type: provider.type,
@@ -15253,15 +15648,14 @@ async function detectAllVersions(loader, archive) {
       binary: null,
       detectedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    const verCmdConfig = provider.versionCommand;
-    const versionCommand = typeof verCmdConfig === "object" && verCmdConfig !== null ? verCmdConfig[currentOs] : verCmdConfig;
+    const versionCommand = getPlatformVersionCommand(provider.versionCommand, currentOs);
     if (provider.category === "ide") {
       const osPaths = provider.paths?.[currentOs] || [];
       const appPath = checkPathExists2(osPaths);
       const cliBin = provider.cli ? findBinary2(provider.cli) : null;
       let resolvedBin = cliBin;
       if (!resolvedBin && appPath && currentOs === "darwin") {
-        const bundled = path16.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
+        const bundled = path17.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
         if (provider.cli && fs10.existsSync(bundled)) resolvedBin = bundled;
       }
       info.installed = !!(appPath || resolvedBin);
@@ -15302,7 +15696,7 @@ async function detectAllVersions(loader, archive) {
 // src/daemon/dev-server.ts
 import * as http2 from "http";
 import * as fs14 from "fs";
-import * as path20 from "path";
+import * as path21 from "path";
 
 // src/daemon/scaffold-template.ts
 function generateFiles(type, name, category, opts = {}) {
@@ -15639,7 +16033,7 @@ init_logger();
 // src/daemon/dev-cdp-handlers.ts
 init_logger();
 import * as fs11 from "fs";
-import * as path17 from "path";
+import * as path18 from "path";
 async function handleCdpEvaluate(ctx, req, res) {
   const body = await ctx.readBody(req);
   const { expression, timeout, ideType } = body;
@@ -15817,17 +16211,17 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   let scriptsPath = "";
-  const directScripts = path17.join(dir, "scripts.js");
+  const directScripts = path18.join(dir, "scripts.js");
   if (fs11.existsSync(directScripts)) {
     scriptsPath = directScripts;
   } else {
-    const scriptsDir = path17.join(dir, "scripts");
+    const scriptsDir = path18.join(dir, "scripts");
     if (fs11.existsSync(scriptsDir)) {
       const versions = fs11.readdirSync(scriptsDir).filter((d) => {
-        return fs11.statSync(path17.join(scriptsDir, d)).isDirectory();
+        return fs11.statSync(path18.join(scriptsDir, d)).isDirectory();
       }).sort().reverse();
       for (const ver of versions) {
-        const p = path17.join(scriptsDir, ver, "scripts.js");
+        const p = path18.join(scriptsDir, ver, "scripts.js");
         if (fs11.existsSync(p)) {
           scriptsPath = p;
           break;
@@ -16646,7 +17040,7 @@ async function handleDomContext(ctx, type, req, res) {
 
 // src/daemon/dev-cli-debug.ts
 import * as fs12 from "fs";
-import * as path18 from "path";
+import * as path19 from "path";
 function slugifyFixtureName(value) {
   const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return normalized || `fixture-${Date.now()}`;
@@ -16656,11 +17050,11 @@ function getCliFixtureDir(ctx, type) {
   if (!providerDir) {
     throw new Error(`Provider directory not found for '${type}'`);
   }
-  return path18.join(providerDir, "fixtures");
+  return path19.join(providerDir, "fixtures");
 }
 function readCliFixture(ctx, type, name) {
   const fixtureDir = getCliFixtureDir(ctx, type);
-  const filePath = path18.join(fixtureDir, `${name}.json`);
+  const filePath = path19.join(fixtureDir, `${name}.json`);
   if (!fs12.existsSync(filePath)) {
     throw new Error(`Fixture not found: ${filePath}`);
   }
@@ -16786,6 +17180,15 @@ function validateCliFixtureResult(result, assertions) {
   }
   return failures;
 }
+function isCliTargetState(state) {
+  return state.category === "cli" || state.category === "acp";
+}
+function getCliAdapterFromInstance(instance) {
+  if (!instance) return null;
+  const candidate = instance;
+  if (typeof candidate.getAdapter === "function") return candidate.getAdapter();
+  return candidate.adapter || null;
+}
 function getCliProviderResolutionMeta(ctx, type, adapter) {
   const adapterMeta = typeof adapter?.getProviderResolutionMeta === "function" ? adapter.getProviderResolutionMeta() : adapter?.getDebugState?.()?.providerResolution || null;
   const resolvedProvider = ctx.providerLoader.resolve(type);
@@ -16803,7 +17206,7 @@ function getCliProviderResolutionMeta(ctx, type, adapter) {
 }
 function findCliTarget(ctx, type, instanceId) {
   if (!ctx.instanceManager) return null;
-  const cliStates = ctx.instanceManager.collectAllStates().filter((s) => s.category === "cli" || s.category === "acp");
+  const cliStates = ctx.instanceManager.collectAllStates().filter(isCliTargetState);
   if (instanceId) return cliStates.find((s) => s.instanceId === instanceId) || null;
   if (!type) return cliStates[cliStates.length - 1] || null;
   const matches = cliStates.filter((s) => s.type === type);
@@ -16815,7 +17218,7 @@ function getCliTargetBundle(ctx, type, instanceId) {
   if (!target) return null;
   const instance = ctx.instanceManager.getInstance(target.instanceId);
   if (!instance) return null;
-  const adapter = instance.getAdapter?.() || instance.adapter;
+  const adapter = getCliAdapterFromInstance(instance);
   if (!adapter) return null;
   return { target, instance, adapter };
 }
@@ -17290,7 +17693,7 @@ async function handleCliDebug(ctx, type, _req, res) {
     return;
   }
   try {
-    const adapter = instance.getAdapter?.() || instance.adapter;
+    const adapter = getCliAdapterFromInstance(instance);
     if (adapter && typeof adapter.getDebugState === "function") {
       const debugState = adapter.getDebugState();
       ctx.json(res, 200, {
@@ -17337,7 +17740,7 @@ async function handleCliTrace(ctx, type, req, res) {
     return;
   }
   try {
-    const adapter = instance.getAdapter?.() || instance.adapter;
+    const adapter = getCliAdapterFromInstance(instance);
     const url = new URL(req.url || "/", "http://127.0.0.1");
     const limit = parseInt(url.searchParams.get("limit") || "120", 10);
     if (adapter && typeof adapter.getTraceState === "function") {
@@ -17419,7 +17822,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       },
       notes: typeof body?.notes === "string" ? body.notes : void 0
     };
-    const filePath = path18.join(fixtureDir, `${name}.json`);
+    const filePath = path19.join(fixtureDir, `${name}.json`);
     fs12.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
     ctx.json(res, 200, {
       saved: true,
@@ -17443,7 +17846,7 @@ async function handleCliFixtureList(ctx, type, _req, res) {
       return;
     }
     const fixtures = fs12.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
-      const fullPath = path18.join(fixtureDir, file);
+      const fullPath = path19.join(fixtureDir, file);
       try {
         const raw = JSON.parse(fs12.readFileSync(fullPath, "utf-8"));
         return {
@@ -17523,7 +17926,7 @@ async function handleCliResolve(ctx, req, res) {
     return;
   }
   const instance = ctx.instanceManager.getInstance(target.instanceId);
-  const adapter = instance?.getAdapter?.() || instance?.adapter;
+  const adapter = getCliAdapterFromInstance(instance);
   if (!adapter) {
     ctx.json(res, 404, { error: `Adapter not found for instance: ${target.instanceId}` });
     return;
@@ -17560,7 +17963,7 @@ async function handleCliRaw(ctx, req, res) {
     return;
   }
   const instance = ctx.instanceManager.getInstance(target.instanceId);
-  const adapter = instance?.getAdapter?.() || instance?.adapter;
+  const adapter = getCliAdapterFromInstance(instance);
   if (!adapter) {
     ctx.json(res, 404, { error: `Adapter not found for instance: ${target.instanceId}` });
     return;
@@ -17579,11 +17982,11 @@ async function handleCliRaw(ctx, req, res) {
 
 // src/daemon/dev-auto-implement.ts
 import * as fs13 from "fs";
-import * as path19 from "path";
-import * as os17 from "os";
+import * as path20 from "path";
+import * as os19 from "os";
 function getAutoImplPid(ctx) {
-  const proc = ctx.autoImplProcess;
-  return proc && typeof proc.pid === "number" && proc.pid > 0 ? proc.pid : null;
+  const pid = ctx.autoImplProcess?.pid;
+  return typeof pid === "number" && pid > 0 ? pid : null;
 }
 function isPidAlive(pid) {
   try {
@@ -17601,6 +18004,13 @@ function clearStaleAutoImplState(ctx, reason) {
   ctx.autoImplProcess = null;
   ctx.autoImplStatus.running = false;
 }
+function tryKillAutoImplProcess(processRef, signal) {
+  if (!processRef) return;
+  try {
+    processRef.kill(signal);
+  } catch {
+  }
+}
 function getDefaultAutoImplReference(ctx, category, type) {
   if (category === "cli") {
     return type === "codex-cli" ? "claude-cli" : "codex-cli";
@@ -17619,22 +18029,22 @@ function getLatestScriptVersionDir(scriptsDir) {
   if (!fs13.existsSync(scriptsDir)) return null;
   const versions = fs13.readdirSync(scriptsDir).filter((d) => {
     try {
-      return fs13.statSync(path19.join(scriptsDir, d)).isDirectory();
+      return fs13.statSync(path20.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 path19.join(scriptsDir, versions[0]);
+  return path20.join(scriptsDir, versions[0]);
 }
 function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
-  const canonicalUserDir = path19.resolve(ctx.providerLoader.getUserProviderDir(category, type));
-  const desiredDir = requestedDir ? path19.resolve(requestedDir) : canonicalUserDir;
-  const upstreamRoot = path19.resolve(ctx.providerLoader.getUpstreamDir());
-  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path19.sep}`)) {
+  const canonicalUserDir = path20.resolve(ctx.providerLoader.getUserProviderDir(category, type));
+  const desiredDir = requestedDir ? path20.resolve(requestedDir) : canonicalUserDir;
+  const upstreamRoot = path20.resolve(ctx.providerLoader.getUpstreamDir());
+  if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path20.sep}`)) {
     return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
   }
-  if (path19.basename(desiredDir) !== type) {
+  if (path20.basename(desiredDir) !== type) {
     return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
   }
   const sourceDir = ctx.findProviderDir(type);
@@ -17642,11 +18052,11 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
     return { dir: null, reason: `Provider source directory not found for '${type}'` };
   }
   if (!fs13.existsSync(desiredDir)) {
-    fs13.mkdirSync(path19.dirname(desiredDir), { recursive: true });
+    fs13.mkdirSync(path20.dirname(desiredDir), { recursive: true });
     fs13.cpSync(sourceDir, desiredDir, { recursive: true });
     ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
   }
-  const providerJson = path19.join(desiredDir, "provider.json");
+  const providerJson = path20.join(desiredDir, "provider.json");
   if (!fs13.existsSync(providerJson)) {
     return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
   }
@@ -17669,13 +18079,13 @@ function loadAutoImplReferenceScripts(ctx, referenceType) {
   const refDir = ctx.findProviderDir(referenceType);
   if (!refDir || !fs13.existsSync(refDir)) return {};
   const referenceScripts = {};
-  const scriptsDir = path19.join(refDir, "scripts");
+  const scriptsDir = path20.join(refDir, "scripts");
   const latestDir = getLatestScriptVersionDir(scriptsDir);
   if (!latestDir) return referenceScripts;
   for (const file of fs13.readdirSync(latestDir)) {
     if (!file.endsWith(".js")) continue;
     try {
-      referenceScripts[file] = fs13.readFileSync(path19.join(latestDir, file), "utf-8");
+      referenceScripts[file] = fs13.readFileSync(path20.join(latestDir, file), "utf-8");
     } catch {
     }
   }
@@ -17783,9 +18193,9 @@ async function handleAutoImplement(ctx, type, req, res) {
     });
     const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
     const prompt = buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
-    const tmpDir = path19.join(os17.tmpdir(), "adhdev-autoimpl");
+    const tmpDir = path20.join(os19.tmpdir(), "adhdev-autoimpl");
     if (!fs13.existsSync(tmpDir)) fs13.mkdirSync(tmpDir, { recursive: true });
-    const promptFile = path19.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
+    const promptFile = path20.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
     fs13.writeFileSync(promptFile, prompt, "utf-8");
     ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
     const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
@@ -17937,7 +18347,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     const interactiveFlags = ["--yolo", "--interactive", "-i"];
     const baseArgs = [...spawn4.args || []].filter((a) => !interactiveFlags.includes(a));
     let shellCmd;
-    const isWin = os17.platform() === "win32";
+    const isWin = os19.platform() === "win32";
     const escapeArg = (a) => isWin ? `"${a.replace(/"/g, '""')}"` : `'${a.replace(/'/g, "'\\''")}'`;
     if (command === "claude") {
       const args = [...baseArgs, "--dangerously-skip-permissions"];
@@ -17981,7 +18391,7 @@ async function handleAutoImplement(ctx, type, req, res) {
     try {
       const pty = __require("node-pty");
       ctx.log(`Auto-implement spawn (PTY): ${shellCmd}`);
-      const isWin2 = os17.platform() === "win32";
+      const isWin2 = os19.platform() === "win32";
       child = pty.spawn(isWin2 ? "cmd.exe" : process.env.SHELL || "/bin/zsh", [isWin2 ? "/c" : "-c", shellCmd], {
         name: "xterm-256color",
         cols: 120,
@@ -18020,10 +18430,12 @@ async function handleAutoImplement(ctx, type, req, res) {
     let autoStopTimer = null;
     let autoStopIssued = false;
     try {
-      const { normalizeCliProviderForRuntime: normalizeCliProviderForRuntime2 } = await Promise.resolve().then(() => (init_provider_cli_adapter(), provider_cli_adapter_exports));
-      const normalized = normalizeCliProviderForRuntime2(agentProvider);
-      approvalPatterns = normalized.patterns.approval;
-      approvalKeys = agentProvider?.approvalKeys || { 0: "y\r", 1: "a\r" };
+      if (agentProvider?.category === "cli") {
+        const { normalizeCliProviderForRuntime: normalizeCliProviderForRuntime2 } = await Promise.resolve().then(() => (init_provider_cli_adapter(), provider_cli_adapter_exports));
+        const normalized = normalizeCliProviderForRuntime2(agentProvider);
+        approvalPatterns = normalized.patterns.approval;
+        approvalKeys = agentProvider.approvalKeys || { 0: "y\r", 1: "a\r" };
+      }
     } catch (err) {
       ctx.log(`Failed to load approval patterns: ${err.message}`);
     }
@@ -18038,10 +18450,7 @@ async function handleAutoImplement(ctx, type, req, res) {
 [\u{1F916} ADHDev Pipeline] Completion token detected. Proceeding...
 `, stream: "stdout" } });
         approvalBuffer = "";
-        try {
-          ctx.autoImplProcess.kill("SIGINT");
-        } catch {
-        }
+        tryKillAutoImplProcess(ctx.autoImplProcess, "SIGINT");
         return;
       }
       if (Date.now() - lastApprovalTime < 2e3) return;
@@ -18078,10 +18487,7 @@ async function handleAutoImplement(ctx, type, req, res) {
             stream: "stdout"
           }
         });
-        try {
-          ctx.autoImplProcess.kill("SIGINT");
-        } catch {
-        }
+        tryKillAutoImplProcess(ctx.autoImplProcess, "SIGINT");
       }, 3e4);
     };
     const finalizeCliAutoImpl = async (code) => {
@@ -18212,7 +18618,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 = path19.join(providerDir, "scripts");
+  const scriptsDir = path20.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -18223,7 +18629,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     for (const file of fs13.readdirSync(latestScriptsDir)) {
       if (file.endsWith(".js") && targetFileNames.has(file)) {
         try {
-          const content = fs13.readFileSync(path19.join(latestScriptsDir, file), "utf-8");
+          const content = fs13.readFileSync(path20.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -18240,7 +18646,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs13.readFileSync(path19.join(latestScriptsDir, file), "utf-8");
+          const content = fs13.readFileSync(path20.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -18281,10 +18687,10 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
       lines.push("");
     }
   }
-  const docsDir = path19.join(providerDir, "../../docs");
+  const docsDir = path20.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path19.join(docsDir, name);
+      const p = path20.join(docsDir, name);
       if (fs13.existsSync(p)) return fs13.readFileSync(p, "utf-8");
     } catch {
     }
@@ -18519,7 +18925,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 = path19.join(providerDir, "scripts");
+  const scriptsDir = path20.join(providerDir, "scripts");
   const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
   if (latestScriptsDir) {
     lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -18531,7 +18937,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       if (!file.endsWith(".js")) continue;
       if (!targetFileNames.has(file)) continue;
       try {
-        const content = fs13.readFileSync(path19.join(latestScriptsDir, file), "utf-8");
+        const content = fs13.readFileSync(path20.join(latestScriptsDir, file), "utf-8");
         lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -18547,7 +18953,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs13.readFileSync(path19.join(latestScriptsDir, file), "utf-8");
+          const content = fs13.readFileSync(path20.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -18580,10 +18986,10 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       lines.push("");
     }
   }
-  const docsDir = path19.join(providerDir, "../../docs");
+  const docsDir = path20.join(providerDir, "../../docs");
   const loadGuide = (name) => {
     try {
-      const p = path19.join(docsDir, name);
+      const p = path20.join(docsDir, name);
       if (fs13.existsSync(p)) return fs13.readFileSync(p, "utf-8");
     } catch {
     }
@@ -18898,6 +19304,38 @@ data: ${JSON.stringify(msg.data)}
 
 // src/daemon/dev-server.ts
 var DEV_SERVER_PORT = 19280;
+function getScriptNames(scripts) {
+  if (!scripts) return [];
+  return Object.entries(scripts).filter(([, value]) => typeof value === "function").map(([name]) => name);
+}
+function toProviderListEntry(provider) {
+  const base = {
+    type: provider.type,
+    name: provider.name,
+    category: provider.category,
+    icon: provider.icon || null,
+    displayName: provider.displayName || provider.name
+  };
+  if (provider.category === "ide" || provider.category === "extension") {
+    base.scripts = getScriptNames(provider.scripts);
+    base.inputMethod = provider.inputMethod || null;
+    base.inputSelector = provider.inputSelector || null;
+    base.extensionId = provider.extensionId || null;
+    base.cdpPorts = provider.cdpPorts || [];
+  }
+  if (provider.category === "acp") {
+    base.spawn = provider.spawn || null;
+    base.auth = provider.auth || null;
+    base.install = provider.install || null;
+    base.hasSettings = !!provider.settings;
+    base.settingsCount = provider.settings ? Object.keys(provider.settings).length : 0;
+  }
+  if (provider.category === "cli") {
+    base.spawn = provider.spawn || null;
+    base.install = provider.install || null;
+  }
+  return base;
+}
 var DevServer = class _DevServer {
   server = null;
   providerLoader;
@@ -18994,8 +19432,8 @@ var DevServer = class _DevServer {
   }
   getEndpointList() {
     return this.routes.map((r) => {
-      const path21 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-      return `${r.method.padEnd(5)} ${path21}`;
+      const path22 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+      return `${r.method.padEnd(5)} ${path22}`;
     });
   }
   async start(port = DEV_SERVER_PORT) {
@@ -19047,34 +19485,7 @@ var DevServer = class _DevServer {
   }
   // ─── Handlers ───
   async handleListProviders(_req, res) {
-    const providers = this.providerLoader.getAll().map((p) => {
-      const base = {
-        type: p.type,
-        name: p.name,
-        category: p.category,
-        icon: p.icon || null,
-        displayName: p.displayName || p.name
-      };
-      if (p.category === "ide" || p.category === "extension") {
-        base.scripts = p.scripts ? Object.keys(p.scripts).filter((k) => typeof p.scripts[k] === "function") : [];
-        base.inputMethod = p.inputMethod || null;
-        base.inputSelector = p.inputSelector || null;
-        base.extensionId = p.extensionId || null;
-        base.cdpPorts = p.cdpPorts || [];
-      }
-      if (p.category === "acp") {
-        base.spawn = p.spawn || null;
-        base.auth = p.auth || null;
-        base.install = p.install || null;
-        base.hasSettings = !!p.settings;
-        base.settingsCount = p.settings ? Object.keys(p.settings).length : 0;
-      }
-      if (p.category === "cli") {
-        base.spawn = p.spawn || null;
-        base.install = p.install || null;
-      }
-      return base;
-    });
+    const providers = this.providerLoader.getAll().map(toProviderListEntry);
     this.json(res, 200, { providers, count: providers.length });
   }
   async handleProviderConfig(type, _req, res) {
@@ -19266,7 +19677,7 @@ var DevServer = class _DevServer {
       }));
       for (const cdp of this.cdpManagers.values()) {
         if (!cdp.isConnected) {
-          cdp._targetId = null;
+          cdp.clearTargetId();
         }
       }
       this.json(res, 200, { reloaded: true, providers });
@@ -19277,12 +19688,12 @@ var DevServer = class _DevServer {
   // ─── DevConsole SPA ───
   getConsoleDistDir() {
     const candidates = [
-      path20.resolve(__dirname, "../../web-devconsole/dist"),
-      path20.resolve(__dirname, "../../../web-devconsole/dist"),
-      path20.join(process.cwd(), "packages/web-devconsole/dist")
+      path21.resolve(__dirname, "../../web-devconsole/dist"),
+      path21.resolve(__dirname, "../../../web-devconsole/dist"),
+      path21.join(process.cwd(), "packages/web-devconsole/dist")
     ];
     for (const dir of candidates) {
-      if (fs14.existsSync(path20.join(dir, "index.html"))) return dir;
+      if (fs14.existsSync(path21.join(dir, "index.html"))) return dir;
     }
     return null;
   }
@@ -19292,7 +19703,7 @@ var DevServer = class _DevServer {
       this.json(res, 500, { error: "DevConsole not found. Run: npm run build -w packages/web-devconsole" });
       return;
     }
-    const htmlPath = path20.join(distDir, "index.html");
+    const htmlPath = path21.join(distDir, "index.html");
     try {
       const html = fs14.readFileSync(htmlPath, "utf-8");
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
@@ -19317,15 +19728,15 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: "Not found" });
       return;
     }
-    const safePath = path20.normalize(pathname).replace(/^\.\.\//, "");
-    const filePath = path20.join(distDir, safePath);
+    const safePath = path21.normalize(pathname).replace(/^\.\.\//, "");
+    const filePath = path21.join(distDir, safePath);
     if (!filePath.startsWith(distDir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
     try {
       const content = fs14.readFileSync(filePath);
-      const ext = path20.extname(filePath);
+      const ext = path21.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);
@@ -19438,9 +19849,9 @@ var DevServer = class _DevServer {
           const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
           if (entry.isDirectory()) {
             files.push({ path: rel, size: 0, type: "dir" });
-            scan(path20.join(d, entry.name), rel);
+            scan(path21.join(d, entry.name), rel);
           } else {
-            const stat = fs14.statSync(path20.join(d, entry.name));
+            const stat = fs14.statSync(path21.join(d, entry.name));
             files.push({ path: rel, size: stat.size, type: "file" });
           }
         }
@@ -19463,7 +19874,7 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path20.resolve(dir, path20.normalize(filePath));
+    const fullPath = path21.resolve(dir, path21.normalize(filePath));
     if (!fullPath.startsWith(dir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
@@ -19488,14 +19899,14 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path20.resolve(dir, path20.normalize(filePath));
+    const fullPath = path21.resolve(dir, path21.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(path20.dirname(fullPath), { recursive: true });
+      fs14.mkdirSync(path21.dirname(fullPath), { recursive: true });
       fs14.writeFileSync(fullPath, content, "utf-8");
       this.log(`File saved: ${fullPath} (${content.length} chars)`);
       this.providerLoader.reload();
@@ -19512,7 +19923,7 @@ var DevServer = class _DevServer {
       return;
     }
     for (const name of ["scripts.js", "provider.json"]) {
-      const p = path20.join(dir, name);
+      const p = path21.join(dir, name);
       if (fs14.existsSync(p)) {
         const source = fs14.readFileSync(p, "utf-8");
         this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
@@ -19533,8 +19944,8 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const target = fs14.existsSync(path20.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
-    const targetPath = path20.join(dir, target);
+    const target = fs14.existsSync(path21.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+    const targetPath = path21.join(dir, target);
     try {
       if (fs14.existsSync(targetPath)) fs14.copyFileSync(targetPath, targetPath + ".bak");
       fs14.writeFileSync(targetPath, source, "utf-8");
@@ -19694,7 +20105,7 @@ var DevServer = class _DevServer {
     }
     let targetDir;
     targetDir = this.providerLoader.getUserProviderDir(category, type);
-    const jsonPath = path20.join(targetDir, "provider.json");
+    const jsonPath = path21.join(targetDir, "provider.json");
     if (fs14.existsSync(jsonPath)) {
       this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
       return;
@@ -19706,8 +20117,8 @@ var DevServer = class _DevServer {
       const createdFiles = ["provider.json"];
       if (result.files) {
         for (const [relPath, content] of Object.entries(result.files)) {
-          const fullPath = path20.join(targetDir, relPath);
-          fs14.mkdirSync(path20.dirname(fullPath), { recursive: true });
+          const fullPath = path21.join(targetDir, relPath);
+          fs14.mkdirSync(path21.dirname(fullPath), { recursive: true });
           fs14.writeFileSync(fullPath, content, "utf-8");
           createdFiles.push(relPath);
         }
@@ -19760,22 +20171,22 @@ var DevServer = class _DevServer {
     if (!fs14.existsSync(scriptsDir)) return null;
     const versions = fs14.readdirSync(scriptsDir).filter((d) => {
       try {
-        return fs14.statSync(path20.join(scriptsDir, d)).isDirectory();
+        return fs14.statSync(path21.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 path20.join(scriptsDir, versions[0]);
+    return path21.join(scriptsDir, versions[0]);
   }
   resolveAutoImplWritableProviderDir(category, type, requestedDir) {
-    const canonicalUserDir = path20.resolve(this.providerLoader.getUserProviderDir(category, type));
-    const desiredDir = requestedDir ? path20.resolve(requestedDir) : canonicalUserDir;
-    const upstreamRoot = path20.resolve(this.providerLoader.getUpstreamDir());
-    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path20.sep}`)) {
+    const canonicalUserDir = path21.resolve(this.providerLoader.getUserProviderDir(category, type));
+    const desiredDir = requestedDir ? path21.resolve(requestedDir) : canonicalUserDir;
+    const upstreamRoot = path21.resolve(this.providerLoader.getUpstreamDir());
+    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path21.sep}`)) {
       return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
     }
-    if (path20.basename(desiredDir) !== type) {
+    if (path21.basename(desiredDir) !== type) {
       return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
     }
     const sourceDir = this.findProviderDir(type);
@@ -19783,11 +20194,11 @@ var DevServer = class _DevServer {
       return { dir: null, reason: `Provider source directory not found for '${type}'` };
     }
     if (!fs14.existsSync(desiredDir)) {
-      fs14.mkdirSync(path20.dirname(desiredDir), { recursive: true });
+      fs14.mkdirSync(path21.dirname(desiredDir), { recursive: true });
       fs14.cpSync(sourceDir, desiredDir, { recursive: true });
       this.log(`Auto-implement writable copy created: ${desiredDir}`);
     }
-    const providerJson = path20.join(desiredDir, "provider.json");
+    const providerJson = path21.join(desiredDir, "provider.json");
     if (!fs14.existsSync(providerJson)) {
       return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
     }
@@ -19835,7 +20246,7 @@ var DevServer = class _DevServer {
       setMode: "set_mode.js"
     };
     const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-    const scriptsDir = path20.join(providerDir, "scripts");
+    const scriptsDir = path21.join(providerDir, "scripts");
     const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
     if (latestScriptsDir) {
       lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -19846,7 +20257,7 @@ var DevServer = class _DevServer {
       for (const file of fs14.readdirSync(latestScriptsDir)) {
         if (file.endsWith(".js") && targetFileNames.has(file)) {
           try {
-            const content = fs14.readFileSync(path20.join(latestScriptsDir, file), "utf-8");
+            const content = fs14.readFileSync(path21.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -19863,7 +20274,7 @@ var DevServer = class _DevServer {
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs14.readFileSync(path20.join(latestScriptsDir, file), "utf-8");
+            const content = fs14.readFileSync(path21.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -19904,10 +20315,10 @@ var DevServer = class _DevServer {
         lines.push("");
       }
     }
-    const docsDir = path20.join(providerDir, "../../docs");
+    const docsDir = path21.join(providerDir, "../../docs");
     const loadGuide = (name) => {
       try {
-        const p = path20.join(docsDir, name);
+        const p = path21.join(docsDir, name);
         if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
       } catch {
       }
@@ -20081,7 +20492,7 @@ var DevServer = class _DevServer {
       parseApproval: "parse_approval.js"
     };
     const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-    const scriptsDir = path20.join(providerDir, "scripts");
+    const scriptsDir = path21.join(providerDir, "scripts");
     const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
     if (latestScriptsDir) {
       lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -20093,7 +20504,7 @@ var DevServer = class _DevServer {
         if (!file.endsWith(".js")) continue;
         if (!targetFileNames.has(file)) continue;
         try {
-          const content = fs14.readFileSync(path20.join(latestScriptsDir, file), "utf-8");
+          const content = fs14.readFileSync(path21.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -20109,7 +20520,7 @@ var DevServer = class _DevServer {
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs14.readFileSync(path20.join(latestScriptsDir, file), "utf-8");
+            const content = fs14.readFileSync(path21.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -20142,10 +20553,10 @@ var DevServer = class _DevServer {
         lines.push("");
       }
     }
-    const docsDir = path20.join(providerDir, "../../docs");
+    const docsDir = path21.join(providerDir, "../../docs");
     const loadGuide = (name) => {
       try {
-        const p = path20.join(docsDir, name);
+        const p = path21.join(docsDir, name);
         if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
       } catch {
       }