@n1creator/openacp-cli 2026.712.4 → 2026.712.5

package/dist/cli.js

@@ -4996,12 +4996,203 @@ var init_groq = __esm({
   }
 });
 
+// src/plugins/speech/providers/local-whisper.ts
+import { execFile } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { mkdtemp, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import path9 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { promisify } from "util";
+function resolveLocalWhisperScriptPath() {
+  const moduleDir = path9.dirname(fileURLToPath2(import.meta.url));
+  const candidates = [
+    path9.resolve(moduleDir, "../scripts/transcribe_audio.sh"),
+    path9.resolve(moduleDir, "speech/transcribe_audio.sh")
+  ];
+  return candidates.find(existsSync2) ?? candidates[0];
+}
+function mimeToExt2(mimeType) {
+  const normalized = mimeType.split(";", 1)[0]?.trim().toLowerCase();
+  const extensions = {
+    "audio/ogg": ".ogg",
+    "audio/opus": ".ogg",
+    "audio/wav": ".wav",
+    "audio/x-wav": ".wav",
+    "audio/mpeg": ".mp3",
+    "audio/mp3": ".mp3",
+    "audio/mp4": ".m4a",
+    "audio/aac": ".aac",
+    "audio/webm": ".webm",
+    "audio/flac": ".flac"
+  };
+  return normalized && extensions[normalized] || ".bin";
+}
+function parseMetadata(stderr) {
+  const language = /\blanguage=([^\s]+)/.exec(stderr)?.[1];
+  const durationRaw = /\bduration=([0-9.]+)s\b/.exec(stderr)?.[1];
+  const duration = durationRaw ? Number(durationRaw) : void 0;
+  return { language, duration: Number.isFinite(duration) ? duration : void 0 };
+}
+function formatExecError(error) {
+  if (!(error instanceof Error)) return String(error);
+  const execError = error;
+  const details = [execError.stderr, execError.stdout].filter(Boolean).join("\n").trim();
+  const code = execError.code === void 0 ? "" : ` (exit ${execError.code})`;
+  return details ? `${error.message}${code}: ${details}` : `${error.message}${code}`;
+}
+var execFileAsync, LOCAL_WHISPER_PROVIDER, LOCAL_WHISPER_DEFAULTS, LocalWhisperSTT;
+var init_local_whisper = __esm({
+  "src/plugins/speech/providers/local-whisper.ts"() {
+    "use strict";
+    execFileAsync = promisify(execFile);
+    LOCAL_WHISPER_PROVIDER = "local-whisper";
+    LOCAL_WHISPER_DEFAULTS = {
+      language: "ru",
+      model: "base",
+      beamSize: 5,
+      vadFilter: false,
+      device: "cpu",
+      computeType: "int8",
+      timeoutMs: 12e4
+    };
+    LocalWhisperSTT = class {
+      name = LOCAL_WHISPER_PROVIDER;
+      config;
+      constructor(options = {}) {
+        this.config = {
+          scriptPath: options.scriptPath ?? resolveLocalWhisperScriptPath(),
+          language: options.language ?? LOCAL_WHISPER_DEFAULTS.language,
+          model: options.model ?? LOCAL_WHISPER_DEFAULTS.model,
+          beamSize: options.beamSize ?? LOCAL_WHISPER_DEFAULTS.beamSize,
+          vadFilter: options.vadFilter ?? LOCAL_WHISPER_DEFAULTS.vadFilter,
+          device: options.device ?? LOCAL_WHISPER_DEFAULTS.device,
+          computeType: options.computeType ?? LOCAL_WHISPER_DEFAULTS.computeType,
+          timeoutMs: options.timeoutMs ?? LOCAL_WHISPER_DEFAULTS.timeoutMs,
+          tempRoot: options.tempRoot
+        };
+      }
+      async transcribe(audioBuffer, mimeType, options) {
+        const tempDir = await mkdtemp(path9.join(this.config.tempRoot ?? tmpdir(), "openacp-local-whisper-"));
+        const audioPath = path9.join(tempDir, `input${mimeToExt2(mimeType)}`);
+        try {
+          await writeFile(audioPath, audioBuffer);
+          const { stdout, stderr } = await execFileAsync(this.config.scriptPath, this.buildArgs(audioPath, options), {
+            timeout: this.config.timeoutMs,
+            maxBuffer: 10 * 1024 * 1024
+          });
+          const text5 = stdout.trim();
+          if (!text5) throw new Error("Local Whisper returned an empty transcript");
+          return { text: text5, ...parseMetadata(stderr) };
+        } catch (error) {
+          throw new Error(`Local Whisper STT failed: ${formatExecError(error)}`);
+        } finally {
+          await rm(tempDir, { recursive: true, force: true });
+        }
+      }
+      buildArgs(audioPath, options) {
+        return [
+          "--model",
+          options?.model ?? this.config.model,
+          "--language",
+          options?.language ?? this.config.language,
+          "--beam-size",
+          String(this.config.beamSize),
+          "--device",
+          this.config.device,
+          "--compute-type",
+          this.config.computeType,
+          this.config.vadFilter ? "--vad-filter" : "--no-vad-filter",
+          audioPath
+        ];
+      }
+    };
+  }
+});
+
 // src/plugins/speech/exports.ts
 var init_exports = __esm({
   "src/plugins/speech/exports.ts"() {
     "use strict";
     init_speech_service();
     init_groq();
+    init_local_whisper();
+  }
+});
+
+// src/plugins/speech/native-stt.ts
+function readLocalWhisperSettings(raw) {
+  return {
+    scriptPath: readString(raw.localWhisperScriptPath, resolveLocalWhisperScriptPath()),
+    language: readString(raw.localWhisperLanguage, LOCAL_WHISPER_DEFAULTS.language),
+    model: readString(raw.localWhisperModel, LOCAL_WHISPER_DEFAULTS.model),
+    beamSize: readNumber(raw.localWhisperBeamSize, LOCAL_WHISPER_DEFAULTS.beamSize),
+    vadFilter: readBoolean(raw.localWhisperVadFilter, LOCAL_WHISPER_DEFAULTS.vadFilter),
+    device: readString(raw.localWhisperDevice, LOCAL_WHISPER_DEFAULTS.device),
+    computeType: readString(raw.localWhisperComputeType, LOCAL_WHISPER_DEFAULTS.computeType),
+    timeoutMs: readNumber(raw.localWhisperTimeoutMs, LOCAL_WHISPER_DEFAULTS.timeoutMs)
+  };
+}
+function buildSpeechServiceConfig(raw) {
+  const groqApiKey = readOptionalString(raw.groqApiKey);
+  const requestedProvider = readOptionalString(raw.sttProvider);
+  const provider = requestedProvider === LOCAL_WHISPER_PROVIDER ? LOCAL_WHISPER_PROVIDER : groqApiKey ? "groq" : null;
+  const providers = {};
+  if (groqApiKey) providers.groq = { apiKey: groqApiKey };
+  if (provider === LOCAL_WHISPER_PROVIDER) {
+    providers[LOCAL_WHISPER_PROVIDER] = {
+      apiKey: "local",
+      ...readLocalWhisperSettings(raw)
+    };
+  }
+  return {
+    stt: { provider, providers },
+    tts: {
+      provider: readOptionalString(raw.ttsProvider) ?? "edge-tts",
+      providers: {}
+    }
+  };
+}
+function createNativeSTTProviders(config) {
+  const providers = /* @__PURE__ */ new Map();
+  const groq = config.stt.providers.groq;
+  if (groq?.apiKey) providers.set("groq", new GroqSTT(groq.apiKey, groq.model));
+  const local = config.stt.providers[LOCAL_WHISPER_PROVIDER];
+  if (local?.apiKey !== void 0) {
+    providers.set(LOCAL_WHISPER_PROVIDER, new LocalWhisperSTT({
+      scriptPath: readOptionalString(local.scriptPath),
+      language: readOptionalString(local.language),
+      model: readOptionalString(local.model),
+      beamSize: readOptionalNumber(local.beamSize),
+      vadFilter: typeof local.vadFilter === "boolean" ? local.vadFilter : void 0,
+      device: readOptionalString(local.device),
+      computeType: readOptionalString(local.computeType),
+      timeoutMs: readOptionalNumber(local.timeoutMs)
+    }));
+  }
+  return providers;
+}
+function readString(value, fallback) {
+  return readOptionalString(value) ?? fallback;
+}
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readNumber(value, fallback) {
+  return readOptionalNumber(value) ?? fallback;
+}
+function readOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+var init_native_stt = __esm({
+  "src/plugins/speech/native-stt.ts"() {
+    "use strict";
+    init_groq();
+    init_local_whisper();
+    init_local_whisper();
   }
 });
 
@@ -5011,14 +5202,14 @@ __export(plugin_installer_exports, {
   importFromDir: () => importFromDir,
   installNpmPlugin: () => installNpmPlugin
 });
-import { execFile } from "child_process";
-import { promisify } from "util";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
 import * as fs8 from "fs/promises";
-import * as path9 from "path";
+import * as path10 from "path";
 import { pathToFileURL } from "url";
 async function importFromDir(packageName, dir) {
-  const pkgDir = path9.join(dir, "node_modules", ...packageName.split("/"));
-  const pkgJsonPath = path9.join(pkgDir, "package.json");
+  const pkgDir = path10.join(dir, "node_modules", ...packageName.split("/"));
+  const pkgJsonPath = path10.join(pkgDir, "package.json");
   let pkgJson;
   try {
     pkgJson = JSON.parse(await fs8.readFile(pkgJsonPath, "utf-8"));
@@ -5034,7 +5225,7 @@ async function importFromDir(packageName, dir) {
   } else {
     entry = pkgJson.main ?? "index.js";
   }
-  const entryPath = path9.join(pkgDir, entry);
+  const entryPath = path10.join(pkgDir, entry);
   try {
     await fs8.access(entryPath);
   } catch {
@@ -5051,16 +5242,16 @@ async function installNpmPlugin(packageName, pluginsDir) {
     return await importFromDir(packageName, dir);
   } catch {
   }
-  await execFileAsync("npm", ["install", packageName, "--prefix", dir, "--save", "--ignore-scripts"], {
+  await execFileAsync2("npm", ["install", packageName, "--prefix", dir, "--save", "--ignore-scripts"], {
     timeout: 6e4
   });
   return await importFromDir(packageName, dir);
 }
-var execFileAsync, VALID_NPM_NAME;
+var execFileAsync2, VALID_NPM_NAME;
 var init_plugin_installer = __esm({
   "src/core/plugin/plugin-installer.ts"() {
     "use strict";
-    execFileAsync = promisify(execFile);
+    execFileAsync2 = promisify2(execFile2);
     VALID_NPM_NAME = /^(@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*(@[\w.^~>=<|-]+)?$/i;
   }
 });
@@ -5070,12 +5261,13 @@ var speech_exports = {};
 __export(speech_exports, {
   default: () => speech_default
 });
-import path10 from "path";
+import path11 from "path";
 var EDGE_TTS_PLUGIN, speechPlugin, speech_default;
 var init_speech = __esm({
   "src/plugins/speech/index.ts"() {
     "use strict";
     init_exports();
+    init_native_stt();
     init_plugin_installer();
     EDGE_TTS_PLUGIN = "@openacp/msedge-tts-plugin";
     speechPlugin = {
@@ -5089,17 +5281,22 @@ var init_speech = __esm({
       inheritableKeys: ["ttsProvider", "ttsVoice"],
       async install(ctx) {
         const { terminal, settings } = ctx;
-        const pluginsDir = ctx.instanceRoot ? path10.join(ctx.instanceRoot, "plugins") : void 0;
+        const pluginsDir = ctx.instanceRoot ? path11.join(ctx.instanceRoot, "plugins") : void 0;
         const enableStt = await terminal.confirm({
           message: "Enable speech-to-text (STT)?",
           initialValue: false
         });
         let sttProvider = null;
         let groqApiKey = "";
+        let localWhisperLanguage = LOCAL_WHISPER_DEFAULTS.language;
+        let localWhisperModel = LOCAL_WHISPER_DEFAULTS.model;
         if (enableStt) {
           sttProvider = await terminal.select({
             message: "STT provider:",
-            options: [{ value: "groq", label: "Groq (Whisper)", hint: "Fast and affordable" }]
+            options: [
+              { value: LOCAL_WHISPER_PROVIDER, label: "Local faster-whisper", hint: "Private and offline after the first model download" },
+              { value: "groq", label: "Groq (Whisper)", hint: "Hosted API, requires an API key" }
+            ]
           });
           if (sttProvider === "groq") {
             groqApiKey = await terminal.text({
@@ -5107,6 +5304,15 @@ var init_speech = __esm({
               validate: (v) => !v.trim() ? "API key cannot be empty" : void 0
             });
             groqApiKey = groqApiKey.trim();
+          } else {
+            localWhisperLanguage = (await terminal.text({
+              message: "Local Whisper language:",
+              defaultValue: LOCAL_WHISPER_DEFAULTS.language
+            })).trim() || LOCAL_WHISPER_DEFAULTS.language;
+            localWhisperModel = (await terminal.text({
+              message: "Local Whisper model:",
+              defaultValue: LOCAL_WHISPER_DEFAULTS.model
+            })).trim() || LOCAL_WHISPER_DEFAULTS.model;
           }
         }
         const ttsProvider = await terminal.select({
@@ -5134,6 +5340,13 @@ var init_speech = __esm({
         await settings.setAll({
           sttProvider,
           groqApiKey,
+          localWhisperLanguage,
+          localWhisperModel,
+          localWhisperBeamSize: LOCAL_WHISPER_DEFAULTS.beamSize,
+          localWhisperVadFilter: LOCAL_WHISPER_DEFAULTS.vadFilter,
+          localWhisperDevice: LOCAL_WHISPER_DEFAULTS.device,
+          localWhisperComputeType: LOCAL_WHISPER_DEFAULTS.computeType,
+          localWhisperTimeoutMs: LOCAL_WHISPER_DEFAULTS.timeoutMs,
           ttsProvider: ttsProvider === "none" ? null : ttsProvider,
           ttsVoice
         });
@@ -5151,13 +5364,34 @@ var init_speech = __esm({
           ]
         });
         if (choice === "stt") {
-          const key = await terminal.text({
-            message: "Groq API key (leave blank to disable STT):",
-            defaultValue: current.groqApiKey ?? ""
+          const provider = await terminal.select({
+            message: "STT provider:",
+            options: [
+              { value: LOCAL_WHISPER_PROVIDER, label: "Local faster-whisper", hint: "Private and offline after the first model download" },
+              { value: "groq", label: "Groq (Whisper)", hint: "Hosted API, requires an API key" },
+              { value: "none", label: "None (disable STT)" }
+            ]
           });
-          const trimmed = key.trim();
-          await settings.set("sttProvider", trimmed ? "groq" : null);
-          await settings.set("groqApiKey", trimmed);
+          await settings.set("sttProvider", provider === "none" ? null : provider);
+          if (provider === "groq") {
+            const key = await terminal.text({
+              message: "Groq API key:",
+              defaultValue: current.groqApiKey ?? "",
+              validate: (v) => !v.trim() ? "API key cannot be empty" : void 0
+            });
+            await settings.set("groqApiKey", key.trim());
+          } else if (provider === LOCAL_WHISPER_PROVIDER) {
+            const language = await terminal.text({
+              message: "Local Whisper language:",
+              defaultValue: current.localWhisperLanguage ?? LOCAL_WHISPER_DEFAULTS.language
+            });
+            const model = await terminal.text({
+              message: "Local Whisper model:",
+              defaultValue: current.localWhisperModel ?? LOCAL_WHISPER_DEFAULTS.model
+            });
+            await settings.set("localWhisperLanguage", language.trim() || LOCAL_WHISPER_DEFAULTS.language);
+            await settings.set("localWhisperModel", model.trim() || LOCAL_WHISPER_DEFAULTS.model);
+          }
           terminal.log.success("STT settings updated");
         } else if (choice === "tts") {
           const voice = await terminal.text({
@@ -5176,37 +5410,26 @@ var init_speech = __esm({
       },
       async setup(ctx) {
         ctx.registerEditableFields([
-          { key: "sttProvider", displayName: "Speech to Text", type: "select", scope: "safe", hotReload: true, options: ["groq"] },
-          { key: "groqApiKey", displayName: "STT API Key", type: "string", scope: "sensitive", hotReload: true },
+          { key: "sttProvider", displayName: "Speech to Text", type: "select", scope: "safe", hotReload: true, options: [LOCAL_WHISPER_PROVIDER, "groq"] },
+          { key: "groqApiKey", displayName: "Groq STT API Key", type: "string", scope: "sensitive", hotReload: true },
+          { key: "localWhisperLanguage", displayName: "Local Whisper Language", type: "string", scope: "safe", hotReload: true },
+          { key: "localWhisperModel", displayName: "Local Whisper Model", type: "string", scope: "safe", hotReload: true },
+          { key: "localWhisperBeamSize", displayName: "Local Whisper Beam Size", type: "number", scope: "safe", hotReload: true },
+          { key: "localWhisperVadFilter", displayName: "Local Whisper VAD Filter", type: "toggle", scope: "safe", hotReload: true },
+          { key: "localWhisperDevice", displayName: "Local Whisper Device", type: "select", scope: "safe", hotReload: true, options: ["cpu", "cuda", "auto"] },
+          { key: "localWhisperComputeType", displayName: "Local Whisper Compute Type", type: "string", scope: "safe", hotReload: true },
+          { key: "localWhisperTimeoutMs", displayName: "Local Whisper Timeout (ms)", type: "number", scope: "safe", hotReload: true },
+          { key: "localWhisperScriptPath", displayName: "Local Whisper Script Path", type: "string", scope: "safe", hotReload: true },
           { key: "ttsProvider", displayName: "Text to Speech", type: "select", scope: "safe", hotReload: true, options: ["edge-tts"] }
         ]);
-        const pluginsDir = ctx.instanceRoot ? path10.join(ctx.instanceRoot, "plugins") : void 0;
+        const pluginsDir = ctx.instanceRoot ? path11.join(ctx.instanceRoot, "plugins") : void 0;
         const config = ctx.pluginConfig;
-        const groqApiKey = config.groqApiKey;
-        const sttProvider = groqApiKey ? "groq" : null;
-        const speechConfig = {
-          stt: {
-            provider: sttProvider,
-            providers: groqApiKey ? { groq: { apiKey: groqApiKey } } : {}
-          },
-          tts: {
-            provider: config.ttsProvider ?? "edge-tts",
-            providers: {}
-          }
-        };
+        const speechConfig = buildSpeechServiceConfig(config);
         const service = new SpeechService(speechConfig);
-        if (groqApiKey) {
-          service.registerSTTProvider("groq", new GroqSTT(groqApiKey));
+        for (const [name, provider] of createNativeSTTProviders(speechConfig)) {
+          service.registerSTTProvider(name, provider);
         }
-        service.setProviderFactory((cfg) => {
-          const sttMap = /* @__PURE__ */ new Map();
-          const ttsMap = /* @__PURE__ */ new Map();
-          const groqCfg = cfg.stt?.providers?.groq;
-          if (groqCfg?.apiKey) {
-            sttMap.set("groq", new GroqSTT(groqCfg.apiKey, groqCfg.model));
-          }
-          return { stt: sttMap, tts: ttsMap };
-        });
+        service.setProviderFactory((cfg) => ({ stt: createNativeSTTProviders(cfg), tts: /* @__PURE__ */ new Map() }));
         ctx.registerService("speech", service);
         const setSessionVoiceMode = (pluginCtx, sessionId, voiceMode) => {
           if (!sessionId) return;
@@ -5534,7 +5757,7 @@ __export(agent_dependencies_exports, {
 });
 import { execFileSync as execFileSync2 } from "child_process";
 import * as fs9 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 function getAgentSetup(registryId) {
   return AGENT_SETUP[registryId];
 }
@@ -5558,9 +5781,9 @@ function commandExists(cmd) {
   }
   let dir = process.cwd();
   while (true) {
-    const binPath = path11.join(dir, "node_modules", ".bin", cmd);
+    const binPath = path12.join(dir, "node_modules", ".bin", cmd);
     if (fs9.existsSync(binPath)) return true;
-    const parent = path11.dirname(dir);
+    const parent = path12.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -5826,7 +6049,7 @@ var init_agent_dependencies = __esm({
 
 // src/core/agents/agent-installer.ts
 import * as fs10 from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 import * as os2 from "os";
 import crypto2 from "crypto";
 function validateArchiveContents(entries, destDir) {
@@ -5841,9 +6064,9 @@ function validateArchiveContents(entries, destDir) {
   }
 }
 function validateUninstallPath(binaryPath, agentsDir) {
-  const realPath = path12.resolve(binaryPath);
-  const realAgentsDir = path12.resolve(agentsDir);
-  if (!realPath.startsWith(realAgentsDir + path12.sep) && realPath !== realAgentsDir) {
+  const realPath = path13.resolve(binaryPath);
+  const realAgentsDir = path13.resolve(agentsDir);
+  if (!realPath.startsWith(realAgentsDir + path13.sep) && realPath !== realAgentsDir) {
     throw new Error(`Refusing to delete path outside agents directory: ${realPath}`);
   }
 }
@@ -5897,7 +6120,7 @@ function buildInstalledAgent(registryId, name, version, dist, binaryPath) {
       binaryPath: null
     };
   }
-  const absCmd = path12.resolve(binaryPath, dist.cmd);
+  const absCmd = path13.resolve(binaryPath, dist.cmd);
   return {
     registryId,
     name,
@@ -5963,7 +6186,7 @@ Install it with: pip install uv`;
   return { ok: true, agentKey, setupSteps: setupSteps.length > 0 ? setupSteps : void 0 };
 }
 async function downloadAndExtract(agentId, archiveUrl, progress, agentsDir) {
-  const destDir = path12.join(agentsDir ?? DEFAULT_AGENTS_DIR, agentId);
+  const destDir = path13.join(agentsDir ?? DEFAULT_AGENTS_DIR, agentId);
   fs10.mkdirSync(destDir, { recursive: true });
   await progress?.onStep("Downloading...");
   log2.info({ agentId, url: archiveUrl }, "Downloading agent binary");
@@ -6010,15 +6233,15 @@ function validateExtractedPaths(destDir) {
   for (const entry of entries) {
     const dirent = entry;
     const parentPath = dirent.parentPath ?? dirent.path ?? destDir;
-    const fullPath = path12.join(parentPath, entry.name);
+    const fullPath = path13.join(parentPath, entry.name);
     let realPath;
     try {
       realPath = fs10.realpathSync(fullPath);
     } catch {
       const linkTarget = fs10.readlinkSync(fullPath);
-      realPath = path12.resolve(path12.dirname(fullPath), linkTarget);
+      realPath = path13.resolve(path13.dirname(fullPath), linkTarget);
     }
-    if (!realPath.startsWith(realDest + path12.sep) && realPath !== realDest) {
+    if (!realPath.startsWith(realDest + path13.sep) && realPath !== realDest) {
       fs10.rmSync(destDir, { recursive: true, force: true });
       throw new Error(`Archive contains unsafe path: ${entry.name}`);
     }
@@ -6026,7 +6249,7 @@ function validateExtractedPaths(destDir) {
 }
 async function extractTarGz(buffer, destDir) {
   const { execFileSync: execFileSync9 } = await import("child_process");
-  const tmpFile = path12.join(destDir, "_archive.tar.gz");
+  const tmpFile = path13.join(destDir, "_archive.tar.gz");
   fs10.writeFileSync(tmpFile, buffer);
   try {
     const listing = execFileSync9("tar", ["tf", tmpFile], { stdio: "pipe" }).toString().trim().split("\n").filter(Boolean);
@@ -6039,7 +6262,7 @@ async function extractTarGz(buffer, destDir) {
 }
 async function extractZip(buffer, destDir) {
   const { execFileSync: execFileSync9 } = await import("child_process");
-  const tmpFile = path12.join(destDir, "_archive.zip");
+  const tmpFile = path13.join(destDir, "_archive.zip");
   fs10.writeFileSync(tmpFile, buffer);
   try {
     const listing = execFileSync9("unzip", ["-l", tmpFile], { stdio: "pipe" }).toString().trim().split("\n").filter(Boolean);
@@ -6068,7 +6291,7 @@ var init_agent_installer = __esm({
     init_log();
     init_agent_dependencies();
     log2 = createChildLogger({ module: "agent-installer" });
-    DEFAULT_AGENTS_DIR = path12.join(os2.homedir(), ".openacp", "agents");
+    DEFAULT_AGENTS_DIR = path13.join(os2.homedir(), ".openacp", "agents");
     MAX_DOWNLOAD_SIZE = 500 * 1024 * 1024;
     validateTarContents = validateArchiveContents;
     ARCH_MAP = {
@@ -6085,7 +6308,7 @@ var init_agent_installer = __esm({
 
 // src/core/utils/install-binary.ts
 import fs11 from "fs";
-import path13 from "path";
+import path14 from "path";
 import https from "https";
 import os3 from "os";
 import { execFileSync as execFileSync3 } from "child_process";
@@ -6160,7 +6383,7 @@ function getDownloadUrl(spec) {
 async function ensureBinary(spec, binDir) {
   const resolvedBinDir = binDir ?? DEFAULT_BIN_DIR;
   const binName = IS_WINDOWS ? `${spec.name}.exe` : spec.name;
-  const binPath = path13.join(resolvedBinDir, binName);
+  const binPath = path14.join(resolvedBinDir, binName);
   if (commandExists(spec.name)) {
     log3.debug({ name: spec.name }, "Found in PATH");
     return spec.name;
@@ -6174,7 +6397,7 @@ async function ensureBinary(spec, binDir) {
   fs11.mkdirSync(resolvedBinDir, { recursive: true });
   const url = getDownloadUrl(spec);
   const isArchive = spec.isArchive?.(url) ?? false;
-  const downloadDest = isArchive ? path13.join(resolvedBinDir, `${spec.name}.tgz`) : binPath;
+  const downloadDest = isArchive ? path14.join(resolvedBinDir, `${spec.name}.tgz`) : binPath;
   await downloadFile(url, downloadDest);
   if (isArchive) {
     const listing = execFileSync3("tar", ["-tf", downloadDest], { stdio: "pipe" }).toString().trim().split("\n").filter(Boolean);
@@ -6202,7 +6425,7 @@ var init_install_binary = __esm({
     init_agent_dependencies();
     init_agent_installer();
     log3 = createChildLogger({ module: "binary-installer" });
-    DEFAULT_BIN_DIR = path13.join(os3.homedir(), ".openacp", "bin");
+    DEFAULT_BIN_DIR = path14.join(os3.homedir(), ".openacp", "bin");
     IS_WINDOWS = os3.platform() === "win32";
   }
 });
@@ -6245,7 +6468,7 @@ var init_install_cloudflared = __esm({
 // src/plugins/tunnel/providers/cloudflare.ts
 import { spawn } from "child_process";
 import fs12 from "fs";
-import path14 from "path";
+import path15 from "path";
 var log4, SIGKILL_TIMEOUT_MS, CloudflareTunnelProvider;
 var init_cloudflare = __esm({
   "src/plugins/tunnel/providers/cloudflare.ts"() {
@@ -6357,7 +6580,7 @@ var init_cloudflare = __esm({
       }
       findBinary() {
         if (commandExists("cloudflared")) return "cloudflared";
-        const binPath = path14.join(this.binDir, "cloudflared");
+        const binPath = path15.join(this.binDir, "cloudflared");
         if (fs12.existsSync(binPath)) return binPath;
         return null;
       }
@@ -6713,7 +6936,7 @@ var init_tailscale = __esm({
 // src/plugins/tunnel/providers/openacp.ts
 import { spawn as spawn5 } from "child_process";
 import fs13 from "fs";
-import path15 from "path";
+import path16 from "path";
 var log8, DEFAULT_WORKER_URL, DEFAULT_API_KEY, HEARTBEAT_INTERVAL_MS, STARTUP_TIMEOUT_MS, SIGKILL_TIMEOUT_MS5, STORAGE_KEY, OpenACPTunnelProvider;
 var init_openacp = __esm({
   "src/plugins/tunnel/providers/openacp.ts"() {
@@ -6915,7 +7138,7 @@ var init_openacp = __esm({
       }
       async resolveBinary() {
         if (commandExists("cloudflared")) return "cloudflared";
-        const binPath = path15.join(this.binDir, "cloudflared");
+        const binPath = path16.join(this.binDir, "cloudflared");
         if (fs13.existsSync(binPath)) return binPath;
         log8.warn("cloudflared not found, attempting auto-install...");
         const { ensureCloudflared: ensureCloudflared2 } = await Promise.resolve().then(() => (init_install_cloudflared(), install_cloudflared_exports));
@@ -6927,7 +7150,7 @@ var init_openacp = __esm({
 
 // src/plugins/tunnel/tunnel-registry.ts
 import fs14 from "fs";
-import path16 from "path";
+import path17 from "path";
 var log9, MAX_RETRIES, BASE_RETRY_DELAY_MS, TunnelRegistry;
 var init_tunnel_registry = __esm({
   "src/plugins/tunnel/tunnel-registry.ts"() {
@@ -7252,7 +7475,7 @@ var init_tunnel_registry = __esm({
           createdAt: l.entry.createdAt
         }));
         try {
-          const dir = path16.dirname(this.registryPath);
+          const dir = path17.dirname(this.registryPath);
           fs14.mkdirSync(dir, { recursive: true });
           fs14.writeFileSync(this.registryPath, JSON.stringify(data, null, 2));
         } catch (err) {
@@ -7687,7 +7910,7 @@ var init_output_viewer = __esm({
 });
 
 // src/plugins/tunnel/viewer-routes.ts
-import path17 from "path";
+import path18 from "path";
 function createViewerRoutes(store) {
   return async (app) => {
     app.get("/view/:id", async (request, reply) => {
@@ -7717,7 +7940,7 @@ function createViewerRoutes(store) {
         return reply.status(404).send({ error: "not found" });
       }
       return reply.send({
-        filePath: entry.filePath ? path17.basename(entry.filePath) : null,
+        filePath: entry.filePath ? path18.basename(entry.filePath) : null,
         content: entry.content,
         language: entry.language
       });
@@ -7728,7 +7951,7 @@ function createViewerRoutes(store) {
         return reply.status(404).send({ error: "not found" });
       }
       return reply.send({
-        filePath: entry.filePath ? path17.basename(entry.filePath) : null,
+        filePath: entry.filePath ? path18.basename(entry.filePath) : null,
         oldContent: entry.oldContent,
         newContent: entry.content,
         language: entry.language
@@ -7753,7 +7976,7 @@ var init_viewer_routes = __esm({
 
 // src/plugins/tunnel/viewer-store.ts
 import * as fs15 from "fs";
-import * as path18 from "path";
+import * as path19 from "path";
 import { nanoid as nanoid2 } from "nanoid";
 var log10, MAX_CONTENT_SIZE, EXTENSION_LANGUAGE, ViewerStore;
 var init_viewer_store = __esm({
@@ -7909,24 +8132,24 @@ var init_viewer_store = __esm({
         let resolved;
         let workspace;
         try {
-          resolved = fs15.realpathSync(path18.resolve(workingDirectory, filePath));
+          resolved = fs15.realpathSync(path19.resolve(workingDirectory, filePath));
         } catch {
-          resolved = path18.resolve(workingDirectory, filePath);
+          resolved = path19.resolve(workingDirectory, filePath);
         }
         try {
-          workspace = fs15.realpathSync(path18.resolve(workingDirectory));
+          workspace = fs15.realpathSync(path19.resolve(workingDirectory));
         } catch {
-          workspace = path18.resolve(workingDirectory);
+          workspace = path19.resolve(workingDirectory);
         }
         if (caseInsensitive) {
           const rLower = resolved.toLowerCase();
           const wLower = workspace.toLowerCase();
-          return rLower.startsWith(wLower + path18.sep) || rLower === wLower;
+          return rLower.startsWith(wLower + path19.sep) || rLower === wLower;
         }
-        return resolved.startsWith(workspace + path18.sep) || resolved === workspace;
+        return resolved.startsWith(workspace + path19.sep) || resolved === workspace;
       }
       detectLanguage(filePath) {
-        const ext = path18.extname(filePath).toLowerCase();
+        const ext = path19.extname(filePath).toLowerCase();
         return EXTENSION_LANGUAGE[ext];
       }
       destroy() {
@@ -8073,7 +8296,7 @@ var tunnel_exports = {};
 __export(tunnel_exports, {
   default: () => tunnel_default
 });
-import path19 from "path";
+import path20 from "path";
 function createTunnelPlugin() {
   let service = null;
   return {
@@ -8179,10 +8402,10 @@ function createTunnelPlugin() {
         { key: "provider", displayName: "Provider", type: "select", scope: "safe", hotReload: false, options: ["openacp", "cloudflare", "ngrok", "bore", "tailscale"] }
       ]);
       const { default: fs57 } = await import("fs");
-      const settingsPath = path19.join(ctx.instanceRoot, "plugins", "data", ctx.pluginName, "settings.json");
+      const settingsPath = path20.join(ctx.instanceRoot, "plugins", "data", ctx.pluginName, "settings.json");
       if (!fs57.existsSync(settingsPath)) {
         const defaults = { enabled: true, provider: "openacp", maxUserTunnels: 5, auth: { enabled: false } };
-        fs57.mkdirSync(path19.dirname(settingsPath), { recursive: true });
+        fs57.mkdirSync(path20.dirname(settingsPath), { recursive: true });
         fs57.writeFileSync(settingsPath, JSON.stringify(defaults, null, 2));
         Object.assign(ctx.pluginConfig, defaults);
         ctx.log.info("Initialized tunnel settings with defaults (openacp provider)");
@@ -8218,8 +8441,8 @@ function createTunnelPlugin() {
       const instanceRoot = ctx.instanceRoot;
       const tunnelSvc = new TunnelService2(
         config,
-        path19.join(instanceRoot, "tunnels.json"),
-        path19.join(instanceRoot, "bin"),
+        path20.join(instanceRoot, "tunnels.json"),
+        path20.join(instanceRoot, "bin"),
         ctx.storage,
         (event, data) => ctx.emit(event, data)
       );
@@ -8318,7 +8541,7 @@ __export(token_store_exports, {
   TokenStore: () => TokenStore,
   parseDuration: () => parseDuration
 });
-import { readFile as readFile2, writeFile } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { randomBytes as randomBytes2 } from "crypto";
 function generateTokenId() {
   return `tok_${randomBytes2(12).toString("hex")}`;
@@ -8387,7 +8610,7 @@ var init_token_store = __esm({
           tokens: Array.from(this.tokens.values()),
           codes: Array.from(this.codes.values())
         };
-        await writeFile(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+        await writeFile2(this.filePath, JSON.stringify(data, null, 2), "utf-8");
       }
       /**
        * Coalesces concurrent writes: if a save is in-flight, sets a pending flag
@@ -8595,22 +8818,22 @@ __export(config_registry_exports, {
   resolveOptions: () => resolveOptions,
   setFieldValueAsync: () => setFieldValueAsync
 });
-function getFieldDef(path71) {
-  return CONFIG_REGISTRY.find((f) => f.path === path71);
+function getFieldDef(path72) {
+  return CONFIG_REGISTRY.find((f) => f.path === path72);
 }
 function getSafeFields() {
   return CONFIG_REGISTRY.filter((f) => f.scope === "safe");
 }
-function isHotReloadable(path71) {
-  const def = getFieldDef(path71);
+function isHotReloadable(path72) {
+  const def = getFieldDef(path72);
   return def?.hotReload ?? false;
 }
 function resolveOptions(def, config) {
   if (!def.options) return void 0;
   return typeof def.options === "function" ? def.options(config) : def.options;
 }
-function getConfigValue(config, path71) {
-  const parts = path71.split(".");
+function getConfigValue(config, path72) {
+  const parts = path72.split(".");
   let current = config;
   for (const part of parts) {
     if (current && typeof current === "object" && part in current) {
@@ -9270,8 +9493,8 @@ __export(static_server_exports, {
   StaticServer: () => StaticServer
 });
 import * as fs16 from "fs";
-import * as path20 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import * as path21 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var MIME_TYPES, StaticServer;
 var init_static_server = __esm({
   "src/plugins/api-server/static-server.ts"() {
@@ -9293,17 +9516,17 @@ var init_static_server = __esm({
       constructor(uiDir) {
         this.uiDir = uiDir;
         if (!this.uiDir) {
-          const __filename = fileURLToPath2(import.meta.url);
-          const candidate = path20.resolve(path20.dirname(__filename), "../../ui/dist");
-          if (fs16.existsSync(path20.join(candidate, "index.html"))) {
+          const __filename = fileURLToPath3(import.meta.url);
+          const candidate = path21.resolve(path21.dirname(__filename), "../../ui/dist");
+          if (fs16.existsSync(path21.join(candidate, "index.html"))) {
             this.uiDir = candidate;
           }
           if (!this.uiDir) {
-            const publishCandidate = path20.resolve(
-              path20.dirname(__filename),
+            const publishCandidate = path21.resolve(
+              path21.dirname(__filename),
               "../ui"
             );
-            if (fs16.existsSync(path20.join(publishCandidate, "index.html"))) {
+            if (fs16.existsSync(path21.join(publishCandidate, "index.html"))) {
               this.uiDir = publishCandidate;
             }
           }
@@ -9321,9 +9544,9 @@ var init_static_server = __esm({
       serve(req, res) {
         if (!this.uiDir) return false;
         const urlPath = (req.url || "/").split("?")[0];
-        const safePath = path20.normalize(urlPath);
-        const filePath = path20.join(this.uiDir, safePath);
-        if (!filePath.startsWith(this.uiDir + path20.sep) && filePath !== this.uiDir)
+        const safePath = path21.normalize(urlPath);
+        const filePath = path21.join(this.uiDir, safePath);
+        if (!filePath.startsWith(this.uiDir + path21.sep) && filePath !== this.uiDir)
           return false;
         let realFilePath;
         try {
@@ -9333,11 +9556,11 @@ var init_static_server = __esm({
         }
         if (realFilePath !== null) {
           const realUiDir = fs16.realpathSync(this.uiDir);
-          if (!realFilePath.startsWith(realUiDir + path20.sep) && realFilePath !== realUiDir)
+          if (!realFilePath.startsWith(realUiDir + path21.sep) && realFilePath !== realUiDir)
             return false;
         }
         if (realFilePath !== null && fs16.existsSync(realFilePath) && fs16.statSync(realFilePath).isFile()) {
-          const ext = path20.extname(filePath);
+          const ext = path21.extname(filePath);
           const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
           const isHashed = /\.[a-zA-Z0-9]{8,}\.(js|css)$/.test(filePath);
           const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "no-cache";
@@ -9348,7 +9571,7 @@ var init_static_server = __esm({
           fs16.createReadStream(realFilePath).pipe(res);
           return true;
         }
-        const indexPath = path20.join(this.uiDir, "index.html");
+        const indexPath = path21.join(this.uiDir, "index.html");
         if (fs16.existsSync(indexPath)) {
           res.writeHead(200, {
             "Content-Type": "text/html; charset=utf-8",
@@ -10100,7 +10323,7 @@ var init_config = __esm({
 
 // src/core/config/config-migrations.ts
 import fs18 from "fs";
-import path21 from "path";
+import path22 from "path";
 import os4 from "os";
 function applyMigrations(raw, migrationList = migrations, ctx) {
   let changed = false;
@@ -10150,7 +10373,7 @@ var init_config_migrations = __esm({
           if (!ctx?.configDir) return false;
           const instanceRoot = ctx.configDir;
           try {
-            const registryPath = path21.join(os4.homedir(), ".openacp", "instances.json");
+            const registryPath = path22.join(os4.homedir(), ".openacp", "instances.json");
             const data = JSON.parse(fs18.readFileSync(registryPath, "utf-8"));
             const instances = data?.instances ?? {};
             const entry = Object.values(instances).find(
@@ -10179,13 +10402,13 @@ __export(config_exports, {
 });
 import { z as z4 } from "zod";
 import * as fs19 from "fs";
-import * as path22 from "path";
+import * as path23 from "path";
 import * as os5 from "os";
 import { randomBytes as randomBytes3 } from "crypto";
 import { EventEmitter } from "events";
 function expandHome2(p2) {
   if (p2.startsWith("~")) {
-    return path22.join(os5.homedir(), p2.slice(1));
+    return path23.join(os5.homedir(), p2.slice(1));
   }
   return p2;
 }
@@ -10259,7 +10482,7 @@ var init_config2 = __esm({
        * 4. Validate against Zod schema — exits on failure
        */
       async load() {
-        const dir = path22.dirname(this.configPath);
+        const dir = path23.dirname(this.configPath);
         fs19.mkdirSync(dir, { recursive: true });
         if (!fs19.existsSync(this.configPath)) {
           fs19.writeFileSync(
@@ -10273,7 +10496,7 @@ var init_config2 = __esm({
           process.exit(1);
         }
         const raw = JSON.parse(fs19.readFileSync(this.configPath, "utf-8"));
-        const { changed: configUpdated } = applyMigrations(raw, void 0, { configDir: path22.dirname(this.configPath) });
+        const { changed: configUpdated } = applyMigrations(raw, void 0, { configDir: path23.dirname(this.configPath) });
         if (configUpdated) {
           fs19.writeFileSync(this.configPath, JSON.stringify(raw, null, 2));
         }
@@ -10353,16 +10576,16 @@ var init_config2 = __esm({
        * (alphanumeric subdirectories under the base).
        */
       resolveWorkspace(input2) {
-        const workspaceBase = path22.dirname(path22.dirname(this.configPath));
+        const workspaceBase = path23.dirname(path23.dirname(this.configPath));
         if (!input2) {
           fs19.mkdirSync(workspaceBase, { recursive: true });
           return workspaceBase;
         }
         const expanded = input2.startsWith("~") ? expandHome2(input2) : input2;
-        if (path22.isAbsolute(expanded)) {
-          const resolved = path22.resolve(expanded);
-          const base = path22.resolve(workspaceBase);
-          const isInternal = resolved === base || resolved.startsWith(base + path22.sep);
+        if (path23.isAbsolute(expanded)) {
+          const resolved = path23.resolve(expanded);
+          const base = path23.resolve(workspaceBase);
+          const isInternal = resolved === base || resolved.startsWith(base + path23.sep);
           if (!isInternal) {
             if (!this.config.workspace.allowExternalWorkspaces) {
               throw new Error(
@@ -10382,7 +10605,7 @@ var init_config2 = __esm({
             `Invalid workspace name: "${input2}". Only alphanumeric characters, hyphens, and underscores are allowed.`
           );
         }
-        const namedPath = path22.join(workspaceBase, input2.toLowerCase());
+        const namedPath = path23.join(workspaceBase, input2.toLowerCase());
         fs19.mkdirSync(namedPath, { recursive: true });
         return namedPath;
       }
@@ -10396,7 +10619,7 @@ var init_config2 = __esm({
       }
       /** Writes a complete config object to disk, creating the directory if needed. Used during initial setup. */
       async writeNew(config) {
-        const dir = path22.dirname(this.configPath);
+        const dir = path23.dirname(this.configPath);
         fs19.mkdirSync(dir, { recursive: true });
         fs19.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
       }
@@ -10414,6 +10637,14 @@ var init_config2 = __esm({
           { envVar: "OPENACP_API_PORT", pluginName: "@openacp/api-server", key: "port", transform: (v) => Number(v) },
           { envVar: "OPENACP_SPEECH_STT_PROVIDER", pluginName: "@openacp/speech", key: "sttProvider" },
           { envVar: "OPENACP_SPEECH_GROQ_API_KEY", pluginName: "@openacp/speech", key: "groqApiKey" },
+          { envVar: "OPENACP_SPEECH_LOCAL_WHISPER_LANGUAGE", pluginName: "@openacp/speech", key: "localWhisperLanguage" },
+          { envVar: "OPENACP_SPEECH_LOCAL_WHISPER_MODEL", pluginName: "@openacp/speech", key: "localWhisperModel" },
+          { envVar: "OPENACP_SPEECH_LOCAL_WHISPER_BEAM_SIZE", pluginName: "@openacp/speech", key: "localWhisperBeamSize", transform: (v) => Number(v) },
+          { envVar: "OPENACP_SPEECH_LOCAL_WHISPER_VAD_FILTER", pluginName: "@openacp/speech", key: "localWhisperVadFilter", transform: (v) => v === "true" },
+          { envVar: "OPENACP_SPEECH_LOCAL_WHISPER_DEVICE", pluginName: "@openacp/speech", key: "localWhisperDevice" },
+          { envVar: "OPENACP_SPEECH_LOCAL_WHISPER_COMPUTE_TYPE", pluginName: "@openacp/speech", key: "localWhisperComputeType" },
+          { envVar: "OPENACP_SPEECH_LOCAL_WHISPER_TIMEOUT_MS", pluginName: "@openacp/speech", key: "localWhisperTimeoutMs", transform: (v) => Number(v) },
+          { envVar: "OPENACP_SPEECH_LOCAL_WHISPER_SCRIPT_PATH", pluginName: "@openacp/speech", key: "localWhisperScriptPath" },
           { envVar: "OPENACP_TELEGRAM_BOT_TOKEN", pluginName: "@openacp/telegram", key: "botToken" },
           { envVar: "OPENACP_TELEGRAM_CHAT_ID", pluginName: "@openacp/telegram", key: "chatId", transform: (v) => Number(v) },
           // Future adapters — no-ops if plugin settings don't exist
@@ -11131,7 +11362,7 @@ var plugins_exports = {};
 __export(plugins_exports, {
   pluginRoutes: () => pluginRoutes
 });
-import path23 from "path";
+import path24 from "path";
 async function pluginRoutes(app, deps) {
   const { lifecycleManager } = deps;
   const admin = [requireScopes("system:admin")];
@@ -11196,7 +11427,7 @@ async function pluginRoutes(app, deps) {
       } else {
         const { importFromDir: importFromDir2 } = await Promise.resolve().then(() => (init_plugin_installer(), plugin_installer_exports));
         const instanceRoot = lifecycleManager.instanceRoot;
-        const pluginsDir = path23.join(instanceRoot, "plugins");
+        const pluginsDir = path24.join(instanceRoot, "plugins");
         try {
           const mod = await importFromDir2(name, pluginsDir);
           pluginDef = mod.default ?? mod;
@@ -11272,11 +11503,11 @@ __export(instance_registry_exports, {
   readIdFromConfig: () => readIdFromConfig
 });
 import fs20 from "fs";
-import path24 from "path";
+import path25 from "path";
 import { randomUUID } from "crypto";
 function readIdFromConfig(instanceRoot) {
   try {
-    const raw = JSON.parse(fs20.readFileSync(path24.join(instanceRoot, "config.json"), "utf-8"));
+    const raw = JSON.parse(fs20.readFileSync(path25.join(instanceRoot, "config.json"), "utf-8"));
     return typeof raw.id === "string" && raw.id ? raw.id : null;
   } catch {
     return null;
@@ -11322,7 +11553,7 @@ var init_instance_registry = __esm({
       }
       /** Persist the registry to disk, creating parent directories if needed. */
       save() {
-        const dir = path24.dirname(this.registryPath);
+        const dir = path25.dirname(this.registryPath);
         fs20.mkdirSync(dir, { recursive: true });
         fs20.writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));
       }
@@ -11392,7 +11623,7 @@ __export(instance_context_exports, {
   resolveInstanceRoot: () => resolveInstanceRoot,
   resolveRunningInstance: () => resolveRunningInstance
 });
-import path25 from "path";
+import path26 from "path";
 import fs21 from "fs";
 import os6 from "os";
 function createInstanceContext(opts) {
@@ -11402,22 +11633,22 @@ function createInstanceContext(opts) {
     id,
     root,
     paths: {
-      config: path25.join(root, "config.json"),
-      sessions: path25.join(root, "sessions.json"),
-      agents: path25.join(root, "agents.json"),
-      registryCache: path25.join(globalRoot, "cache", "registry-cache.json"),
-      plugins: path25.join(root, "plugins"),
-      pluginsData: path25.join(root, "plugins", "data"),
-      pluginRegistry: path25.join(root, "plugins.json"),
-      logs: path25.join(root, "logs"),
-      pid: path25.join(root, "openacp.pid"),
-      running: path25.join(root, "running"),
-      apiPort: path25.join(root, "api.port"),
-      apiSecret: path25.join(root, "api-secret"),
-      bin: path25.join(globalRoot, "bin"),
-      cache: path25.join(root, "cache"),
-      tunnels: path25.join(root, "tunnels.json"),
-      agentsDir: path25.join(globalRoot, "agents")
+      config: path26.join(root, "config.json"),
+      sessions: path26.join(root, "sessions.json"),
+      agents: path26.join(root, "agents.json"),
+      registryCache: path26.join(globalRoot, "cache", "registry-cache.json"),
+      plugins: path26.join(root, "plugins"),
+      pluginsData: path26.join(root, "plugins", "data"),
+      pluginRegistry: path26.join(root, "plugins.json"),
+      logs: path26.join(root, "logs"),
+      pid: path26.join(root, "openacp.pid"),
+      running: path26.join(root, "running"),
+      apiPort: path26.join(root, "api.port"),
+      apiSecret: path26.join(root, "api-secret"),
+      bin: path26.join(globalRoot, "bin"),
+      cache: path26.join(root, "cache"),
+      tunnels: path26.join(root, "tunnels.json"),
+      agentsDir: path26.join(globalRoot, "agents")
     }
   };
 }
@@ -11426,50 +11657,50 @@ function generateSlug(name) {
   return slug || "openacp";
 }
 function expandHome3(p2) {
-  if (p2.startsWith("~")) return path25.join(os6.homedir(), p2.slice(1));
+  if (p2.startsWith("~")) return path26.join(os6.homedir(), p2.slice(1));
   return p2;
 }
 function resolveInstanceRoot(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const home = os6.homedir();
   const globalRoot = getGlobalRoot();
-  if (opts.dir) return path25.join(expandHome3(opts.dir), ".openacp");
-  if (opts.local) return path25.join(cwd, ".openacp");
-  const cwdRoot = path25.join(cwd, ".openacp");
-  if (fs21.existsSync(path25.join(cwdRoot, "config.json"))) return cwdRoot;
-  let dir = path25.resolve(cwd);
+  if (opts.dir) return path26.join(expandHome3(opts.dir), ".openacp");
+  if (opts.local) return path26.join(cwd, ".openacp");
+  const cwdRoot = path26.join(cwd, ".openacp");
+  if (fs21.existsSync(path26.join(cwdRoot, "config.json"))) return cwdRoot;
+  let dir = path26.resolve(cwd);
   while (true) {
-    const parent = path25.dirname(dir);
+    const parent = path26.dirname(dir);
     if (parent === dir) break;
     dir = parent;
-    const candidate = path25.join(dir, ".openacp");
+    const candidate = path26.join(dir, ".openacp");
     if (candidate === globalRoot) {
       if (dir === home) break;
       continue;
     }
-    if (fs21.existsSync(path25.join(candidate, "config.json"))) return candidate;
+    if (fs21.existsSync(path26.join(candidate, "config.json"))) return candidate;
     if (dir === home) break;
   }
-  if (path25.resolve(cwd) === path25.resolve(home)) {
-    const defaultWs = path25.join(home, "openacp-workspace", ".openacp");
-    if (fs21.existsSync(path25.join(defaultWs, "config.json"))) return defaultWs;
+  if (path26.resolve(cwd) === path26.resolve(home)) {
+    const defaultWs = path26.join(home, "openacp-workspace", ".openacp");
+    if (fs21.existsSync(path26.join(defaultWs, "config.json"))) return defaultWs;
   }
   if (process.env.OPENACP_INSTANCE_ROOT) return process.env.OPENACP_INSTANCE_ROOT;
   return null;
 }
 function getGlobalRoot() {
-  return path25.join(os6.homedir(), ".openacp");
+  return path26.join(os6.homedir(), ".openacp");
 }
 async function resolveRunningInstance(cwd) {
   const globalRoot = getGlobalRoot();
   const home = os6.homedir();
-  let dir = path25.resolve(cwd);
+  let dir = path26.resolve(cwd);
   while (true) {
-    const candidate = path25.join(dir, ".openacp");
+    const candidate = path26.join(dir, ".openacp");
     if (candidate !== globalRoot && fs21.existsSync(candidate)) {
       if (await isInstanceRunning(candidate)) return candidate;
     }
-    const parent = path25.dirname(dir);
+    const parent = path26.dirname(dir);
     if (parent === dir) break;
     if (dir === home) break;
     dir = parent;
@@ -11477,7 +11708,7 @@ async function resolveRunningInstance(cwd) {
   return null;
 }
 async function isInstanceRunning(instanceRoot) {
-  const portFile = path25.join(instanceRoot, "api.port");
+  const portFile = path26.join(instanceRoot, "api.port");
   try {
     const content = fs21.readFileSync(portFile, "utf-8").trim();
     const port = parseInt(content, 10);
@@ -11506,14 +11737,14 @@ __export(api_server_exports, {
 });
 import * as fs22 from "fs";
 import * as crypto3 from "crypto";
-import * as path26 from "path";
+import * as path27 from "path";
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   cachedVersion = getCurrentVersion();
   return cachedVersion;
 }
 function loadOrCreateSecret(secretFilePath) {
-  const dir = path26.dirname(secretFilePath);
+  const dir = path27.dirname(secretFilePath);
   fs22.mkdirSync(dir, { recursive: true });
   try {
     const existing = fs22.readFileSync(secretFilePath, "utf-8").trim();
@@ -11539,7 +11770,7 @@ function loadOrCreateSecret(secretFilePath) {
   return secret;
 }
 function writePortFile(portFilePath, port) {
-  const dir = path26.dirname(portFilePath);
+  const dir = path27.dirname(portFilePath);
   fs22.mkdirSync(dir, { recursive: true });
   fs22.writeFileSync(portFilePath, String(port));
 }
@@ -11624,10 +11855,10 @@ function createApiServerPlugin() {
         { port: apiConfig.port, host: apiConfig.host, instanceRoot },
         "API server plugin setup \u2014 config loaded"
       );
-      portFilePath = path26.join(instanceRoot, "api.port");
-      const secretFilePath = path26.join(instanceRoot, "api-secret");
-      const jwtSecretFilePath = path26.join(instanceRoot, "jwt-secret");
-      const tokensFilePath = path26.join(instanceRoot, "tokens.json");
+      portFilePath = path27.join(instanceRoot, "api.port");
+      const secretFilePath = path27.join(instanceRoot, "api-secret");
+      const jwtSecretFilePath = path27.join(instanceRoot, "jwt-secret");
+      const tokensFilePath = path27.join(instanceRoot, "tokens.json");
       const startedAt = Date.now();
       const secret = loadOrCreateSecret(secretFilePath);
       const jwtSecret = loadOrCreateSecret(jwtSecretFilePath);
@@ -11666,7 +11897,7 @@ function createApiServerPlugin() {
       const { InstanceRegistry: InstanceRegistry2 } = await Promise.resolve().then(() => (init_instance_registry(), instance_registry_exports));
       const { getGlobalRoot: getGlobalRoot2 } = await Promise.resolve().then(() => (init_instance_context(), instance_context_exports));
       const globalRoot = getGlobalRoot2();
-      const instanceReg = new InstanceRegistry2(path26.join(globalRoot, "instances.json"));
+      const instanceReg = new InstanceRegistry2(path27.join(globalRoot, "instances.json"));
       instanceReg.load();
       const instanceEntry = instanceReg.getByRoot(instanceRoot);
       const workspaceId = instanceEntry?.id ?? "main";
@@ -11698,7 +11929,7 @@ function createApiServerPlugin() {
       server.registerPlugin("/api/v1/plugins", async (app) => pluginRoutes2(app, deps));
       const appConfig = core.configManager.get();
       const workspaceName = appConfig.instanceName ?? "Main";
-      const workspaceDir = path26.dirname(instanceRoot);
+      const workspaceDir = path27.dirname(instanceRoot);
       server.registerPlugin("/api/v1", async (app) => {
         await app.register(workspaceRoute2, {
           id: workspaceId,
@@ -12792,8 +13023,8 @@ function formatToolSummary(name, rawInput, displaySummary) {
   }
   if (lowerName === "grep") {
     const pattern = args2.pattern ?? "";
-    const path71 = args2.path ?? "";
-    return pattern ? `\u{1F50D} Grep "${pattern}"${path71 ? ` in ${path71}` : ""}` : `\u{1F527} ${name}`;
+    const path72 = args2.path ?? "";
+    return pattern ? `\u{1F50D} Grep "${pattern}"${path72 ? ` in ${path72}` : ""}` : `\u{1F527} ${name}`;
   }
   if (lowerName === "glob") {
     const pattern = args2.pattern ?? "";
@@ -12829,8 +13060,8 @@ function formatToolTitle(name, rawInput, displayTitle) {
   }
   if (lowerName === "grep") {
     const pattern = args2.pattern ?? "";
-    const path71 = args2.path ?? "";
-    return pattern ? `"${pattern}"${path71 ? ` in ${path71}` : ""}` : name;
+    const path72 = args2.path ?? "";
+    return pattern ? `"${pattern}"${path72 ? ` in ${path72}` : ""}` : name;
   }
   if (lowerName === "glob") {
     return String(args2.pattern ?? name);
@@ -13973,7 +14204,7 @@ __export(integrate_exports, {
   listIntegrations: () => listIntegrations,
   uninstallIntegration: () => uninstallIntegration
 });
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5, unlinkSync as unlinkSync4, chmodSync, rmdirSync } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5, unlinkSync as unlinkSync4, chmodSync, rmdirSync } from "fs";
 import { join as join10, dirname as dirname7 } from "path";
 import { homedir as homedir3 } from "os";
 function isHooksIntegrationSpec(spec) {
@@ -14135,7 +14366,7 @@ function generateOpencodePlugin(spec) {
 function mergeSettingsJson(settingsPath, hookEvent, hookScriptPath) {
   const fullPath = expandPath(settingsPath);
   let settings = {};
-  if (existsSync6(fullPath)) {
+  if (existsSync7(fullPath)) {
     const raw = readFileSync5(fullPath, "utf-8");
     writeFileSync5(`${fullPath}.bak`, raw);
     settings = JSON.parse(raw);
@@ -14158,7 +14389,7 @@ function mergeSettingsJson(settingsPath, hookEvent, hookScriptPath) {
 function mergeHooksJson(settingsPath, hookEvent, hookScriptPath) {
   const fullPath = expandPath(settingsPath);
   let config = { version: 1 };
-  if (existsSync6(fullPath)) {
+  if (existsSync7(fullPath)) {
     const raw = readFileSync5(fullPath, "utf-8");
     writeFileSync5(`${fullPath}.bak`, raw);
     config = JSON.parse(raw);
@@ -14176,7 +14407,7 @@ function mergeHooksJson(settingsPath, hookEvent, hookScriptPath) {
 }
 function removeFromSettingsJson(settingsPath, hookEvent) {
   const fullPath = expandPath(settingsPath);
-  if (!existsSync6(fullPath)) return;
+  if (!existsSync7(fullPath)) return;
   const raw = readFileSync5(fullPath, "utf-8");
   const settings = JSON.parse(raw);
   const hooks = settings.hooks;
@@ -14191,7 +14422,7 @@ function removeFromSettingsJson(settingsPath, hookEvent) {
 }
 function removeFromHooksJson(settingsPath, hookEvent) {
   const fullPath = expandPath(settingsPath);
-  if (!existsSync6(fullPath)) return;
+  if (!existsSync7(fullPath)) return;
   const raw = readFileSync5(fullPath, "utf-8");
   const config = JSON.parse(raw);
   const hooks = config.hooks;
@@ -14257,7 +14488,7 @@ async function uninstallHooksIntegration(agentKey, spec) {
     const hooksDir = expandPath(spec.hooksDirPath);
     for (const filename of ["openacp-inject-session.sh", "openacp-handoff.sh"]) {
       const filePath = join10(hooksDir, filename);
-      if (existsSync6(filePath)) {
+      if (existsSync7(filePath)) {
         unlinkSync4(filePath);
         logs.push(`Removed ${filePath}`);
       }
@@ -14266,7 +14497,7 @@ async function uninstallHooksIntegration(agentKey, spec) {
       if (spec.commandFormat === "skill") {
         const skillDir = expandPath(join10(spec.commandsPath, spec.handoffCommandName));
         const skillPath = join10(skillDir, "SKILL.md");
-        if (existsSync6(skillPath)) {
+        if (existsSync7(skillPath)) {
           unlinkSync4(skillPath);
           try {
             rmdirSync(skillDir);
@@ -14276,7 +14507,7 @@ async function uninstallHooksIntegration(agentKey, spec) {
         }
       } else {
         const cmdPath = expandPath(join10(spec.commandsPath, `${spec.handoffCommandName}.md`));
-        if (existsSync6(cmdPath)) {
+        if (existsSync7(cmdPath)) {
           unlinkSync4(cmdPath);
           logs.push(`Removed ${cmdPath}`);
         }
@@ -14303,11 +14534,11 @@ async function installPluginIntegration(_agentKey, spec) {
     const pluginsDir = expandPath(spec.pluginsPath);
     mkdirSync5(pluginsDir, { recursive: true });
     const pluginPath = join10(pluginsDir, spec.pluginFileName);
-    if (existsSync6(commandPath) && existsSync6(pluginPath)) {
+    if (existsSync7(commandPath) && existsSync7(pluginPath)) {
       logs.push("Already installed, skipping.");
       return { success: true, logs };
     }
-    if (existsSync6(commandPath) || existsSync6(pluginPath)) {
+    if (existsSync7(commandPath) || existsSync7(pluginPath)) {
       logs.push("Overwriting existing files.");
     }
     writeFileSync5(commandPath, generateOpencodeHandoffCommand(spec));
@@ -14325,13 +14556,13 @@ async function uninstallPluginIntegration(_agentKey, spec) {
   try {
     const commandPath = join10(expandPath(spec.commandsPath), spec.handoffCommandFile);
     let removedCount = 0;
-    if (existsSync6(commandPath)) {
+    if (existsSync7(commandPath)) {
       unlinkSync4(commandPath);
       logs.push(`Removed ${commandPath}`);
       removedCount += 1;
     }
     const pluginPath = join10(expandPath(spec.pluginsPath), spec.pluginFileName);
-    if (existsSync6(pluginPath)) {
+    if (existsSync7(pluginPath)) {
       unlinkSync4(pluginPath);
       logs.push(`Removed ${pluginPath}`);
       removedCount += 1;
@@ -14365,11 +14596,11 @@ function buildHandoffItem(agentKey, spec) {
     isInstalled() {
       if (isHooksIntegrationSpec(spec)) {
         const hooksDir = expandPath(spec.hooksDirPath);
-        return existsSync6(join10(hooksDir, "openacp-inject-session.sh")) && existsSync6(join10(hooksDir, "openacp-handoff.sh"));
+        return existsSync7(join10(hooksDir, "openacp-inject-session.sh")) && existsSync7(join10(hooksDir, "openacp-handoff.sh"));
       }
       const commandPath = join10(expandPath(spec.commandsPath), spec.handoffCommandFile);
       const pluginPath = join10(expandPath(spec.pluginsPath), spec.pluginFileName);
-      return existsSync6(commandPath) && existsSync6(pluginPath);
+      return existsSync7(commandPath) && existsSync7(pluginPath);
     },
     install: () => installIntegration(agentKey, spec),
     uninstall: () => uninstallIntegration(agentKey, spec)
@@ -14391,7 +14622,7 @@ function buildTunnelItem(spec) {
     name: "Tunnel",
     description: "Expose local ports to the internet via OpenACP tunnel",
     isInstalled() {
-      return existsSync6(getTunnelPath());
+      return existsSync7(getTunnelPath());
     },
     async install() {
       const logs = [];
@@ -14410,7 +14641,7 @@ function buildTunnelItem(spec) {
       const logs = [];
       try {
         const skillPath = getTunnelPath();
-        if (existsSync6(skillPath)) {
+        if (existsSync7(skillPath)) {
           unlinkSync4(skillPath);
           try {
             rmdirSync(dirname7(skillPath));
@@ -15173,7 +15404,7 @@ var init_config4 = __esm({
 // src/core/doctor/checks/agents.ts
 import { execFileSync as execFileSync4 } from "child_process";
 import * as fs24 from "fs";
-import * as path27 from "path";
+import * as path28 from "path";
 function commandExists2(cmd) {
   try {
     execFileSync4("which", [cmd], { stdio: "pipe" });
@@ -15182,9 +15413,9 @@ function commandExists2(cmd) {
   }
   let dir = process.cwd();
   while (true) {
-    const binPath = path27.join(dir, "node_modules", ".bin", cmd);
+    const binPath = path28.join(dir, "node_modules", ".bin", cmd);
     if (fs24.existsSync(binPath)) return true;
-    const parent = path27.dirname(dir);
+    const parent = path28.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -15206,7 +15437,7 @@ var init_agents3 = __esm({
         const defaultAgent = ctx.config.defaultAgent;
         let agents = {};
         try {
-          const agentsPath = path27.join(ctx.dataDir, "agents.json");
+          const agentsPath = path28.join(ctx.dataDir, "agents.json");
           if (fs24.existsSync(agentsPath)) {
             const data = JSON.parse(fs24.readFileSync(agentsPath, "utf-8"));
             agents = data.installed ?? {};
@@ -15247,7 +15478,7 @@ __export(settings_manager_exports, {
   SettingsManager: () => SettingsManager
 });
 import fs25 from "fs";
-import path28 from "path";
+import path29 from "path";
 var SettingsManager, SettingsAPIImpl;
 var init_settings_manager = __esm({
   "src/core/plugin/settings-manager.ts"() {
@@ -15290,7 +15521,7 @@ var init_settings_manager = __esm({
       }
       /** Resolve the absolute path to a plugin's settings.json file. */
       getSettingsPath(pluginName) {
-        return path28.join(this.basePath, pluginName, "settings.json");
+        return path29.join(this.basePath, pluginName, "settings.json");
       }
       async getPluginSettings(pluginName) {
         return this.loadSettings(pluginName);
@@ -15320,7 +15551,7 @@ var init_settings_manager = __esm({
         }
       }
       writeFile(data) {
-        const dir = path28.dirname(this.settingsPath);
+        const dir = path29.dirname(this.settingsPath);
         fs25.mkdirSync(dir, { recursive: true });
         fs25.writeFileSync(this.settingsPath, JSON.stringify(data, null, 2));
         this.cache = data;
@@ -15357,7 +15588,7 @@ var init_settings_manager = __esm({
 });
 
 // src/core/doctor/checks/telegram.ts
-import * as path29 from "path";
+import * as path30 from "path";
 var BOT_TOKEN_REGEX, telegramCheck;
 var init_telegram = __esm({
   "src/core/doctor/checks/telegram.ts"() {
@@ -15373,7 +15604,7 @@ var init_telegram = __esm({
           return results;
         }
         const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
-        const sm = new SettingsManager2(path29.join(ctx.pluginsDir, "data"));
+        const sm = new SettingsManager2(path30.join(ctx.pluginsDir, "data"));
         const ps = await sm.loadSettings("@openacp/telegram");
         const botToken = ps.botToken;
         const chatId = ps.chatId;
@@ -15545,7 +15776,7 @@ var init_storage = __esm({
 
 // src/core/doctor/checks/workspace.ts
 import * as fs27 from "fs";
-import * as path30 from "path";
+import * as path31 from "path";
 var workspaceCheck;
 var init_workspace2 = __esm({
   "src/core/doctor/checks/workspace.ts"() {
@@ -15555,7 +15786,7 @@ var init_workspace2 = __esm({
       order: 5,
       async run(ctx) {
         const results = [];
-        const workspace = path30.dirname(ctx.dataDir);
+        const workspace = path31.dirname(ctx.dataDir);
         if (!fs27.existsSync(workspace)) {
           results.push({
             status: "warn",
@@ -15583,7 +15814,7 @@ var init_workspace2 = __esm({
 
 // src/core/doctor/checks/plugins.ts
 import * as fs28 from "fs";
-import * as path31 from "path";
+import * as path32 from "path";
 var pluginsCheck;
 var init_plugins2 = __esm({
   "src/core/doctor/checks/plugins.ts"() {
@@ -15602,7 +15833,7 @@ var init_plugins2 = __esm({
             fix: async () => {
               fs28.mkdirSync(ctx.pluginsDir, { recursive: true });
               fs28.writeFileSync(
-                path31.join(ctx.pluginsDir, "package.json"),
+                path32.join(ctx.pluginsDir, "package.json"),
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
               return { success: true, message: "initialized plugins directory" };
@@ -15611,7 +15842,7 @@ var init_plugins2 = __esm({
           return results;
         }
         results.push({ status: "pass", message: "Plugins directory exists" });
-        const pkgPath = path31.join(ctx.pluginsDir, "package.json");
+        const pkgPath = path32.join(ctx.pluginsDir, "package.json");
         if (!fs28.existsSync(pkgPath)) {
           results.push({
             status: "warn",
@@ -15758,7 +15989,7 @@ var init_daemon = __esm({
 
 // src/core/doctor/checks/tunnel.ts
 import * as fs30 from "fs";
-import * as path32 from "path";
+import * as path33 from "path";
 import * as os7 from "os";
 import { execFileSync as execFileSync5 } from "child_process";
 var tunnelCheck;
@@ -15775,7 +16006,7 @@ var init_tunnel3 = __esm({
           return results;
         }
         const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
-        const sm = new SettingsManager2(path32.join(ctx.pluginsDir, "data"));
+        const sm = new SettingsManager2(path33.join(ctx.pluginsDir, "data"));
         const tunnelSettings = await sm.loadSettings("@openacp/tunnel");
         const tunnelEnabled = tunnelSettings.enabled ?? false;
         const provider = tunnelSettings.provider ?? "cloudflare";
@@ -15787,7 +16018,7 @@ var init_tunnel3 = __esm({
         results.push({ status: "pass", message: `Tunnel provider: ${provider}` });
         if (provider === "cloudflare") {
           const binName = os7.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
-          const binPath = path32.join(ctx.dataDir, "bin", binName);
+          const binPath = path33.join(ctx.dataDir, "bin", binName);
           let found = false;
           if (fs30.existsSync(binPath)) {
             found = true;
@@ -15835,7 +16066,7 @@ __export(doctor_exports, {
   DoctorEngine: () => DoctorEngine
 });
 import * as fs31 from "fs";
-import * as path33 from "path";
+import * as path34 from "path";
 var ALL_CHECKS, CHECK_TIMEOUT_MS, DoctorEngine;
 var init_doctor = __esm({
   "src/core/doctor/index.ts"() {
@@ -15923,7 +16154,7 @@ var init_doctor = __esm({
       /** Constructs the shared context used by all checks — loads config if available. */
       async buildContext() {
         const dataDir = this.dataDir;
-        const configPath = process.env.OPENACP_CONFIG_PATH || path33.join(dataDir, "config.json");
+        const configPath = process.env.OPENACP_CONFIG_PATH || path34.join(dataDir, "config.json");
         let config = null;
         let rawConfig = null;
         try {
@@ -15934,16 +16165,16 @@ var init_doctor = __esm({
           config = cm.get();
         } catch {
         }
-        const logsDir = config ? expandHome2(config.logging.logDir) : path33.join(dataDir, "logs");
+        const logsDir = config ? expandHome2(config.logging.logDir) : path34.join(dataDir, "logs");
         return {
           config,
           rawConfig,
           configPath,
           dataDir,
-          sessionsPath: path33.join(dataDir, "sessions.json"),
-          pidPath: path33.join(dataDir, "openacp.pid"),
-          portFilePath: path33.join(dataDir, "api.port"),
-          pluginsDir: path33.join(dataDir, "plugins"),
+          sessionsPath: path34.join(dataDir, "sessions.json"),
+          pidPath: path34.join(dataDir, "openacp.pid"),
+          portFilePath: path34.join(dataDir, "api.port"),
+          pluginsDir: path34.join(dataDir, "plugins"),
           logsDir
         };
       }
@@ -20500,10 +20731,10 @@ var install_context_exports = {};
 __export(install_context_exports, {
   createInstallContext: () => createInstallContext
 });
-import path34 from "path";
+import path35 from "path";
 function createInstallContext(opts) {
   const { pluginName, settingsManager, basePath, instanceRoot } = opts;
-  const dataDir = path34.join(basePath, pluginName, "data");
+  const dataDir = path35.join(basePath, pluginName, "data");
   return {
     pluginName,
     terminal: createTerminalIO(),
@@ -20531,13 +20762,13 @@ __export(api_client_exports, {
   waitForPortFile: () => waitForPortFile
 });
 import * as fs33 from "fs";
-import * as path36 from "path";
+import * as path37 from "path";
 import { setTimeout as sleep } from "timers/promises";
 function defaultPortFile(root) {
-  return path36.join(root, "api.port");
+  return path37.join(root, "api.port");
 }
 function defaultSecretFile(root) {
-  return path36.join(root, "api-secret");
+  return path37.join(root, "api-secret");
 }
 async function waitForPortFile(portFilePath, timeoutMs = 5e3, intervalMs = 100) {
   const deadline = Date.now() + timeoutMs;
@@ -20632,9 +20863,9 @@ var init_suggest = __esm({
 
 // src/cli/instance-hint.ts
 import os8 from "os";
-import path37 from "path";
+import path38 from "path";
 function printInstanceHint(root) {
-  const workspaceDir = path37.dirname(root);
+  const workspaceDir = path38.dirname(root);
   const displayPath = workspaceDir.replace(os8.homedir(), "~");
   console.log(`  Workspace: ${displayPath}`);
 }
@@ -20650,23 +20881,23 @@ __export(resolve_instance_id_exports, {
   resolveInstanceId: () => resolveInstanceId
 });
 import fs34 from "fs";
-import path38 from "path";
+import path39 from "path";
 function resolveInstanceId(instanceRoot) {
   try {
-    const configPath = path38.join(instanceRoot, "config.json");
+    const configPath = path39.join(instanceRoot, "config.json");
     const raw = JSON.parse(fs34.readFileSync(configPath, "utf-8"));
     if (raw.id && typeof raw.id === "string") return raw.id;
   } catch {
   }
   try {
-    const reg = new InstanceRegistry(path38.join(getGlobalRoot(), "instances.json"));
+    const reg = new InstanceRegistry(path39.join(getGlobalRoot(), "instances.json"));
     reg.load();
     const entry = reg.getByRoot(instanceRoot);
     if (entry?.id) return entry.id;
   } catch (err) {
     log31.debug({ err: err.message, instanceRoot }, "Could not read instance registry, using fallback id");
   }
-  return path38.basename(path38.dirname(instanceRoot)).replace(/[^a-zA-Z0-9-]/g, "-") || "default";
+  return path39.basename(path39.dirname(instanceRoot)).replace(/[^a-zA-Z0-9-]/g, "-") || "default";
 }
 var log31;
 var init_resolve_instance_id = __esm({
@@ -20698,18 +20929,18 @@ __export(daemon_exports, {
 });
 import { spawn as spawn6 } from "child_process";
 import * as fs35 from "fs";
-import * as path39 from "path";
+import * as path40 from "path";
 function getPidPath(root) {
-  return path39.join(root, "openacp.pid");
+  return path40.join(root, "openacp.pid");
 }
 function getLogDir(root) {
-  return path39.join(root, "logs");
+  return path40.join(root, "logs");
 }
 function getRunningMarker(root) {
-  return path39.join(root, "running");
+  return path40.join(root, "running");
 }
 function writePidFile(pidPath, pid) {
-  const dir = path39.dirname(pidPath);
+  const dir = path40.dirname(pidPath);
   fs35.mkdirSync(dir, { recursive: true });
   fs35.writeFileSync(pidPath, String(pid));
 }
@@ -20758,8 +20989,8 @@ function startDaemon(pidPath, logDir2, instanceRoot) {
   }
   const resolvedLogDir = logDir2 ? expandHome2(logDir2) : getLogDir(instanceRoot);
   fs35.mkdirSync(resolvedLogDir, { recursive: true });
-  const logFile = path39.join(resolvedLogDir, "openacp.log");
-  const cliPath = path39.resolve(process.argv[1]);
+  const logFile = path40.join(resolvedLogDir, "openacp.log");
+  const cliPath = path40.resolve(process.argv[1]);
   const nodePath = process.execPath;
   const out = fs35.openSync(logFile, "a");
   const err = fs35.openSync(logFile, "a");
@@ -20843,7 +21074,7 @@ async function stopDaemon(pidPath, instanceRoot) {
 }
 function markRunning(root) {
   const marker = getRunningMarker(root);
-  fs35.mkdirSync(path39.dirname(marker), { recursive: true });
+  fs35.mkdirSync(path40.dirname(marker), { recursive: true });
   fs35.writeFileSync(marker, "");
 }
 function clearRunning(root) {
@@ -20876,19 +21107,19 @@ __export(autostart_exports, {
 });
 import { execFileSync as execFileSync6 } from "child_process";
 import * as fs36 from "fs";
-import * as path40 from "path";
+import * as path41 from "path";
 import * as os9 from "os";
 function getLaunchdLabel(instanceId) {
   return `com.openacp.daemon.${instanceId}`;
 }
 function getLaunchdPlistPath(instanceId) {
-  return path40.join(os9.homedir(), "Library", "LaunchAgents", `${getLaunchdLabel(instanceId)}.plist`);
+  return path41.join(os9.homedir(), "Library", "LaunchAgents", `${getLaunchdLabel(instanceId)}.plist`);
 }
 function getSystemdServiceName(instanceId) {
   return `openacp-${instanceId}`;
 }
 function getSystemdServicePath(instanceId) {
-  return path40.join(os9.homedir(), ".config", "systemd", "user", `${getSystemdServiceName(instanceId)}.service`);
+  return path41.join(os9.homedir(), ".config", "systemd", "user", `${getSystemdServiceName(instanceId)}.service`);
 }
 function isAutoStartSupported() {
   return process.platform === "darwin" || process.platform === "linux";
@@ -20902,7 +21133,7 @@ function escapeSystemdValue(str) {
 }
 function generateLaunchdPlist(nodePath, cliPath, logDir2, instanceRoot, instanceId) {
   const label = getLaunchdLabel(instanceId);
-  const logFile = path40.join(logDir2, "openacp.log");
+  const logFile = path41.join(logDir2, "openacp.log");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -20984,14 +21215,14 @@ function installAutoStart(logDir2, instanceRoot, instanceId) {
     return { success: false, error: "Auto-start not supported on this platform" };
   }
   const nodePath = process.execPath;
-  const cliPath = path40.resolve(process.argv[1]);
-  const resolvedLogDir = logDir2.startsWith("~") ? path40.join(os9.homedir(), logDir2.slice(1)) : logDir2;
+  const cliPath = path41.resolve(process.argv[1]);
+  const resolvedLogDir = logDir2.startsWith("~") ? path41.join(os9.homedir(), logDir2.slice(1)) : logDir2;
   try {
     migrateLegacy();
     if (process.platform === "darwin") {
       const plistPath = getLaunchdPlistPath(instanceId);
       const plist = generateLaunchdPlist(nodePath, cliPath, resolvedLogDir, instanceRoot, instanceId);
-      const dir = path40.dirname(plistPath);
+      const dir = path41.dirname(plistPath);
       fs36.mkdirSync(dir, { recursive: true });
       fs36.writeFileSync(plistPath, plist);
       const uid = process.getuid();
@@ -21008,7 +21239,7 @@ function installAutoStart(logDir2, instanceRoot, instanceId) {
       const servicePath = getSystemdServicePath(instanceId);
       const serviceName = getSystemdServiceName(instanceId);
       const unit = generateSystemdUnit(nodePath, cliPath, instanceRoot, instanceId);
-      const dir = path40.dirname(servicePath);
+      const dir = path41.dirname(servicePath);
       fs36.mkdirSync(dir, { recursive: true });
       fs36.writeFileSync(servicePath, unit);
       execFileSync6("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
@@ -21077,8 +21308,8 @@ var init_autostart = __esm({
     "use strict";
     init_log();
     log32 = createChildLogger({ module: "autostart" });
-    LEGACY_LAUNCHD_PLIST_PATH = path40.join(os9.homedir(), "Library", "LaunchAgents", "com.openacp.daemon.plist");
-    LEGACY_SYSTEMD_SERVICE_PATH = path40.join(os9.homedir(), ".config", "systemd", "user", "openacp.service");
+    LEGACY_LAUNCHD_PLIST_PATH = path41.join(os9.homedir(), "Library", "LaunchAgents", "com.openacp.daemon.plist");
+    LEGACY_SYSTEMD_SERVICE_PATH = path41.join(os9.homedir(), ".config", "systemd", "user", "openacp.service");
   }
 });
 
@@ -21133,7 +21364,7 @@ var init_stop = __esm({
 
 // src/core/security/path-guard.ts
 import fs37 from "fs";
-import path42 from "path";
+import path43 from "path";
 import ignore from "ignore";
 var DEFAULT_DENY_PATTERNS, PathGuard;
 var init_path_guard = __esm({
@@ -21162,15 +21393,15 @@ var init_path_guard = __esm({
       ig;
       constructor(options) {
         try {
-          this.cwd = fs37.realpathSync(path42.resolve(options.cwd));
+          this.cwd = fs37.realpathSync(path43.resolve(options.cwd));
         } catch {
-          this.cwd = path42.resolve(options.cwd);
+          this.cwd = path43.resolve(options.cwd);
         }
         this.allowedPaths = options.allowedPaths.map((p2) => {
           try {
-            return fs37.realpathSync(path42.resolve(p2));
+            return fs37.realpathSync(path43.resolve(p2));
           } catch {
-            return path42.resolve(p2);
+            return path43.resolve(p2);
           }
         });
         this.ig = ignore();
@@ -21194,19 +21425,19 @@ var init_path_guard = __esm({
        * @returns `{ allowed: true }` or `{ allowed: false, reason: "..." }`
        */
       validatePath(targetPath, operation) {
-        const resolved = path42.resolve(targetPath);
+        const resolved = path43.resolve(targetPath);
         let realPath;
         try {
           realPath = fs37.realpathSync(resolved);
         } catch {
           realPath = resolved;
         }
-        if (operation === "write" && path42.basename(realPath) === ".openacpignore") {
+        if (operation === "write" && path43.basename(realPath) === ".openacpignore") {
           return { allowed: false, reason: "Cannot write to .openacpignore" };
         }
-        const isWithinCwd = realPath === this.cwd || realPath.startsWith(this.cwd + path42.sep);
+        const isWithinCwd = realPath === this.cwd || realPath.startsWith(this.cwd + path43.sep);
         const isWithinAllowed = this.allowedPaths.some(
-          (ap) => realPath === ap || realPath.startsWith(ap + path42.sep)
+          (ap) => realPath === ap || realPath.startsWith(ap + path43.sep)
         );
         if (!isWithinCwd && !isWithinAllowed) {
           return {
@@ -21215,7 +21446,7 @@ var init_path_guard = __esm({
           };
         }
         if (isWithinCwd && !isWithinAllowed) {
-          const relativePath = path42.relative(this.cwd, realPath);
+          const relativePath = path43.relative(this.cwd, realPath);
           if (relativePath === ".openacpignore") {
             return { allowed: true, reason: "" };
           }
@@ -21231,9 +21462,9 @@ var init_path_guard = __esm({
       /** Adds an additional allowed path at runtime (e.g. for file-service uploads). */
       addAllowedPath(p2) {
         try {
-          this.allowedPaths.push(fs37.realpathSync(path42.resolve(p2)));
+          this.allowedPaths.push(fs37.realpathSync(path43.resolve(p2)));
         } catch {
-          this.allowedPaths.push(path42.resolve(p2));
+          this.allowedPaths.push(path43.resolve(p2));
         }
       }
       /**
@@ -21241,7 +21472,7 @@ var init_path_guard = __esm({
        * Follows .gitignore syntax — blank lines and lines starting with # are skipped.
        */
       static loadIgnoreFile(cwd) {
-        const ignorePath = path42.join(cwd, ".openacpignore");
+        const ignorePath = path43.join(cwd, ".openacpignore");
         try {
           const content = fs37.readFileSync(ignorePath, "utf-8");
           return content.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
@@ -21718,7 +21949,7 @@ var init_mcp_manager = __esm({
 
 // src/core/utils/debug-tracer.ts
 import fs38 from "fs";
-import path43 from "path";
+import path44 from "path";
 function createDebugTracer(sessionId, workingDirectory) {
   if (!DEBUG_ENABLED) return null;
   return new DebugTracer(sessionId, workingDirectory);
@@ -21732,7 +21963,7 @@ var init_debug_tracer = __esm({
       constructor(sessionId, workingDirectory) {
         this.sessionId = sessionId;
         this.workingDirectory = workingDirectory;
-        this.logDir = path43.join(workingDirectory, ".log");
+        this.logDir = path44.join(workingDirectory, ".log");
       }
       sessionId;
       workingDirectory;
@@ -21750,7 +21981,7 @@ var init_debug_tracer = __esm({
             fs38.mkdirSync(this.logDir, { recursive: true });
             this.dirCreated = true;
           }
-          const filePath = path43.join(this.logDir, `${this.sessionId}_${layer}.jsonl`);
+          const filePath = path44.join(this.logDir, `${this.sessionId}_${layer}.jsonl`);
           const seen = /* @__PURE__ */ new WeakSet();
           const line = JSON.stringify({ ts: Date.now(), ...data }, (_key, value) => {
             if (typeof value === "object" && value !== null) {
@@ -21774,21 +22005,21 @@ var init_debug_tracer = __esm({
 import { spawn as spawn8, execFileSync as execFileSync7 } from "child_process";
 import { Transform } from "stream";
 import fs39 from "fs";
-import path44 from "path";
+import path45 from "path";
 import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
 import { PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
 function findPackageRoot(startDir) {
   let dir = startDir;
-  while (dir !== path44.dirname(dir)) {
-    if (fs39.existsSync(path44.join(dir, "package.json"))) {
+  while (dir !== path45.dirname(dir)) {
+    if (fs39.existsSync(path45.join(dir, "package.json"))) {
       return dir;
     }
-    dir = path44.dirname(dir);
+    dir = path45.dirname(dir);
   }
   return startDir;
 }
 function commandForWindowsScript(filePath) {
-  const ext = path44.extname(filePath).toLowerCase();
+  const ext = path45.extname(filePath).toLowerCase();
   if (process.platform === "win32" && (ext === ".cmd" || ext === ".bat")) {
     return { command: process.env.ComSpec ?? "cmd.exe", args: ["/d", "/s", "/c", `"${filePath}"`] };
   }
@@ -21802,8 +22033,8 @@ function resolveAgentCommand(cmd) {
   }
   for (const root of searchRoots) {
     const packageDirs = [
-      path44.resolve(root, "node_modules", "@zed-industries", cmd, "dist", "index.js"),
-      path44.resolve(root, "node_modules", cmd, "dist", "index.js")
+      path45.resolve(root, "node_modules", "@zed-industries", cmd, "dist", "index.js"),
+      path45.resolve(root, "node_modules", cmd, "dist", "index.js")
     ];
     for (const jsPath of packageDirs) {
       if (fs39.existsSync(jsPath)) {
@@ -21812,7 +22043,7 @@ function resolveAgentCommand(cmd) {
     }
   }
   for (const root of searchRoots) {
-    const localBin = path44.resolve(root, "node_modules", ".bin", cmd);
+    const localBin = path45.resolve(root, "node_modules", ".bin", cmd);
     if (fs39.existsSync(localBin)) {
       const content = fs39.readFileSync(localBin, "utf-8");
       if (content.startsWith("#!/usr/bin/env node")) {
@@ -21820,7 +22051,7 @@ function resolveAgentCommand(cmd) {
       }
       const match = content.match(/"([^"]+\.js)"/);
       if (match) {
-        const target = path44.resolve(path44.dirname(localBin), match[1]);
+        const target = path45.resolve(path45.dirname(localBin), match[1]);
         if (fs39.existsSync(target)) {
           return { command: process.execPath, args: [target] };
         }
@@ -21836,9 +22067,9 @@ function resolveAgentCommand(cmd) {
         candidates.push(dir);
       }
     };
-    addCandidate(path44.dirname(process.execPath));
+    addCandidate(path45.dirname(process.execPath));
     try {
-      addCandidate(path44.dirname(fs39.realpathSync(process.execPath)));
+      addCandidate(path45.dirname(fs39.realpathSync(process.execPath)));
     } catch {
     }
     addCandidate("/opt/homebrew/bin");
@@ -21847,8 +22078,8 @@ function resolveAgentCommand(cmd) {
     for (const dir of candidates) {
       if (cmd === "npx") {
         const npxCliCandidates = [
-          path44.join(dir, "node_modules", "npm", "bin", "npx-cli.js"),
-          path44.join(path44.dirname(dir), "lib", "node_modules", "npm", "bin", "npx-cli.js")
+          path45.join(dir, "node_modules", "npm", "bin", "npx-cli.js"),
+          path45.join(path45.dirname(dir), "lib", "node_modules", "npm", "bin", "npx-cli.js")
         ];
         for (const npxCli of npxCliCandidates) {
           if (fs39.existsSync(npxCli)) {
@@ -21858,7 +22089,7 @@ function resolveAgentCommand(cmd) {
         }
       }
       for (const name of executableNames) {
-        const candidate = path44.join(dir, name);
+        const candidate = path45.join(dir, name);
         if (fs39.existsSync(candidate)) {
           const resolved = commandForWindowsScript(candidate);
           log33.info({ cmd, resolved: candidate }, "Resolved package runner from fallback search");
@@ -21870,7 +22101,7 @@ function resolveAgentCommand(cmd) {
   }
   try {
     const fullPath = execFileSync7("which", [cmd], { encoding: "utf-8" }).trim();
-    const isUnspawnableWindowsShim = process.platform === "win32" && (cmd === "npx" || cmd === "uvx") && !path44.extname(fullPath);
+    const isUnspawnableWindowsShim = process.platform === "win32" && (cmd === "npx" || cmd === "uvx") && !path45.extname(fullPath);
     if (fullPath && !isUnspawnableWindowsShim) {
       try {
         const content = fs39.readFileSync(fullPath, "utf-8");
@@ -22451,7 +22682,7 @@ ${stderr}`
               writePath = result.path;
               writeContent = result.content;
             }
-            await fs39.promises.mkdir(path44.dirname(writePath), { recursive: true });
+            await fs39.promises.mkdir(path45.dirname(writePath), { recursive: true });
             await fs39.promises.writeFile(writePath, writeContent, "utf-8");
             return {};
           },
@@ -24711,7 +24942,7 @@ var init_extract_file_info = __esm({
 });
 
 // src/core/message-transformer.ts
-import * as path45 from "path";
+import * as path46 from "path";
 function computeLineDiff(oldStr, newStr) {
   const oldLines = oldStr ? oldStr.split("\n") : [];
   const newLines = newStr ? newStr.split("\n") : [];
@@ -25017,7 +25248,7 @@ var init_message_transformer = __esm({
           );
           return;
         }
-        const fileExt = path45.extname(fileInfo.filePath).toLowerCase();
+        const fileExt = path46.extname(fileInfo.filePath).toLowerCase();
         if (BINARY_VIEWER_EXTENSIONS.has(fileExt)) {
           log36.debug({ kind, filePath: fileInfo.filePath }, "enrichWithViewerLinks: skipping binary file");
           return;
@@ -25072,7 +25303,7 @@ var init_message_transformer = __esm({
 
 // src/core/sessions/session-store.ts
 import fs41 from "fs";
-import path46 from "path";
+import path47 from "path";
 var log37, DEBOUNCE_MS3, JsonFileSessionStore;
 var init_session_store = __esm({
   "src/core/sessions/session-store.ts"() {
@@ -25164,7 +25395,7 @@ var init_session_store = __esm({
           version: 1,
           sessions: Object.fromEntries(this.records)
         };
-        const dir = path46.dirname(this.filePath);
+        const dir = path47.dirname(this.filePath);
         if (!fs41.existsSync(dir)) fs41.mkdirSync(dir, { recursive: true });
         const tmpPath = `${this.filePath}.tmp`;
         fs41.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
@@ -25933,7 +26164,7 @@ __export(agent_catalog_exports, {
   AgentCatalog: () => AgentCatalog
 });
 import * as fs42 from "fs";
-import * as path47 from "path";
+import * as path48 from "path";
 function stripNpmVersion(pkg) {
   if (pkg.startsWith("@")) {
     const slashIdx = pkg.indexOf("/");
@@ -26000,7 +26231,7 @@ var init_agent_catalog = __esm({
             ttlHours: DEFAULT_TTL_HOURS,
             data
           };
-          fs42.mkdirSync(path47.dirname(this.cachePath), { recursive: true });
+          fs42.mkdirSync(path48.dirname(this.cachePath), { recursive: true });
           fs42.writeFileSync(this.cachePath, JSON.stringify(cache, null, 2), { mode: 384 });
           this.enrichInstalledFromRegistry();
           log40.info({ count: this.registryAgents.length }, "Registry updated");
@@ -26242,9 +26473,9 @@ var init_agent_catalog = __esm({
         }
         try {
           const candidates = [
-            path47.join(import.meta.dirname, "data", "registry-snapshot.json"),
-            path47.join(import.meta.dirname, "..", "data", "registry-snapshot.json"),
-            path47.join(import.meta.dirname, "..", "..", "data", "registry-snapshot.json")
+            path48.join(import.meta.dirname, "data", "registry-snapshot.json"),
+            path48.join(import.meta.dirname, "..", "data", "registry-snapshot.json"),
+            path48.join(import.meta.dirname, "..", "..", "data", "registry-snapshot.json")
           ];
           for (const candidate of candidates) {
             if (fs42.existsSync(candidate)) {
@@ -26269,7 +26500,7 @@ __export(agent_store_exports, {
   AgentStore: () => AgentStore
 });
 import * as fs43 from "fs";
-import * as path48 from "path";
+import * as path49 from "path";
 import { z as z10 } from "zod";
 var log41, InstalledAgentSchema, AgentStoreSchema, AgentStore;
 var init_agent_store = __esm({
@@ -26346,7 +26577,7 @@ var init_agent_store = __esm({
        * may contain agent binary paths and environment variables.
        */
       save() {
-        fs43.mkdirSync(path48.dirname(this.filePath), { recursive: true });
+        fs43.mkdirSync(path49.dirname(this.filePath), { recursive: true });
         const tmpPath = this.filePath + ".tmp";
         fs43.writeFileSync(tmpPath, JSON.stringify(this.data, null, 2), { mode: 384 });
         fs43.renameSync(tmpPath, this.filePath);
@@ -26665,7 +26896,7 @@ var init_error_tracker = __esm({
 
 // src/core/plugin/plugin-storage.ts
 import fs44 from "fs";
-import path49 from "path";
+import path50 from "path";
 var PluginStorageImpl;
 var init_plugin_storage = __esm({
   "src/core/plugin/plugin-storage.ts"() {
@@ -26676,8 +26907,8 @@ var init_plugin_storage = __esm({
       /** Serializes writes to prevent concurrent file corruption */
       writeChain = Promise.resolve();
       constructor(baseDir) {
-        this.dataDir = path49.join(baseDir, "data");
-        this.kvPath = path49.join(baseDir, "kv.json");
+        this.dataDir = path50.join(baseDir, "data");
+        this.kvPath = path50.join(baseDir, "kv.json");
         fs44.mkdirSync(baseDir, { recursive: true });
       }
       readKv() {
@@ -27802,7 +28033,7 @@ var init_core_items = __esm({
 });
 
 // src/core/core.ts
-import path50 from "path";
+import path51 from "path";
 import { nanoid as nanoid6 } from "nanoid";
 var log45, OpenACPCore;
 var init_core = __esm({
@@ -27828,6 +28059,7 @@ var init_core = __esm({
     init_middleware_chain();
     init_error_tracker();
     init_log();
+    init_native_stt();
     init_events();
     init_turn_context();
     log45 = createChildLogger({ module: "core" });
@@ -27972,21 +28204,7 @@ var init_core = __esm({
                 const settingsMgr = this.settingsManager;
                 if (settingsMgr) {
                   const pluginCfg = await settingsMgr.loadSettings("@openacp/speech");
-                  const groqApiKey = pluginCfg.groqApiKey;
-                  const sttProviders = {};
-                  if (groqApiKey) {
-                    sttProviders.groq = { apiKey: groqApiKey };
-                  }
-                  const newSpeechConfig = {
-                    stt: {
-                      provider: groqApiKey ? "groq" : null,
-                      providers: sttProviders
-                    },
-                    tts: {
-                      provider: pluginCfg.ttsProvider ?? null,
-                      providers: {}
-                    }
-                  };
+                  const newSpeechConfig = buildSpeechServiceConfig(pluginCfg);
                   speechSvc.refreshProviders(newSpeechConfig);
                   log45.info("Speech service config updated at runtime (from plugin settings)");
                 }
@@ -27995,7 +28213,7 @@ var init_core = __esm({
           }
         );
         registerCoreMenuItems(this.menuRegistry);
-        this.assistantRegistry.setInstanceRoot(path50.dirname(ctx.root));
+        this.assistantRegistry.setInstanceRoot(path51.dirname(ctx.root));
         this.assistantRegistry.register(createSessionsSection(this));
         this.assistantRegistry.register(createAgentsSection(this));
         this.assistantRegistry.register(createConfigSection(this));
@@ -28429,8 +28647,8 @@ ${text5}`;
             message: `Agent '${agentName}' not found`
           };
         }
-        const { existsSync: existsSync20 } = await import("fs");
-        if (!existsSync20(cwd)) {
+        const { existsSync: existsSync21 } = await import("fs");
+        if (!existsSync21(cwd)) {
           return {
             ok: false,
             error: "invalid_cwd",
@@ -30148,11 +30366,11 @@ __export(instance_copy_exports, {
   copyInstance: () => copyInstance
 });
 import fs45 from "fs";
-import path51 from "path";
+import path52 from "path";
 async function copyInstance(src, dst, opts) {
   const { inheritableKeys = {}, onProgress } = opts;
   fs45.mkdirSync(dst, { recursive: true });
-  const configSrc = path51.join(src, "config.json");
+  const configSrc = path52.join(src, "config.json");
   if (fs45.existsSync(configSrc)) {
     onProgress?.("Configuration", "start");
     const config = JSON.parse(fs45.readFileSync(configSrc, "utf-8"));
@@ -30176,44 +30394,44 @@ async function copyInstance(src, dst, opts) {
         }
       }
     }
-    fs45.writeFileSync(path51.join(dst, "config.json"), JSON.stringify(config, null, 2));
+    fs45.writeFileSync(path52.join(dst, "config.json"), JSON.stringify(config, null, 2));
     onProgress?.("Configuration", "done");
   }
-  const pluginsSrc = path51.join(src, "plugins.json");
+  const pluginsSrc = path52.join(src, "plugins.json");
   if (fs45.existsSync(pluginsSrc)) {
     onProgress?.("Plugin list", "start");
-    fs45.copyFileSync(pluginsSrc, path51.join(dst, "plugins.json"));
+    fs45.copyFileSync(pluginsSrc, path52.join(dst, "plugins.json"));
     onProgress?.("Plugin list", "done");
   }
-  const pluginsDir = path51.join(src, "plugins");
+  const pluginsDir = path52.join(src, "plugins");
   if (fs45.existsSync(pluginsDir)) {
     onProgress?.("Plugins", "start");
-    const dstPlugins = path51.join(dst, "plugins");
+    const dstPlugins = path52.join(dst, "plugins");
     fs45.mkdirSync(dstPlugins, { recursive: true });
-    const pkgJson = path51.join(pluginsDir, "package.json");
-    if (fs45.existsSync(pkgJson)) fs45.copyFileSync(pkgJson, path51.join(dstPlugins, "package.json"));
-    const nodeModules = path51.join(pluginsDir, "node_modules");
-    if (fs45.existsSync(nodeModules)) fs45.cpSync(nodeModules, path51.join(dstPlugins, "node_modules"), { recursive: true });
+    const pkgJson = path52.join(pluginsDir, "package.json");
+    if (fs45.existsSync(pkgJson)) fs45.copyFileSync(pkgJson, path52.join(dstPlugins, "package.json"));
+    const nodeModules = path52.join(pluginsDir, "node_modules");
+    if (fs45.existsSync(nodeModules)) fs45.cpSync(nodeModules, path52.join(dstPlugins, "node_modules"), { recursive: true });
     onProgress?.("Plugins", "done");
   }
-  const agentsJson = path51.join(src, "agents.json");
+  const agentsJson = path52.join(src, "agents.json");
   if (fs45.existsSync(agentsJson)) {
     onProgress?.("Agents", "start");
-    fs45.copyFileSync(agentsJson, path51.join(dst, "agents.json"));
-    const agentsDir = path51.join(src, "agents");
-    if (fs45.existsSync(agentsDir)) fs45.cpSync(agentsDir, path51.join(dst, "agents"), { recursive: true });
+    fs45.copyFileSync(agentsJson, path52.join(dst, "agents.json"));
+    const agentsDir = path52.join(src, "agents");
+    if (fs45.existsSync(agentsDir)) fs45.cpSync(agentsDir, path52.join(dst, "agents"), { recursive: true });
     onProgress?.("Agents", "done");
   }
-  const binDir = path51.join(src, "bin");
+  const binDir = path52.join(src, "bin");
   if (fs45.existsSync(binDir)) {
     onProgress?.("Tools", "start");
-    fs45.cpSync(binDir, path51.join(dst, "bin"), { recursive: true });
+    fs45.cpSync(binDir, path52.join(dst, "bin"), { recursive: true });
     onProgress?.("Tools", "done");
   }
-  const pluginDataSrc = path51.join(src, "plugins", "data");
+  const pluginDataSrc = path52.join(src, "plugins", "data");
   if (fs45.existsSync(pluginDataSrc)) {
     onProgress?.("Preferences", "start");
-    copyPluginSettings(pluginDataSrc, path51.join(dst, "plugins", "data"), inheritableKeys);
+    copyPluginSettings(pluginDataSrc, path52.join(dst, "plugins", "data"), inheritableKeys);
     onProgress?.("Preferences", "done");
   }
 }
@@ -30228,10 +30446,10 @@ function copyPluginSettings(srcData, dstData, inheritableKeys) {
         if (key in settings) filtered[key] = settings[key];
       }
       if (Object.keys(filtered).length > 0) {
-        const relative = path51.relative(srcData, path51.dirname(settingsPath));
-        const dstDir = path51.join(dstData, relative);
+        const relative = path52.relative(srcData, path52.dirname(settingsPath));
+        const dstDir = path52.join(dstData, relative);
         fs45.mkdirSync(dstDir, { recursive: true });
-        fs45.writeFileSync(path51.join(dstDir, "settings.json"), JSON.stringify(filtered, null, 2));
+        fs45.writeFileSync(path52.join(dstDir, "settings.json"), JSON.stringify(filtered, null, 2));
       }
     } catch {
     }
@@ -30242,15 +30460,15 @@ function walkPluginDirs(base, cb) {
   for (const entry of fs45.readdirSync(base, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith("@")) {
-      const scopeDir = path51.join(base, entry.name);
+      const scopeDir = path52.join(base, entry.name);
       for (const sub of fs45.readdirSync(scopeDir, { withFileTypes: true })) {
         if (!sub.isDirectory()) continue;
         const pluginName = `${entry.name}/${sub.name}`;
-        const settingsPath = path51.join(scopeDir, sub.name, "settings.json");
+        const settingsPath = path52.join(scopeDir, sub.name, "settings.json");
         if (fs45.existsSync(settingsPath)) cb(pluginName, settingsPath);
       }
     } else {
-      const settingsPath = path51.join(base, entry.name, "settings.json");
+      const settingsPath = path52.join(base, entry.name, "settings.json");
       if (fs45.existsSync(settingsPath)) cb(entry.name, settingsPath);
     }
   }
@@ -30263,14 +30481,14 @@ var init_instance_copy = __esm({
 
 // src/core/setup/git-protect.ts
 import fs46 from "fs";
-import path52 from "path";
+import path53 from "path";
 function protectLocalInstance(projectDir) {
   ensureGitignore(projectDir);
   ensureClaudeMd(projectDir);
   printSecurityWarning();
 }
 function ensureGitignore(projectDir) {
-  const gitignorePath = path52.join(projectDir, ".gitignore");
+  const gitignorePath = path53.join(projectDir, ".gitignore");
   const entry = ".openacp";
   if (fs46.existsSync(gitignorePath)) {
     const content = fs46.readFileSync(gitignorePath, "utf-8");
@@ -30290,7 +30508,7 @@ ${entry}
   }
 }
 function ensureClaudeMd(projectDir) {
-  const claudeMdPath = path52.join(projectDir, "CLAUDE.md");
+  const claudeMdPath = path53.join(projectDir, "CLAUDE.md");
   const marker = "## Local OpenACP Workspace";
   if (fs46.existsSync(claudeMdPath)) {
     const content = fs46.readFileSync(claudeMdPath, "utf-8");
@@ -30333,7 +30551,7 @@ var init_git_protect = __esm({
 });
 
 // src/core/setup/wizard.ts
-import * as path53 from "path";
+import * as path54 from "path";
 import * as fs47 from "fs";
 import * as os10 from "os";
 import * as clack7 from "@clack/prompts";
@@ -30381,7 +30599,7 @@ async function runSetup(configManager, opts) {
     const instanceRoot = opts?.instanceRoot;
     let instanceName = opts?.instanceName;
     if (!instanceName) {
-      const defaultName = path53.basename(path53.dirname(instanceRoot));
+      const defaultName = path54.basename(path54.dirname(instanceRoot));
       const locationHint = instanceRoot.replace(/\/.openacp$/, "").replace(os10.homedir(), "~");
       const nameResult = await clack7.text({
         message: `Name for this workspace (${locationHint})`,
@@ -30392,13 +30610,13 @@ async function runSetup(configManager, opts) {
       instanceName = nameResult.trim();
     }
     const globalRoot = getGlobalRoot();
-    const registryPath = path53.join(globalRoot, "instances.json");
+    const registryPath = path54.join(globalRoot, "instances.json");
     const instanceRegistry = new InstanceRegistry(registryPath);
     instanceRegistry.load();
     let didCopy = false;
     if (opts?.from) {
-      const fromRoot = path53.join(opts.from, ".openacp");
-      if (fs47.existsSync(path53.join(fromRoot, "config.json"))) {
+      const fromRoot = path54.join(opts.from, ".openacp");
+      if (fs47.existsSync(path54.join(fromRoot, "config.json"))) {
         const inheritableMap = buildInheritableKeysMap();
         await copyInstance(fromRoot, instanceRoot, { inheritableKeys: inheritableMap });
         didCopy = true;
@@ -30409,7 +30627,7 @@ async function runSetup(configManager, opts) {
     }
     if (!didCopy) {
       const existingInstances = instanceRegistry.list().filter(
-        (e) => fs47.existsSync(path53.join(e.root, "config.json")) && e.root !== instanceRoot
+        (e) => fs47.existsSync(path54.join(e.root, "config.json")) && e.root !== instanceRoot
       );
       if (existingInstances.length > 0) {
         let singleLabel;
@@ -30417,7 +30635,7 @@ async function runSetup(configManager, opts) {
           const e = existingInstances[0];
           let name = e.id;
           try {
-            const cfg = JSON.parse(fs47.readFileSync(path53.join(e.root, "config.json"), "utf-8"));
+            const cfg = JSON.parse(fs47.readFileSync(path54.join(e.root, "config.json"), "utf-8"));
             if (cfg.instanceName) name = cfg.instanceName;
           } catch {
           }
@@ -30440,7 +30658,7 @@ async function runSetup(configManager, opts) {
               options: existingInstances.map((e) => {
                 let name = e.id;
                 try {
-                  const cfg = JSON.parse(fs47.readFileSync(path53.join(e.root, "config.json"), "utf-8"));
+                  const cfg = JSON.parse(fs47.readFileSync(path54.join(e.root, "config.json"), "utf-8"));
                   if (cfg.instanceName) name = cfg.instanceName;
                 } catch {
                 }
@@ -30535,9 +30753,9 @@ async function runSetup(configManager, opts) {
       if (channelId.startsWith("official:")) {
         const npmPackage = channelId.slice("official:".length);
         const { execFileSync: execFileSync9 } = await import("child_process");
-        const pluginsDir = path53.join(instanceRoot, "plugins");
-        const nodeModulesDir = path53.join(pluginsDir, "node_modules");
-        const installedPath = path53.join(nodeModulesDir, npmPackage);
+        const pluginsDir = path54.join(instanceRoot, "plugins");
+        const nodeModulesDir = path54.join(pluginsDir, "node_modules");
+        const installedPath = path54.join(nodeModulesDir, npmPackage);
         if (!fs47.existsSync(installedPath)) {
           try {
             clack7.log.step(`Installing ${npmPackage}...`);
@@ -30551,9 +30769,9 @@ async function runSetup(configManager, opts) {
           }
         }
         try {
-          const installedPkgPath = path53.join(nodeModulesDir, npmPackage, "package.json");
+          const installedPkgPath = path54.join(nodeModulesDir, npmPackage, "package.json");
           const installedPkg = JSON.parse(fs47.readFileSync(installedPkgPath, "utf-8"));
-          const pluginModule = await import(path53.join(nodeModulesDir, npmPackage, installedPkg.main ?? "dist/index.js"));
+          const pluginModule = await import(path54.join(nodeModulesDir, npmPackage, installedPkg.main ?? "dist/index.js"));
           const plugin2 = pluginModule.default;
           if (plugin2?.install) {
             const installCtx = createInstallContext2({
@@ -30583,8 +30801,8 @@ async function runSetup(configManager, opts) {
       if (channelId.startsWith("community:")) {
         const npmPackage = channelId.slice("community:".length);
         const { execFileSync: execFileSync9 } = await import("child_process");
-        const pluginsDir = path53.join(instanceRoot, "plugins");
-        const nodeModulesDir = path53.join(pluginsDir, "node_modules");
+        const pluginsDir = path54.join(instanceRoot, "plugins");
+        const nodeModulesDir = path54.join(pluginsDir, "node_modules");
         try {
           execFileSync9("npm", ["install", npmPackage, "--prefix", pluginsDir, "--save", "--ignore-scripts"], {
             stdio: "inherit",
@@ -30596,9 +30814,9 @@ async function runSetup(configManager, opts) {
         }
         try {
           const { readFileSync: readFileSync18 } = await import("fs");
-          const installedPkgPath = path53.join(nodeModulesDir, npmPackage, "package.json");
+          const installedPkgPath = path54.join(nodeModulesDir, npmPackage, "package.json");
           const installedPkg = JSON.parse(readFileSync18(installedPkgPath, "utf-8"));
-          const pluginModule = await import(path53.join(nodeModulesDir, npmPackage, installedPkg.main ?? "dist/index.js"));
+          const pluginModule = await import(path54.join(nodeModulesDir, npmPackage, installedPkg.main ?? "dist/index.js"));
           const plugin2 = pluginModule.default;
           if (plugin2?.install) {
             const installCtx = createInstallContext2({
@@ -30651,7 +30869,7 @@ async function runSetup(configManager, opts) {
       workspace: { allowExternalWorkspaces: true, security: { allowedPaths: [], envWhitelist: [] } },
       logging: {
         level: "info",
-        logDir: path53.join(instanceRoot, "logs"),
+        logDir: path54.join(instanceRoot, "logs"),
         maxFileSize: "10m",
         maxFiles: 7,
         sessionLogRetentionDays: 30
@@ -30678,7 +30896,7 @@ async function runSetup(configManager, opts) {
       instanceRegistry.register(instanceId, instanceRoot);
       await instanceRegistry.save();
     }
-    const projectDir = path53.dirname(instanceRoot);
+    const projectDir = path54.dirname(instanceRoot);
     protectLocalInstance(projectDir);
     clack7.outro(`Config saved to ${configManager.getConfigPath()}`);
     if (!opts?.skipRunMode) {
@@ -30757,7 +30975,7 @@ async function runReconfigure(configManager, settingsManager) {
         await configureChannels(config, settingsManager);
       }
       if (choice === "agents") {
-        const reconfigRoot = path53.dirname(configManager.getConfigPath());
+        const reconfigRoot = path54.dirname(configManager.getConfigPath());
         const { defaultAgent } = await setupAgents(reconfigRoot);
         await configManager.save({ defaultAgent });
         config = configManager.get();
@@ -30962,7 +31180,7 @@ __export(dev_loader_exports, {
 });
 import fs48 from "fs";
 import os11 from "os";
-import path54 from "path";
+import path55 from "path";
 var loadCounter, DevPluginLoader;
 var init_dev_loader = __esm({
   "src/core/plugin/dev-loader.ts"() {
@@ -30972,24 +31190,24 @@ var init_dev_loader = __esm({
       pluginPath;
       lastTempDir = null;
       constructor(pluginPath) {
-        this.pluginPath = path54.resolve(pluginPath);
+        this.pluginPath = path55.resolve(pluginPath);
       }
       async load() {
-        const distPath = path54.join(this.pluginPath, "dist");
-        const distIndex = path54.join(distPath, "index.js");
-        const srcIndex = path54.join(this.pluginPath, "src", "index.ts");
+        const distPath = path55.join(this.pluginPath, "dist");
+        const distIndex = path55.join(distPath, "index.js");
+        const srcIndex = path55.join(this.pluginPath, "src", "index.ts");
         if (!fs48.existsSync(distIndex) && !fs48.existsSync(srcIndex)) {
           throw new Error(`Plugin not found at ${this.pluginPath}. Expected dist/index.js or src/index.ts`);
         }
         if (!fs48.existsSync(distIndex)) {
           throw new Error(`Built plugin not found at ${distIndex}. Run 'npm run build' first.`);
         }
-        const tempDir = path54.join(os11.tmpdir(), `openacp-dev-plugin-${Date.now()}-${++loadCounter}`);
+        const tempDir = path55.join(os11.tmpdir(), `openacp-dev-plugin-${Date.now()}-${++loadCounter}`);
         fs48.cpSync(distPath, tempDir, { recursive: true });
         const previousTempDir = this.lastTempDir;
         this.lastTempDir = tempDir;
         try {
-          const mod = await import(`file://${path54.join(tempDir, "index.js")}`);
+          const mod = await import(`file://${path55.join(tempDir, "index.js")}`);
           const plugin2 = mod.default;
           if (!plugin2 || !plugin2.name || !plugin2.setup) {
             throw new Error(`Invalid plugin at ${distIndex}. Must export default OpenACPPlugin with name and setup().`);
@@ -31012,7 +31230,7 @@ var init_dev_loader = __esm({
       }
       /** Returns the path to the plugin's dist directory (the source of truth — NOT the temp copy). */
       getDistPath() {
-        return path54.join(this.pluginPath, "dist");
+        return path55.join(this.pluginPath, "dist");
       }
     };
   }
@@ -31024,7 +31242,7 @@ __export(main_exports, {
   RESTART_EXIT_CODE: () => RESTART_EXIT_CODE,
   startServer: () => startServer
 });
-import path55 from "path";
+import path56 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 import fs49 from "fs";
 async function startServer(opts) {
@@ -31049,7 +31267,7 @@ async function startServer(opts) {
       process.exit(1);
     }
     const globalRoot = getGlobalRoot();
-    const reg = new InstanceRegistry(path55.join(globalRoot, "instances.json"));
+    const reg = new InstanceRegistry(path56.join(globalRoot, "instances.json"));
     reg.load();
     const entry = reg.getByRoot(root);
     opts = { ...opts, instanceContext: createInstanceContext({ id: entry?.id ?? randomUUID4(), root }) };
@@ -31137,22 +31355,22 @@ async function startServer(opts) {
         try {
           let modulePath;
           if (name.startsWith("/") || name.startsWith(".")) {
-            const resolved = path55.resolve(name);
-            const pkgPath = path55.join(resolved, "package.json");
+            const resolved = path56.resolve(name);
+            const pkgPath = path56.join(resolved, "package.json");
             const pkg = JSON.parse(await fs49.promises.readFile(pkgPath, "utf-8"));
-            modulePath = path55.join(resolved, pkg.main || "dist/index.js");
+            modulePath = path56.join(resolved, pkg.main || "dist/index.js");
           } else {
-            const nodeModulesDir = path55.join(ctx.paths.plugins, "node_modules");
-            let pkgDir = path55.join(nodeModulesDir, name);
-            if (!fs49.existsSync(path55.join(pkgDir, "package.json"))) {
+            const nodeModulesDir = path56.join(ctx.paths.plugins, "node_modules");
+            let pkgDir = path56.join(nodeModulesDir, name);
+            if (!fs49.existsSync(path56.join(pkgDir, "package.json"))) {
               let found = false;
               const scopes = fs49.existsSync(nodeModulesDir) ? fs49.readdirSync(nodeModulesDir).filter((d) => d.startsWith("@")) : [];
               for (const scope of scopes) {
-                const scopeDir = path55.join(nodeModulesDir, scope);
+                const scopeDir = path56.join(nodeModulesDir, scope);
                 const pkgs = fs49.readdirSync(scopeDir);
                 for (const pkg2 of pkgs) {
-                  const candidateDir = path55.join(scopeDir, pkg2);
-                  const candidatePkgPath = path55.join(candidateDir, "package.json");
+                  const candidateDir = path56.join(scopeDir, pkg2);
+                  const candidatePkgPath = path56.join(candidateDir, "package.json");
                   if (fs49.existsSync(candidatePkgPath)) {
                     try {
                       const candidatePkg = JSON.parse(fs49.readFileSync(candidatePkgPath, "utf-8"));
@@ -31169,9 +31387,9 @@ async function startServer(opts) {
                 if (found) break;
               }
             }
-            const pkgJsonPath = path55.join(pkgDir, "package.json");
+            const pkgJsonPath = path56.join(pkgDir, "package.json");
             const pkg = JSON.parse(await fs49.promises.readFile(pkgJsonPath, "utf-8"));
-            modulePath = path55.join(pkgDir, pkg.main || "dist/index.js");
+            modulePath = path56.join(pkgDir, pkg.main || "dist/index.js");
           }
           log.debug({ plugin: name, modulePath }, "Loading community plugin");
           const mod = await import(modulePath);
@@ -31343,7 +31561,7 @@ async function startServer(opts) {
   await core.start();
   try {
     const globalRoot = getGlobalRoot();
-    const registryPath = path55.join(globalRoot, "instances.json");
+    const registryPath = path56.join(globalRoot, "instances.json");
     const instanceReg = new InstanceRegistry(registryPath);
     await instanceReg.load();
     if (!instanceReg.getByRoot(ctx.root)) {
@@ -31515,7 +31733,7 @@ var restart_exports = {};
 __export(restart_exports, {
   cmdRestart: () => cmdRestart
 });
-import path56 from "path";
+import path57 from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 async function cmdRestart(args2 = [], instanceRoot) {
   const json = isJsonMode(args2);
@@ -31555,7 +31773,7 @@ Stops the running daemon (if any) and starts a new one.
   if (!json && stopResult.stopped) {
     console.log(`Stopped daemon (was PID ${stopResult.pid})`);
   }
-  const cm = new ConfigManager2(path56.join(root, "config.json"));
+  const cm = new ConfigManager2(path57.join(root, "config.json"));
   if (!await cm.exists()) {
     if (json) jsonError(ErrorCodes.CONFIG_NOT_FOUND, 'No config found. Run "openacp" first to set up.');
     console.error('No config found. Run "openacp" first to set up.');
@@ -31576,7 +31794,7 @@ Stops the running daemon (if any) and starts a new one.
     printInstanceHint(root);
     console.log("Starting in foreground mode...");
     const { startServer: startServer2 } = await Promise.resolve().then(() => (init_main(), main_exports));
-    const reg = new InstanceRegistry(path56.join(getGlobalRoot(), "instances.json"));
+    const reg = new InstanceRegistry(path57.join(getGlobalRoot(), "instances.json"));
     reg.load();
     const existingEntry = reg.getByRoot(root);
     const ctx = createInstanceContext({
@@ -31625,7 +31843,7 @@ __export(status_exports, {
   readInstanceInfo: () => readInstanceInfo
 });
 import fs50 from "fs";
-import path57 from "path";
+import path58 from "path";
 import os12 from "os";
 async function cmdStatus(args2 = [], instanceRoot) {
   const json = isJsonMode(args2);
@@ -31643,7 +31861,7 @@ async function cmdStatus(args2 = [], instanceRoot) {
   await showSingleInstance(root, json);
 }
 async function showAllInstances(json = false) {
-  const registryPath = path57.join(getGlobalRoot(), "instances.json");
+  const registryPath = path58.join(getGlobalRoot(), "instances.json");
   const registry = new InstanceRegistry(registryPath);
   await registry.load();
   const instances = registry.list();
@@ -31686,7 +31904,7 @@ async function showAllInstances(json = false) {
   console.log("");
 }
 async function showInstanceById(id, json = false) {
-  const registryPath = path57.join(getGlobalRoot(), "instances.json");
+  const registryPath = path58.join(getGlobalRoot(), "instances.json");
   const registry = new InstanceRegistry(registryPath);
   await registry.load();
   const entry = registry.get(id);
@@ -31701,7 +31919,7 @@ async function showSingleInstance(root, json = false) {
   const info = readInstanceInfo(root);
   if (json) {
     jsonSuccess({
-      id: path57.basename(root),
+      id: path58.basename(root),
       name: info.name,
       status: info.pid ? "online" : "offline",
       pid: info.pid,
@@ -31732,13 +31950,13 @@ function readInstanceInfo(root) {
     channels: []
   };
   try {
-    const config = JSON.parse(fs50.readFileSync(path57.join(root, "config.json"), "utf-8"));
+    const config = JSON.parse(fs50.readFileSync(path58.join(root, "config.json"), "utf-8"));
     result.name = config.instanceName ?? null;
     result.runMode = config.runMode ?? null;
   } catch {
   }
   try {
-    const pid = parseInt(fs50.readFileSync(path57.join(root, "openacp.pid"), "utf-8").trim());
+    const pid = parseInt(fs50.readFileSync(path58.join(root, "openacp.pid"), "utf-8").trim());
     if (!isNaN(pid)) {
       process.kill(pid, 0);
       result.pid = pid;
@@ -31746,19 +31964,19 @@ function readInstanceInfo(root) {
   } catch {
   }
   try {
-    const port = parseInt(fs50.readFileSync(path57.join(root, "api.port"), "utf-8").trim());
+    const port = parseInt(fs50.readFileSync(path58.join(root, "api.port"), "utf-8").trim());
     if (!isNaN(port)) result.apiPort = port;
   } catch {
   }
   try {
-    const tunnels = JSON.parse(fs50.readFileSync(path57.join(root, "tunnels.json"), "utf-8"));
+    const tunnels = JSON.parse(fs50.readFileSync(path58.join(root, "tunnels.json"), "utf-8"));
     const entries = Object.values(tunnels);
     const systemEntry = entries.find((t) => t.type === "system");
     if (systemEntry?.port) result.tunnelPort = systemEntry.port;
   } catch {
   }
   try {
-    const plugins = JSON.parse(fs50.readFileSync(path57.join(root, "plugins.json"), "utf-8"));
+    const plugins = JSON.parse(fs50.readFileSync(path58.join(root, "plugins.json"), "utf-8"));
     const adapterMap = [
       { pluginName: "@openacp/telegram", channelId: "telegram" },
       { pluginName: "@openacp/discord-adapter", channelId: "discord" },
@@ -31776,7 +31994,7 @@ function readInstanceInfo(root) {
 function formatInstanceStatus(root) {
   const info = readInstanceInfo(root);
   if (!info.pid) return null;
-  const workspaceDir = path57.dirname(root);
+  const workspaceDir = path58.dirname(root);
   const displayPath = workspaceDir.replace(os12.homedir(), "~");
   const lines = [];
   lines.push(`  PID:       ${info.pid}`);
@@ -31845,7 +32063,7 @@ var config_editor_exports = {};
 __export(config_editor_exports, {
   runConfigEditor: () => runConfigEditor
 });
-import * as path58 from "path";
+import * as path59 from "path";
 import * as clack8 from "@clack/prompts";
 async function select8(opts) {
   const result = await clack8.select({
@@ -32399,7 +32617,7 @@ async function runConfigEditor(configManager, mode = "file", apiPort, settingsMa
   await configManager.load();
   const config = configManager.get();
   const updates = {};
-  const instanceRoot = path58.dirname(configManager.getConfigPath());
+  const instanceRoot = path59.dirname(configManager.getConfigPath());
   console.log(`
 ${c2.cyan}${c2.bold}OpenACP Config Editor${c2.reset}`);
   console.log(dim2(`Config: ${configManager.getConfigPath()}`));
@@ -32456,17 +32674,17 @@ ${c2.cyan}${c2.bold}OpenACP Config Editor${c2.reset}`);
 async function sendConfigViaApi(port, updates) {
   const { apiCall: call } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
   const paths = flattenToPaths(updates);
-  for (const { path: path71, value } of paths) {
+  for (const { path: path72, value } of paths) {
     const res = await call(port, "/api/config", {
       method: "PATCH",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ path: path71, value })
+      body: JSON.stringify({ path: path72, value })
     });
     const data = await res.json();
     if (!res.ok) {
-      console.log(warn2(`Failed to update ${path71}: ${data.error}`));
+      console.log(warn2(`Failed to update ${path72}: ${data.error}`));
     } else if (data.needsRestart) {
-      console.log(warn2(`${path71} updated \u2014 restart required`));
+      console.log(warn2(`${path72} updated \u2014 restart required`));
     }
   }
 }
@@ -32576,24 +32794,24 @@ __export(migration_exports, {
   migrateGlobalInstance: () => migrateGlobalInstance
 });
 import fs55 from "fs";
-import path68 from "path";
+import path69 from "path";
 import os15 from "os";
 import { randomUUID as randomUUID8 } from "crypto";
 async function migrateGlobalInstance() {
   const globalRoot = getGlobalRoot();
-  const globalConfig = path68.join(globalRoot, "config.json");
+  const globalConfig = path69.join(globalRoot, "config.json");
   if (!fs55.existsSync(globalConfig)) return null;
-  let baseDir = path68.join(os15.homedir(), "openacp-workspace");
+  let baseDir = path69.join(os15.homedir(), "openacp-workspace");
   try {
     const raw = JSON.parse(fs55.readFileSync(globalConfig, "utf-8"));
     if (raw.workspace?.baseDir) {
       const configured = raw.workspace.baseDir;
-      baseDir = configured.startsWith("~") ? path68.join(os15.homedir(), configured.slice(1)) : configured;
+      baseDir = configured.startsWith("~") ? path69.join(os15.homedir(), configured.slice(1)) : configured;
     }
   } catch {
   }
-  const targetRoot = path68.join(baseDir, ".openacp");
-  if (path68.resolve(targetRoot) === path68.resolve(globalRoot)) {
+  const targetRoot = path69.join(baseDir, ".openacp");
+  if (path69.resolve(targetRoot) === path69.resolve(globalRoot)) {
     return null;
   }
   const instanceFiles = [
@@ -32607,34 +32825,34 @@ async function migrateGlobalInstance() {
   const instanceDirs = ["plugins", "logs", "history", "files"];
   fs55.mkdirSync(targetRoot, { recursive: true });
   for (const file of instanceFiles) {
-    const src = path68.join(globalRoot, file);
-    const dst = path68.join(targetRoot, file);
+    const src = path69.join(globalRoot, file);
+    const dst = path69.join(targetRoot, file);
     if (fs55.existsSync(src)) {
       fs55.cpSync(src, dst, { force: true });
       fs55.rmSync(src);
     }
   }
   for (const dir of instanceDirs) {
-    const src = path68.join(globalRoot, dir);
-    const dst = path68.join(targetRoot, dir);
+    const src = path69.join(globalRoot, dir);
+    const dst = path69.join(targetRoot, dir);
     if (fs55.existsSync(src)) {
       fs55.cpSync(src, dst, { recursive: true, force: true });
       fs55.rmSync(src, { recursive: true, force: true });
     }
   }
-  const srcCache = path68.join(globalRoot, "cache");
-  const dstCache = path68.join(targetRoot, "cache");
+  const srcCache = path69.join(globalRoot, "cache");
+  const dstCache = path69.join(targetRoot, "cache");
   if (fs55.existsSync(srcCache)) {
     fs55.mkdirSync(dstCache, { recursive: true });
     for (const entry of fs55.readdirSync(srcCache)) {
       if (entry === "registry-cache.json") continue;
-      const s = path68.join(srcCache, entry);
-      const d = path68.join(dstCache, entry);
+      const s = path69.join(srcCache, entry);
+      const d = path69.join(dstCache, entry);
       fs55.cpSync(s, d, { recursive: true, force: true });
       fs55.rmSync(s, { recursive: true, force: true });
     }
   }
-  const migratedConfigPath = path68.join(targetRoot, "config.json");
+  const migratedConfigPath = path69.join(targetRoot, "config.json");
   try {
     const config = JSON.parse(fs55.readFileSync(migratedConfigPath, "utf-8"));
     if (config.workspace?.baseDir) {
@@ -32643,7 +32861,7 @@ async function migrateGlobalInstance() {
     fs55.writeFileSync(migratedConfigPath, JSON.stringify(config, null, 2));
   } catch {
   }
-  const registryPath = path68.join(globalRoot, "instances.json");
+  const registryPath = path69.join(globalRoot, "instances.json");
   try {
     const registry = new InstanceRegistry(registryPath);
     registry.load();
@@ -32675,17 +32893,17 @@ __export(instance_prompt_exports, {
   promptForInstance: () => promptForInstance
 });
 import fs56 from "fs";
-import path69 from "path";
+import path70 from "path";
 import os16 from "os";
 async function promptForInstance(opts) {
   const globalRoot = getGlobalRoot();
-  const globalConfigExists = fs56.existsSync(path69.join(globalRoot, "config.json"));
+  const globalConfigExists = fs56.existsSync(path70.join(globalRoot, "config.json"));
   const cwd = process.cwd();
-  const isHomeDir = path69.resolve(cwd) === path69.resolve(os16.homedir());
-  const defaultWorkspace = path69.join(os16.homedir(), "openacp-workspace");
-  const createRoot = isHomeDir ? path69.join(defaultWorkspace, ".openacp") : path69.join(cwd, ".openacp");
+  const isHomeDir = path70.resolve(cwd) === path70.resolve(os16.homedir());
+  const defaultWorkspace = path70.join(os16.homedir(), "openacp-workspace");
+  const createRoot = isHomeDir ? path70.join(defaultWorkspace, ".openacp") : path70.join(cwd, ".openacp");
   const detectedParent = findParentInstance(cwd, globalRoot);
-  const registryPath = path69.join(globalRoot, "instances.json");
+  const registryPath = path70.join(globalRoot, "instances.json");
   const registry = new InstanceRegistry(registryPath);
   registry.load();
   const instances = registry.list().filter((e) => fs56.existsSync(e.root));
@@ -32717,24 +32935,24 @@ async function promptForInstance(opts) {
   const instanceOptions = instances.filter((e) => !detectedParent || e.root !== detectedParent).map((e) => {
     let name = e.id;
     try {
-      const raw = fs56.readFileSync(path69.join(e.root, "config.json"), "utf-8");
+      const raw = fs56.readFileSync(path70.join(e.root, "config.json"), "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.instanceName) name = parsed.instanceName;
     } catch {
     }
-    const workspaceDir = path69.dirname(e.root);
+    const workspaceDir = path70.dirname(e.root);
     const displayPath = workspaceDir.replace(os16.homedir(), "~");
     return { value: e.root, label: `${name} (${displayPath})` };
   });
   if (detectedParent) {
-    let name = path69.basename(path69.dirname(detectedParent));
+    let name = path70.basename(path70.dirname(detectedParent));
     try {
-      const raw = fs56.readFileSync(path69.join(detectedParent, "config.json"), "utf-8");
+      const raw = fs56.readFileSync(path70.join(detectedParent, "config.json"), "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.instanceName) name = parsed.instanceName;
     } catch {
     }
-    const workspaceDir = path69.dirname(detectedParent);
+    const workspaceDir = path70.dirname(detectedParent);
     const displayPath = workspaceDir.replace(os16.homedir(), "~");
     instanceOptions.unshift({ value: detectedParent, label: `${name} (${displayPath})` });
   }
@@ -32773,11 +32991,11 @@ async function promptForInstance(opts) {
   return choice;
 }
 function findParentInstance(cwd, globalRoot) {
-  let dir = path69.dirname(cwd);
+  let dir = path70.dirname(cwd);
   while (true) {
-    const candidate = path69.join(dir, ".openacp");
-    if (candidate !== globalRoot && fs56.existsSync(path69.join(candidate, "config.json"))) return candidate;
-    const parent = path69.dirname(dir);
+    const candidate = path70.join(dir, ".openacp");
+    if (candidate !== globalRoot && fs56.existsSync(path70.join(candidate, "config.json"))) return candidate;
+    const parent = path70.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -32793,7 +33011,7 @@ var init_instance_prompt = __esm({
 
 // src/cli.ts
 import { setDefaultAutoSelectFamily } from "net";
-import path70 from "path";
+import path71 from "path";
 
 // src/cli/commands/help.ts
 function printHelp() {
@@ -32937,10 +33155,10 @@ Shows all plugins registered in the plugin registry.
 `);
     return;
   }
-  const path71 = await import("path");
+  const path72 = await import("path");
   const { PluginRegistry: PluginRegistry2 } = await Promise.resolve().then(() => (init_plugin_registry(), plugin_registry_exports));
   const root = instanceRoot;
-  const registryPath = path71.join(root, "plugins.json");
+  const registryPath = path72.join(root, "plugins.json");
   const registry = new PluginRegistry2(registryPath);
   await registry.load();
   const plugins = registry.list();
@@ -33076,10 +33294,10 @@ async function cmdPlugin(args2 = [], instanceRoot) {
 }
 async function setPluginEnabled(name, enabled, instanceRoot, json = false) {
   if (json) await muteForJson();
-  const path71 = await import("path");
+  const path72 = await import("path");
   const { PluginRegistry: PluginRegistry2 } = await Promise.resolve().then(() => (init_plugin_registry(), plugin_registry_exports));
   const root = instanceRoot;
-  const registryPath = path71.join(root, "plugins.json");
+  const registryPath = path72.join(root, "plugins.json");
   const registry = new PluginRegistry2(registryPath);
   await registry.load();
   const entry = registry.get(name);
@@ -33094,7 +33312,7 @@ async function setPluginEnabled(name, enabled, instanceRoot, json = false) {
   console.log(`Plugin ${name} ${enabled ? "enabled" : "disabled"}. Restart to apply.`);
 }
 async function configurePlugin(name, instanceRoot) {
-  const path71 = await import("path");
+  const path72 = await import("path");
   const { corePlugins: corePlugins2 } = await Promise.resolve().then(() => (init_core_plugins(), core_plugins_exports));
   const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
   const { createInstallContext: createInstallContext2 } = await Promise.resolve().then(() => (init_install_context(), install_context_exports));
@@ -33104,7 +33322,7 @@ async function configurePlugin(name, instanceRoot) {
     process.exit(1);
   }
   const root = instanceRoot;
-  const basePath = path71.join(root, "plugins", "data");
+  const basePath = path72.join(root, "plugins", "data");
   const settingsManager = new SettingsManager2(basePath);
   const ctx = createInstallContext2({ pluginName: name, settingsManager, basePath });
   if (plugin2.configure) {
@@ -33117,7 +33335,7 @@ async function configurePlugin(name, instanceRoot) {
 }
 async function installPlugin(input2, instanceRoot, json = false) {
   if (json) await muteForJson();
-  const path71 = await import("path");
+  const path72 = await import("path");
   const { execFileSync: execFileSync9 } = await import("child_process");
   const { getCurrentVersion: getCurrentVersion2 } = await Promise.resolve().then(() => (init_version(), version_exports));
   const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
@@ -33168,9 +33386,9 @@ async function installPlugin(input2, instanceRoot, json = false) {
   if (!json) console.log(`Installing ${installSpec}...`);
   const { corePlugins: corePlugins2 } = await Promise.resolve().then(() => (init_core_plugins(), core_plugins_exports));
   const builtinPlugin = corePlugins2.find((p2) => p2.name === pkgName);
-  const basePath = path71.join(root, "plugins", "data");
+  const basePath = path72.join(root, "plugins", "data");
   const settingsManager = new SettingsManager2(basePath);
-  const registryPath = path71.join(root, "plugins.json");
+  const registryPath = path72.join(root, "plugins.json");
   const pluginRegistry = new PluginRegistry2(registryPath);
   await pluginRegistry.load();
   if (builtinPlugin) {
@@ -33190,8 +33408,8 @@ async function installPlugin(input2, instanceRoot, json = false) {
     console.log(`\u2713 ${builtinPlugin.name} installed! Restart to activate.`);
     return;
   }
-  const pluginsDir = path71.join(root, "plugins");
-  const nodeModulesDir = path71.join(pluginsDir, "node_modules");
+  const pluginsDir = path72.join(root, "plugins");
+  const nodeModulesDir = path72.join(pluginsDir, "node_modules");
   try {
     execFileSync9("npm", ["install", installSpec, "--prefix", pluginsDir, "--save"], {
       stdio: json ? "pipe" : "inherit",
@@ -33205,8 +33423,8 @@ async function installPlugin(input2, instanceRoot, json = false) {
   const cliVersion = getCurrentVersion2();
   const isLocalPath = pkgName.startsWith("/") || pkgName.startsWith(".");
   try {
-    const pluginRoot = isLocalPath ? path71.resolve(pkgName) : path71.join(nodeModulesDir, pkgName);
-    const installedPkgPath = path71.join(pluginRoot, "package.json");
+    const pluginRoot = isLocalPath ? path72.resolve(pkgName) : path72.join(nodeModulesDir, pkgName);
+    const installedPkgPath = path72.join(pluginRoot, "package.json");
     const { readFileSync: readFileSync18 } = await import("fs");
     const installedPkg = JSON.parse(readFileSync18(installedPkgPath, "utf-8"));
     const minVersion = installedPkg.engines?.openacp?.replace(/[>=^~\s]/g, "");
@@ -33221,7 +33439,7 @@ async function installPlugin(input2, instanceRoot, json = false) {
         }
       }
     }
-    const pluginModule = await import(path71.join(pluginRoot, installedPkg.main ?? "dist/index.js"));
+    const pluginModule = await import(path72.join(pluginRoot, installedPkg.main ?? "dist/index.js"));
     const plugin2 = pluginModule.default;
     if (plugin2?.install) {
       const ctx = createInstallContext2({ pluginName: plugin2.name ?? pkgName, settingsManager, basePath });
@@ -33251,11 +33469,11 @@ async function installPlugin(input2, instanceRoot, json = false) {
 }
 async function uninstallPlugin(name, purge, instanceRoot, json = false) {
   if (json) await muteForJson();
-  const path71 = await import("path");
+  const path72 = await import("path");
   const fs57 = await import("fs");
   const { PluginRegistry: PluginRegistry2 } = await Promise.resolve().then(() => (init_plugin_registry(), plugin_registry_exports));
   const root = instanceRoot;
-  const registryPath = path71.join(root, "plugins.json");
+  const registryPath = path72.join(root, "plugins.json");
   const registry = new PluginRegistry2(registryPath);
   await registry.load();
   const entry = registry.get(name);
@@ -33275,7 +33493,7 @@ async function uninstallPlugin(name, purge, instanceRoot, json = false) {
     if (plugin2?.uninstall) {
       const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
       const { createInstallContext: createInstallContext2 } = await Promise.resolve().then(() => (init_install_context(), install_context_exports));
-      const basePath = path71.join(root, "plugins", "data");
+      const basePath = path72.join(root, "plugins", "data");
       const settingsManager = new SettingsManager2(basePath);
       const ctx = createInstallContext2({ pluginName: name, settingsManager, basePath });
       await plugin2.uninstall(ctx, { purge });
@@ -33283,7 +33501,7 @@ async function uninstallPlugin(name, purge, instanceRoot, json = false) {
   } catch {
   }
   if (purge) {
-    const pluginDir = path71.join(root, "plugins", name);
+    const pluginDir = path72.join(root, "plugins", name);
     fs57.rmSync(pluginDir, { recursive: true, force: true });
   }
   registry.remove(name);
@@ -33324,12 +33542,12 @@ init_helpers();
 init_output();
 import { execSync as execSync2 } from "child_process";
 import * as fs32 from "fs";
-import * as path35 from "path";
+import * as path36 from "path";
 async function cmdUninstall(args2, instanceRoot) {
   const json = isJsonMode(args2);
   if (json) await muteForJson();
   const root = instanceRoot;
-  const pluginsDir = path35.join(root, "plugins");
+  const pluginsDir = path36.join(root, "plugins");
   if (!json && wantsHelp(args2)) {
     console.log(`
 \x1B[1mopenacp uninstall\x1B[0m \u2014 Remove a plugin adapter
@@ -33356,7 +33574,7 @@ async function cmdUninstall(args2, instanceRoot) {
     process.exit(1);
   }
   fs32.mkdirSync(pluginsDir, { recursive: true });
-  const pkgPath = path35.join(pluginsDir, "package.json");
+  const pkgPath = path36.join(pluginsDir, "package.json");
   if (!fs32.existsSync(pkgPath)) {
     fs32.writeFileSync(pkgPath, JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2));
   }
@@ -34202,7 +34420,7 @@ init_helpers();
 init_output();
 init_instance_hint();
 init_resolve_instance_id();
-import path41 from "path";
+import path42 from "path";
 async function cmdStart(args2 = [], instanceRoot) {
   const json = isJsonMode(args2);
   if (json) await muteForJson();
@@ -34232,7 +34450,7 @@ Requires an existing config \u2014 run 'openacp' first to set up.
   await checkAndPromptUpdate();
   const { startDaemon: startDaemon2, getPidPath: getPidPath2, isProcessRunning: isProcessRunning2 } = await Promise.resolve().then(() => (init_daemon2(), daemon_exports));
   const { ConfigManager: ConfigManager2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
-  const cm = new ConfigManager2(path41.join(root, "config.json"));
+  const cm = new ConfigManager2(path42.join(root, "config.json"));
   if (await cm.exists()) {
     await cm.load();
     const config = cm.get();
@@ -34258,12 +34476,12 @@ Requires an existing config \u2014 run 'openacp' first to set up.
     }
     if (json) {
       const { waitForPortFile: waitForPortFile2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
-      const port = await waitForPortFile2(path41.join(root, "api.port")) ?? 21420;
+      const port = await waitForPortFile2(path42.join(root, "api.port")) ?? 21420;
       jsonSuccess({
         pid: result.pid,
         instanceId,
         name: config.instanceName ?? null,
-        directory: path41.dirname(root),
+        directory: path42.dirname(root),
         dir: root,
         port
       });
@@ -34433,7 +34651,7 @@ start fresh with the setup wizard. The daemon must be stopped first.
 `);
     return;
   }
-  const path71 = await import("path");
+  const path72 = await import("path");
   const root = instanceRoot;
   const { getStatus: getStatus2, getPidPath: getPidPath2 } = await Promise.resolve().then(() => (init_daemon2(), daemon_exports));
   const status = getStatus2(getPidPath2(root));
@@ -34595,14 +34813,14 @@ as a messaging thread. Requires a running daemon.
 // src/cli/commands/instances.ts
 init_instance_registry();
 init_instance_context();
-import path60 from "path";
+import path61 from "path";
 import os13 from "os";
 import fs52 from "fs";
 import { randomUUID as randomUUID6 } from "crypto";
 
 // src/core/instance/instance-init.ts
 import fs51 from "fs";
-import path59 from "path";
+import path60 from "path";
 function initInstanceFiles(instanceRoot, opts = {}) {
   fs51.mkdirSync(instanceRoot, { recursive: true });
   writeConfig(instanceRoot, opts);
@@ -34612,7 +34830,7 @@ function initInstanceFiles(instanceRoot, opts = {}) {
   writePluginsIfMissing(instanceRoot);
 }
 function writeConfig(instanceRoot, opts) {
-  const configPath = path59.join(instanceRoot, "config.json");
+  const configPath = path60.join(instanceRoot, "config.json");
   let existing = {};
   if (opts.mergeExisting && fs51.existsSync(configPath)) {
     try {
@@ -34642,7 +34860,7 @@ function writeConfig(instanceRoot, opts) {
   fs51.writeFileSync(configPath, JSON.stringify(config, null, 2));
 }
 function writeAgentsIfMissing(instanceRoot, agents) {
-  const agentsPath = path59.join(instanceRoot, "agents.json");
+  const agentsPath = path60.join(instanceRoot, "agents.json");
   if (fs51.existsSync(agentsPath)) return;
   const installed = {};
   for (const agentName of agents) {
@@ -34661,7 +34879,7 @@ function writeAgentsIfMissing(instanceRoot, agents) {
   fs51.writeFileSync(agentsPath, JSON.stringify({ version: 1, installed }, null, 2));
 }
 function writePluginsIfMissing(instanceRoot) {
-  const pluginsPath = path59.join(instanceRoot, "plugins.json");
+  const pluginsPath = path60.join(instanceRoot, "plugins.json");
   if (!fs51.existsSync(pluginsPath)) {
     fs51.writeFileSync(pluginsPath, JSON.stringify({ version: 1, installed: {} }, null, 2));
   }
@@ -34672,7 +34890,7 @@ init_status();
 init_output();
 init_helpers();
 async function buildInstanceListEntries() {
-  const registryPath = path60.join(getGlobalRoot(), "instances.json");
+  const registryPath = path61.join(getGlobalRoot(), "instances.json");
   const registry = new InstanceRegistry(registryPath);
   registry.load();
   const entries = registry.list();
@@ -34682,7 +34900,7 @@ async function buildInstanceListEntries() {
     return {
       id: entry.id,
       name: info.name,
-      directory: path60.dirname(entry.root),
+      directory: path61.dirname(entry.root),
       root: entry.root,
       status,
       port: info.apiPort
@@ -34775,9 +34993,9 @@ async function cmdInstancesCreate(args2) {
   const agentIdx = args2.indexOf("--agent");
   const agent = agentIdx !== -1 ? args2[agentIdx + 1] : void 0;
   const noInteractive = args2.includes("--no-interactive");
-  const resolvedDir = path60.resolve(rawDir.replace(/^~/, os13.homedir()));
-  const instanceRoot = path60.join(resolvedDir, ".openacp");
-  const registryPath = path60.join(getGlobalRoot(), "instances.json");
+  const resolvedDir = path61.resolve(rawDir.replace(/^~/, os13.homedir()));
+  const instanceRoot = path61.join(resolvedDir, ".openacp");
+  const registryPath = path61.join(getGlobalRoot(), "instances.json");
   const registry = new InstanceRegistry(registryPath);
   registry.load();
   if (fs52.existsSync(instanceRoot)) {
@@ -34802,8 +35020,8 @@ async function cmdInstancesCreate(args2) {
   const name = instanceName ?? `openacp-${registry.list().length + 1}`;
   const id = randomUUID6();
   if (rawFrom) {
-    const fromRoot = path60.join(path60.resolve(rawFrom.replace(/^~/, os13.homedir())), ".openacp");
-    if (!fs52.existsSync(path60.join(fromRoot, "config.json"))) {
+    const fromRoot = path61.join(path61.resolve(rawFrom.replace(/^~/, os13.homedir())), ".openacp");
+    if (!fs52.existsSync(path61.join(fromRoot, "config.json"))) {
       console.error(`Error: No OpenACP instance found at ${rawFrom}`);
       process.exit(1);
     }
@@ -34827,7 +35045,7 @@ async function outputInstance(json, { id, root }) {
   const entry = {
     id,
     name: info.name,
-    directory: path60.dirname(root),
+    directory: path61.dirname(root),
     root,
     status: info.pid ? "running" : "stopped",
     port: info.apiPort
@@ -34836,7 +35054,7 @@ async function outputInstance(json, { id, root }) {
     jsonSuccess(entry);
     return;
   }
-  console.log(`Instance created: ${info.name ?? id} at ${path60.dirname(root)}`);
+  console.log(`Instance created: ${info.name ?? id} at ${path61.dirname(root)}`);
 }
 
 // src/cli/commands/integrate.ts
@@ -35597,15 +35815,15 @@ Options:
 }
 
 // src/cli/commands/onboard.ts
-import * as path61 from "path";
+import * as path62 from "path";
 async function cmdOnboard(instanceRoot) {
   const { ConfigManager: ConfigManager2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
   const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
   const { PluginRegistry: PluginRegistry2 } = await Promise.resolve().then(() => (init_plugin_registry(), plugin_registry_exports));
   const OPENACP_DIR = instanceRoot;
-  const PLUGINS_DATA_DIR = path61.join(OPENACP_DIR, "plugins", "data");
-  const REGISTRY_PATH = path61.join(OPENACP_DIR, "plugins.json");
-  const cm = new ConfigManager2(path61.join(OPENACP_DIR, "config.json"));
+  const PLUGINS_DATA_DIR = path62.join(OPENACP_DIR, "plugins", "data");
+  const REGISTRY_PATH = path62.join(OPENACP_DIR, "plugins.json");
+  const cm = new ConfigManager2(path62.join(OPENACP_DIR, "config.json"));
   const settingsManager = new SettingsManager2(PLUGINS_DATA_DIR);
   const pluginRegistry = new PluginRegistry2(REGISTRY_PATH);
   await pluginRegistry.load();
@@ -35625,15 +35843,15 @@ init_instance_registry();
 init_instance_hint();
 init_output();
 init_resolve_instance_id();
-import path62 from "path";
+import path63 from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 async function cmdDefault(command2, instanceRoot) {
   const args2 = command2 ? [command2] : [];
   const json = isJsonMode(args2);
   if (json) await muteForJson();
   const root = instanceRoot;
-  const pluginsDataDir = path62.join(root, "plugins", "data");
-  const registryPath = path62.join(root, "plugins.json");
+  const pluginsDataDir = path63.join(root, "plugins", "data");
+  const registryPath = path63.join(root, "plugins.json");
   const forceForeground = command2 === "--foreground";
   if (command2 && !command2.startsWith("-")) {
     const { suggestMatch: suggestMatch2 } = await Promise.resolve().then(() => (init_suggest(), suggest_exports));
@@ -35665,7 +35883,7 @@ async function cmdDefault(command2, instanceRoot) {
   }
   await checkAndPromptUpdate();
   const { ConfigManager: ConfigManager2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
-  const configPath = path62.join(root, "config.json");
+  const configPath = path63.join(root, "config.json");
   const cm = new ConfigManager2(configPath);
   if (!await cm.exists()) {
     const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
@@ -35702,12 +35920,12 @@ async function cmdDefault(command2, instanceRoot) {
     }
     if (json) {
       const { waitForPortFile: waitForPortFile2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
-      const port = await waitForPortFile2(path62.join(root, "api.port")) ?? 21420;
+      const port = await waitForPortFile2(path63.join(root, "api.port")) ?? 21420;
       jsonSuccess({
         pid: result.pid,
         instanceId: instanceId2,
         name: config.instanceName ?? null,
-        directory: path62.dirname(root),
+        directory: path63.dirname(root),
         dir: root,
         port
       });
@@ -35720,7 +35938,7 @@ async function cmdDefault(command2, instanceRoot) {
   markRunning2(root);
   printInstanceHint(root);
   const { startServer: startServer2 } = await Promise.resolve().then(() => (init_main(), main_exports));
-  const reg = new InstanceRegistry(path62.join(getGlobalRoot(), "instances.json"));
+  const reg = new InstanceRegistry(path63.join(getGlobalRoot(), "instances.json"));
   reg.load();
   const existingEntry = reg.getByRoot(root);
   const instanceId = existingEntry?.id ?? randomUUID7();
@@ -35734,7 +35952,7 @@ async function cmdDefault(command2, instanceRoot) {
       pid: process.pid,
       instanceId,
       name: config.instanceName ?? null,
-      directory: path62.dirname(root),
+      directory: path63.dirname(root),
       dir: root,
       port
     });
@@ -35803,7 +36021,7 @@ async function showAlreadyRunningMenu(root) {
 // src/cli/commands/dev.ts
 init_helpers();
 import fs53 from "fs";
-import path63 from "path";
+import path64 from "path";
 async function cmdDev(args2 = []) {
   if (wantsHelp(args2)) {
     console.log(`
@@ -35830,12 +36048,12 @@ async function cmdDev(args2 = []) {
     console.error("Error: missing plugin path. Usage: openacp dev <plugin-path>");
     process.exit(1);
   }
-  const pluginPath = path63.resolve(pluginPathArg);
+  const pluginPath = path64.resolve(pluginPathArg);
   if (!fs53.existsSync(pluginPath)) {
     console.error(`Error: plugin path does not exist: ${pluginPath}`);
     process.exit(1);
   }
-  const tsconfigPath = path63.join(pluginPath, "tsconfig.json");
+  const tsconfigPath = path64.join(pluginPath, "tsconfig.json");
   const hasTsconfig = fs53.existsSync(tsconfigPath);
   if (hasTsconfig) {
     console.log("Compiling plugin TypeScript...");
@@ -35877,7 +36095,7 @@ async function cmdDev(args2 = []) {
 
 // src/cli/commands/attach.ts
 init_helpers();
-import path64 from "path";
+import path65 from "path";
 async function cmdAttach(args2 = [], instanceRoot) {
   const root = instanceRoot;
   if (wantsHelp(args2)) {
@@ -35913,15 +36131,15 @@ Press Ctrl+C to detach.
   console.log("");
   const { spawn: spawn9 } = await import("child_process");
   const { expandHome: expandHome4 } = await Promise.resolve().then(() => (init_config2(), config_exports));
-  let logDir2 = path64.join(root, "logs");
+  let logDir2 = path65.join(root, "logs");
   try {
-    const configPath = path64.join(root, "config.json");
+    const configPath = path65.join(root, "config.json");
     const { readFileSync: readFileSync18 } = await import("fs");
     const config = JSON.parse(readFileSync18(configPath, "utf-8"));
     if (config.logging?.logDir) logDir2 = expandHome4(config.logging.logDir);
   } catch {
   }
-  const logFile = path64.join(logDir2, "openacp.log");
+  const logFile = path65.join(logDir2, "openacp.log");
   const tail = spawn9("tail", ["-f", "-n", "50", logFile], { stdio: "inherit" });
   tail.on("error", (err) => {
     console.error(`Cannot tail log file: ${err.message}`);
@@ -35933,7 +36151,7 @@ Press Ctrl+C to detach.
 init_api_client();
 init_instance_registry();
 init_output();
-import path65 from "path";
+import path66 from "path";
 import os14 from "os";
 import qrcode from "qrcode-terminal";
 async function cmdRemote(args2, instanceRoot) {
@@ -35949,7 +36167,7 @@ async function cmdRemote(args2, instanceRoot) {
   const scopes = scopesRaw ? scopesRaw.split(",").map((s) => s.trim()) : void 0;
   let resolvedInstanceRoot2 = instanceRoot;
   if (instanceId) {
-    const registryPath = path65.join(os14.homedir(), ".openacp", "instances.json");
+    const registryPath = path66.join(os14.homedir(), ".openacp", "instances.json");
     const registry = new InstanceRegistry(registryPath);
     await registry.load();
     const entry = registry.get(instanceId);
@@ -36088,7 +36306,7 @@ function extractFlag(args2, flag) {
 init_output();
 init_instance_context();
 init_instance_registry();
-import * as path66 from "path";
+import * as path67 from "path";
 import fs54 from "fs";
 function parseFlag(args2, flag) {
   const idx = args2.indexOf(flag);
@@ -36096,7 +36314,7 @@ function parseFlag(args2, flag) {
 }
 function readConfigField(instanceRoot, field) {
   try {
-    const raw = JSON.parse(fs54.readFileSync(path66.join(instanceRoot, "config.json"), "utf-8"));
+    const raw = JSON.parse(fs54.readFileSync(path67.join(instanceRoot, "config.json"), "utf-8"));
     return typeof raw[field] === "string" ? raw[field] : null;
   } catch {
     return null;
@@ -36119,7 +36337,7 @@ async function cmdSetup(args2, instanceRoot) {
   }
   const runMode = rawRunMode;
   const agents = agentRaw.split(",").map((a) => a.trim());
-  const registryPath = path66.join(getGlobalRoot(), "instances.json");
+  const registryPath = path67.join(getGlobalRoot(), "instances.json");
   const registry = new InstanceRegistry(registryPath);
   registry.load();
   const { id, registryUpdated } = registry.resolveId(instanceRoot);
@@ -36127,9 +36345,9 @@ async function cmdSetup(args2, instanceRoot) {
   if (registryUpdated) {
     registry.save();
   }
-  const name = readConfigField(instanceRoot, "instanceName") ?? path66.basename(path66.dirname(instanceRoot));
+  const name = readConfigField(instanceRoot, "instanceName") ?? path67.basename(path67.dirname(instanceRoot));
   if (!readConfigField(instanceRoot, "instanceName")) {
-    const configPath = path66.join(instanceRoot, "config.json");
+    const configPath = path67.join(instanceRoot, "config.json");
     try {
       const raw = JSON.parse(fs54.readFileSync(configPath, "utf-8"));
       raw.instanceName = name;
@@ -36138,17 +36356,17 @@ async function cmdSetup(args2, instanceRoot) {
     }
   }
   if (json) {
-    jsonSuccess({ id, name, directory: path66.dirname(instanceRoot), configPath: path66.join(instanceRoot, "config.json") });
+    jsonSuccess({ id, name, directory: path67.dirname(instanceRoot), configPath: path67.join(instanceRoot, "config.json") });
   } else {
     console.log(`
-  \x1B[32m\u2713 Setup complete.\x1B[0m Config written to ${path66.join(instanceRoot, "config.json")}
+  \x1B[32m\u2713 Setup complete.\x1B[0m Config written to ${path67.join(instanceRoot, "config.json")}
 `);
   }
 }
 
 // src/cli/commands/autostart.ts
 init_helpers();
-import path67 from "path";
+import path68 from "path";
 async function cmdAutostart(args2 = [], instanceRoot) {
   const subcommand = args2[0];
   if (!subcommand || wantsHelp(args2)) {
@@ -36186,7 +36404,7 @@ async function cmdAutostart(args2 = [], instanceRoot) {
     let logDir2 = `${root}/logs`;
     try {
       const { ConfigManager: ConfigManager2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
-      const cm = new ConfigManager2(path67.join(root, "config.json"));
+      const cm = new ConfigManager2(path68.join(root, "config.json"));
       if (await cm.exists()) {
         await cm.load();
         logDir2 = cm.get().logging?.logDir ?? logDir2;
@@ -36374,7 +36592,7 @@ async function main() {
     if (envRoot) {
       const { createInstanceContext: createInstanceContext2, getGlobalRoot: getGlobal } = await Promise.resolve().then(() => (init_instance_context(), instance_context_exports));
       const { InstanceRegistry: InstanceRegistry2 } = await Promise.resolve().then(() => (init_instance_registry(), instance_registry_exports));
-      const registry = new InstanceRegistry2(path70.join(getGlobal(), "instances.json"));
+      const registry = new InstanceRegistry2(path71.join(getGlobal(), "instances.json"));
       await registry.load();
       const entry = registry.getByRoot(envRoot);
       const { randomUUID: randomUUID9 } = await import("crypto");