@openacp/cli 2026.403.1 → 2026.403.2

package/dist/index.js

@@ -462,22 +462,22 @@ __export(config_registry_exports, {
 });
 import * as fs4 from "fs";
 import * as path4 from "path";
-function getFieldDef(path32) {
-  return CONFIG_REGISTRY.find((f) => f.path === path32);
+function getFieldDef(path33) {
+  return CONFIG_REGISTRY.find((f) => f.path === path33);
 }
 function getSafeFields() {
   return CONFIG_REGISTRY.filter((f) => f.scope === "safe");
 }
-function isHotReloadable(path32) {
-  const def = getFieldDef(path32);
+function isHotReloadable(path33) {
+  const def = getFieldDef(path33);
   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, path32) {
-  const parts = path32.split(".");
+function getConfigValue(config, path33) {
+  const parts = path33.split(".");
   let current = config;
   for (const part of parts) {
     if (current && typeof current === "object" && part in current) {
@@ -1482,7 +1482,115 @@ var init_agents = __esm({
   }
 });
 
+// src/core/plugin/settings-manager.ts
+var settings_manager_exports = {};
+__export(settings_manager_exports, {
+  SettingsManager: () => SettingsManager
+});
+import fs18 from "fs";
+import path17 from "path";
+var SettingsManager, SettingsAPIImpl;
+var init_settings_manager = __esm({
+  "src/core/plugin/settings-manager.ts"() {
+    "use strict";
+    SettingsManager = class {
+      constructor(basePath) {
+        this.basePath = basePath;
+      }
+      getBasePath() {
+        return this.basePath;
+      }
+      createAPI(pluginName) {
+        const settingsPath = this.getSettingsPath(pluginName);
+        return new SettingsAPIImpl(settingsPath);
+      }
+      async loadSettings(pluginName) {
+        const settingsPath = this.getSettingsPath(pluginName);
+        try {
+          const content = fs18.readFileSync(settingsPath, "utf-8");
+          return JSON.parse(content);
+        } catch {
+          return {};
+        }
+      }
+      validateSettings(_pluginName, settings, schema) {
+        if (!schema) return { valid: true };
+        const result = schema.safeParse(settings);
+        if (result.success) return { valid: true };
+        return {
+          valid: false,
+          errors: result.error.errors.map(
+            (e) => `${e.path.join(".")}: ${e.message}`
+          )
+        };
+      }
+      getSettingsPath(pluginName) {
+        return path17.join(this.basePath, pluginName, "settings.json");
+      }
+      async getPluginSettings(pluginName) {
+        return this.loadSettings(pluginName);
+      }
+      async updatePluginSettings(pluginName, updates) {
+        const api = this.createAPI(pluginName);
+        const current = await api.getAll();
+        await api.setAll({ ...current, ...updates });
+      }
+    };
+    SettingsAPIImpl = class {
+      constructor(settingsPath) {
+        this.settingsPath = settingsPath;
+      }
+      cache = null;
+      readFile() {
+        if (this.cache !== null) return this.cache;
+        try {
+          const content = fs18.readFileSync(this.settingsPath, "utf-8");
+          this.cache = JSON.parse(content);
+          return this.cache;
+        } catch {
+          this.cache = {};
+          return this.cache;
+        }
+      }
+      writeFile(data) {
+        const dir = path17.dirname(this.settingsPath);
+        fs18.mkdirSync(dir, { recursive: true });
+        fs18.writeFileSync(this.settingsPath, JSON.stringify(data, null, 2));
+        this.cache = data;
+      }
+      async get(key) {
+        const data = this.readFile();
+        return data[key];
+      }
+      async set(key, value) {
+        const data = this.readFile();
+        data[key] = value;
+        this.writeFile(data);
+      }
+      async getAll() {
+        return { ...this.readFile() };
+      }
+      async setAll(settings) {
+        this.writeFile({ ...settings });
+      }
+      async delete(key) {
+        const data = this.readFile();
+        delete data[key];
+        this.writeFile(data);
+      }
+      async clear() {
+        this.writeFile({});
+      }
+      async has(key) {
+        const data = this.readFile();
+        return key in data;
+      }
+    };
+  }
+});
+
 // src/core/doctor/checks/telegram.ts
+import * as path18 from "path";
 var BOT_TOKEN_REGEX, telegramCheck;
 var init_telegram = __esm({
   "src/core/doctor/checks/telegram.ts"() {
@@ -1497,13 +1605,16 @@ var init_telegram = __esm({
           results.push({ status: "fail", message: "Cannot check Telegram \u2014 config not loaded" });
           return results;
         }
-        const tgConfig = ctx.config.channels.telegram;
-        if (!tgConfig || !tgConfig.enabled) {
-          results.push({ status: "pass", message: "Telegram not enabled (skipped)" });
+        const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
+        const sm = new SettingsManager2(path18.join(ctx.pluginsDir, "data"));
+        const ps = await sm.loadSettings("@openacp/telegram");
+        const legacyCh = ctx.config.channels.telegram;
+        const botToken = ps.botToken ?? legacyCh?.botToken;
+        const chatId = ps.chatId ?? legacyCh?.chatId;
+        if (!botToken && !chatId) {
+          results.push({ status: "pass", message: "Telegram not configured (skipped)" });
           return results;
         }
-        const botToken = tgConfig.botToken;
-        const chatId = tgConfig.chatId;
         if (!botToken || !BOT_TOKEN_REGEX.test(botToken)) {
           results.push({ status: "fail", message: "Bot token format invalid" });
           return results;
@@ -1579,7 +1690,7 @@ var init_telegram = __esm({
 });
 
 // src/core/doctor/checks/storage.ts
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 var storageCheck;
 var init_storage = __esm({
   "src/core/doctor/checks/storage.ts"() {
@@ -1589,28 +1700,28 @@ var init_storage = __esm({
       order: 4,
       async run(ctx) {
         const results = [];
-        if (!fs18.existsSync(ctx.dataDir)) {
+        if (!fs19.existsSync(ctx.dataDir)) {
           results.push({
             status: "fail",
             message: "Data directory ~/.openacp does not exist",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs18.mkdirSync(ctx.dataDir, { recursive: true });
+              fs19.mkdirSync(ctx.dataDir, { recursive: true });
               return { success: true, message: "created directory" };
             }
           });
         } else {
           try {
-            fs18.accessSync(ctx.dataDir, fs18.constants.W_OK);
+            fs19.accessSync(ctx.dataDir, fs19.constants.W_OK);
             results.push({ status: "pass", message: "Data directory exists and writable" });
           } catch {
             results.push({ status: "fail", message: "Data directory not writable" });
           }
         }
-        if (fs18.existsSync(ctx.sessionsPath)) {
+        if (fs19.existsSync(ctx.sessionsPath)) {
           try {
-            const content = fs18.readFileSync(ctx.sessionsPath, "utf-8");
+            const content = fs19.readFileSync(ctx.sessionsPath, "utf-8");
             const data = JSON.parse(content);
             if (typeof data === "object" && data !== null && "sessions" in data) {
               results.push({ status: "pass", message: "Sessions file valid" });
@@ -1621,7 +1732,7 @@ var init_storage = __esm({
                 fixable: true,
                 fixRisk: "risky",
                 fix: async () => {
-                  fs18.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
+                  fs19.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
                   return { success: true, message: "reset sessions file" };
                 }
               });
@@ -1633,7 +1744,7 @@ var init_storage = __esm({
               fixable: true,
               fixRisk: "risky",
               fix: async () => {
-                fs18.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
+                fs19.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
                 return { success: true, message: "reset sessions file" };
               }
             });
@@ -1641,20 +1752,20 @@ var init_storage = __esm({
         } else {
           results.push({ status: "pass", message: "Sessions file not present yet (created on first session)" });
         }
-        if (!fs18.existsSync(ctx.logsDir)) {
+        if (!fs19.existsSync(ctx.logsDir)) {
           results.push({
             status: "warn",
             message: "Log directory does not exist",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs18.mkdirSync(ctx.logsDir, { recursive: true });
+              fs19.mkdirSync(ctx.logsDir, { recursive: true });
               return { success: true, message: "created log directory" };
             }
           });
         } else {
           try {
-            fs18.accessSync(ctx.logsDir, fs18.constants.W_OK);
+            fs19.accessSync(ctx.logsDir, fs19.constants.W_OK);
             results.push({ status: "pass", message: "Log directory exists and writable" });
           } catch {
             results.push({ status: "fail", message: "Log directory not writable" });
@@ -1667,7 +1778,7 @@ var init_storage = __esm({
 });
 
 // src/core/doctor/checks/workspace.ts
-import * as fs19 from "fs";
+import * as fs20 from "fs";
 var workspaceCheck;
 var init_workspace = __esm({
   "src/core/doctor/checks/workspace.ts"() {
@@ -1683,20 +1794,20 @@ var init_workspace = __esm({
           return results;
         }
         const baseDir = expandHome3(ctx.config.workspace.baseDir);
-        if (!fs19.existsSync(baseDir)) {
+        if (!fs20.existsSync(baseDir)) {
           results.push({
             status: "warn",
             message: `Workspace directory does not exist: ${baseDir}`,
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs19.mkdirSync(baseDir, { recursive: true });
+              fs20.mkdirSync(baseDir, { recursive: true });
               return { success: true, message: "created directory" };
             }
           });
         } else {
           try {
-            fs19.accessSync(baseDir, fs19.constants.W_OK);
+            fs20.accessSync(baseDir, fs20.constants.W_OK);
             results.push({ status: "pass", message: `Workspace directory exists: ${baseDir}` });
           } catch {
             results.push({ status: "fail", message: `Workspace directory not writable: ${baseDir}` });
@@ -1709,8 +1820,8 @@ var init_workspace = __esm({
 });
 
 // src/core/doctor/checks/plugins.ts
-import * as fs20 from "fs";
-import * as path17 from "path";
+import * as fs21 from "fs";
+import * as path19 from "path";
 var pluginsCheck;
 var init_plugins = __esm({
   "src/core/doctor/checks/plugins.ts"() {
@@ -1720,16 +1831,16 @@ var init_plugins = __esm({
       order: 6,
       async run(ctx) {
         const results = [];
-        if (!fs20.existsSync(ctx.pluginsDir)) {
+        if (!fs21.existsSync(ctx.pluginsDir)) {
           results.push({
             status: "warn",
             message: "Plugins directory does not exist",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs20.mkdirSync(ctx.pluginsDir, { recursive: true });
-              fs20.writeFileSync(
-                path17.join(ctx.pluginsDir, "package.json"),
+              fs21.mkdirSync(ctx.pluginsDir, { recursive: true });
+              fs21.writeFileSync(
+                path19.join(ctx.pluginsDir, "package.json"),
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
               return { success: true, message: "initialized plugins directory" };
@@ -1738,15 +1849,15 @@ var init_plugins = __esm({
           return results;
         }
         results.push({ status: "pass", message: "Plugins directory exists" });
-        const pkgPath = path17.join(ctx.pluginsDir, "package.json");
-        if (!fs20.existsSync(pkgPath)) {
+        const pkgPath = path19.join(ctx.pluginsDir, "package.json");
+        if (!fs21.existsSync(pkgPath)) {
           results.push({
             status: "warn",
             message: "Plugins package.json missing",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs20.writeFileSync(
+              fs21.writeFileSync(
                 pkgPath,
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
@@ -1756,7 +1867,7 @@ var init_plugins = __esm({
           return results;
         }
         try {
-          const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf-8"));
+          const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
           const deps = pkg.dependencies || {};
           const count = Object.keys(deps).length;
           results.push({ status: "pass", message: `Plugins package.json valid (${count} plugins)` });
@@ -1767,7 +1878,7 @@ var init_plugins = __esm({
             fixable: true,
             fixRisk: "risky",
             fix: async () => {
-              fs20.writeFileSync(
+              fs21.writeFileSync(
                 pkgPath,
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
@@ -1782,7 +1893,7 @@ var init_plugins = __esm({
 });
 
 // src/core/doctor/checks/daemon.ts
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 import * as net from "net";
 function isProcessAlive(pid) {
   try {
@@ -1812,8 +1923,8 @@ var init_daemon = __esm({
       order: 7,
       async run(ctx) {
         const results = [];
-        if (fs21.existsSync(ctx.pidPath)) {
-          const content = fs21.readFileSync(ctx.pidPath, "utf-8").trim();
+        if (fs22.existsSync(ctx.pidPath)) {
+          const content = fs22.readFileSync(ctx.pidPath, "utf-8").trim();
           const pid = parseInt(content, 10);
           if (isNaN(pid)) {
             results.push({
@@ -1822,7 +1933,7 @@ var init_daemon = __esm({
               fixable: true,
               fixRisk: "safe",
               fix: async () => {
-                fs21.unlinkSync(ctx.pidPath);
+                fs22.unlinkSync(ctx.pidPath);
                 return { success: true, message: "removed invalid PID file" };
               }
             });
@@ -1833,7 +1944,7 @@ var init_daemon = __esm({
               fixable: true,
               fixRisk: "safe",
               fix: async () => {
-                fs21.unlinkSync(ctx.pidPath);
+                fs22.unlinkSync(ctx.pidPath);
                 return { success: true, message: "removed stale PID file" };
               }
             });
@@ -1841,8 +1952,8 @@ var init_daemon = __esm({
             results.push({ status: "pass", message: `Daemon running (PID ${pid})` });
           }
         }
-        if (fs21.existsSync(ctx.portFilePath)) {
-          const content = fs21.readFileSync(ctx.portFilePath, "utf-8").trim();
+        if (fs22.existsSync(ctx.portFilePath)) {
+          const content = fs22.readFileSync(ctx.portFilePath, "utf-8").trim();
           const port = parseInt(content, 10);
           if (isNaN(port)) {
             results.push({
@@ -1851,7 +1962,7 @@ var init_daemon = __esm({
               fixable: true,
               fixRisk: "safe",
               fix: async () => {
-                fs21.unlinkSync(ctx.portFilePath);
+                fs22.unlinkSync(ctx.portFilePath);
                 return { success: true, message: "removed invalid port file" };
               }
             });
@@ -1863,8 +1974,8 @@ var init_daemon = __esm({
           const apiPort = ctx.config.api.port;
           const inUse = await checkPortInUse(apiPort);
           if (inUse) {
-            if (fs21.existsSync(ctx.pidPath)) {
-              const pid = parseInt(fs21.readFileSync(ctx.pidPath, "utf-8").trim(), 10);
+            if (fs22.existsSync(ctx.pidPath)) {
+              const pid = parseInt(fs22.readFileSync(ctx.pidPath, "utf-8").trim(), 10);
               if (!isNaN(pid) && isProcessAlive(pid)) {
                 results.push({ status: "pass", message: `API port ${apiPort} in use by OpenACP daemon` });
               } else {
@@ -1884,17 +1995,17 @@ var init_daemon = __esm({
 });
 
 // src/core/utils/install-binary.ts
-import fs22 from "fs";
-import path18 from "path";
+import fs23 from "fs";
+import path20 from "path";
 import https from "https";
 import os9 from "os";
 import { execSync } from "child_process";
 function downloadFile(url, dest) {
   return new Promise((resolve6, reject) => {
-    const file = fs22.createWriteStream(dest);
+    const file = fs23.createWriteStream(dest);
     const cleanup = () => {
       try {
-        if (fs22.existsSync(dest)) fs22.unlinkSync(dest);
+        if (fs23.existsSync(dest)) fs23.unlinkSync(dest);
       } catch {
       }
     };
@@ -1941,34 +2052,34 @@ 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 = path18.join(resolvedBinDir, binName);
+  const binPath = path20.join(resolvedBinDir, binName);
   if (commandExists(spec.name)) {
     log17.debug({ name: spec.name }, "Found in PATH");
     return spec.name;
   }
-  if (fs22.existsSync(binPath)) {
-    if (!IS_WINDOWS) fs22.chmodSync(binPath, "755");
+  if (fs23.existsSync(binPath)) {
+    if (!IS_WINDOWS) fs23.chmodSync(binPath, "755");
     log17.debug({ name: spec.name, path: binPath }, "Found in ~/.openacp/bin");
     return binPath;
   }
   log17.info({ name: spec.name }, "Not found, downloading from GitHub...");
-  fs22.mkdirSync(resolvedBinDir, { recursive: true });
+  fs23.mkdirSync(resolvedBinDir, { recursive: true });
   const url = getDownloadUrl(spec);
   const isArchive = spec.isArchive?.(url) ?? false;
-  const downloadDest = isArchive ? path18.join(resolvedBinDir, `${spec.name}.tgz`) : binPath;
+  const downloadDest = isArchive ? path20.join(resolvedBinDir, `${spec.name}.tgz`) : binPath;
   await downloadFile(url, downloadDest);
   if (isArchive) {
     execSync(`tar -xzf "${downloadDest}" -C "${resolvedBinDir}"`, { stdio: "pipe" });
     try {
-      fs22.unlinkSync(downloadDest);
+      fs23.unlinkSync(downloadDest);
     } catch {
     }
   }
-  if (!fs22.existsSync(binPath)) {
+  if (!fs23.existsSync(binPath)) {
     throw new Error(`${spec.name}: binary not found at ${binPath} after download/extraction. The archive structure may have changed.`);
   }
   if (!IS_WINDOWS) {
-    fs22.chmodSync(binPath, "755");
+    fs23.chmodSync(binPath, "755");
   }
   log17.info({ name: spec.name, path: binPath }, "Installed successfully");
   return binPath;
@@ -1980,7 +2091,7 @@ var init_install_binary = __esm({
     init_log();
     init_agent_dependencies();
     log17 = createChildLogger({ module: "binary-installer" });
-    DEFAULT_BIN_DIR = path18.join(os9.homedir(), ".openacp", "bin");
+    DEFAULT_BIN_DIR = path20.join(os9.homedir(), ".openacp", "bin");
     IS_WINDOWS = os9.platform() === "win32";
   }
 });
@@ -2021,8 +2132,8 @@ var init_install_cloudflared = __esm({
 });
 
 // src/core/doctor/checks/tunnel.ts
-import * as fs23 from "fs";
-import * as path19 from "path";
+import * as fs24 from "fs";
+import * as path21 from "path";
 import * as os10 from "os";
 import { execFileSync as execFileSync4 } from "child_process";
 var tunnelCheck;
@@ -2046,9 +2157,9 @@ var init_tunnel = __esm({
         results.push({ status: "pass", message: `Tunnel provider: ${provider}` });
         if (provider === "cloudflare") {
           const binName = os10.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
-          const binPath = path19.join(ctx.dataDir, "bin", binName);
+          const binPath = path21.join(ctx.dataDir, "bin", binName);
           let found = false;
-          if (fs23.existsSync(binPath)) {
+          if (fs24.existsSync(binPath)) {
             found = true;
           } else {
             try {
@@ -2090,8 +2201,8 @@ var init_tunnel = __esm({
 });
 
 // src/core/doctor/index.ts
-import * as fs24 from "fs";
-import * as path20 from "path";
+import * as fs25 from "fs";
+import * as path22 from "path";
 var ALL_CHECKS, CHECK_TIMEOUT_MS, DoctorEngine;
 var init_doctor = __esm({
   "src/core/doctor/index.ts"() {
@@ -2173,27 +2284,27 @@ var init_doctor = __esm({
       }
       async buildContext() {
         const dataDir = this.dataDir;
-        const configPath = process.env.OPENACP_CONFIG_PATH || path20.join(dataDir, "config.json");
+        const configPath = process.env.OPENACP_CONFIG_PATH || path22.join(dataDir, "config.json");
         let config = null;
         let rawConfig = null;
         try {
-          const content = fs24.readFileSync(configPath, "utf-8");
+          const content = fs25.readFileSync(configPath, "utf-8");
           rawConfig = JSON.parse(content);
           const cm = new ConfigManager(configPath);
           await cm.load();
           config = cm.get();
         } catch {
         }
-        const logsDir = config ? expandHome3(config.logging.logDir) : path20.join(dataDir, "logs");
+        const logsDir = config ? expandHome3(config.logging.logDir) : path22.join(dataDir, "logs");
         return {
           config,
           rawConfig,
           configPath,
           dataDir,
-          sessionsPath: path20.join(dataDir, "sessions.json"),
-          pidPath: path20.join(dataDir, "openacp.pid"),
-          portFilePath: path20.join(dataDir, "api.port"),
-          pluginsDir: path20.join(dataDir, "plugins"),
+          sessionsPath: path22.join(dataDir, "sessions.json"),
+          pidPath: path22.join(dataDir, "openacp.pid"),
+          portFilePath: path22.join(dataDir, "api.port"),
+          pluginsDir: path22.join(dataDir, "plugins"),
           logsDir
         };
       }
@@ -2298,16 +2409,16 @@ __export(plugin_installer_exports, {
 });
 import { exec } from "child_process";
 import { promisify } from "util";
-import * as fs26 from "fs/promises";
+import * as fs27 from "fs/promises";
 import * as os12 from "os";
-import * as path22 from "path";
+import * as path24 from "path";
 import { pathToFileURL } from "url";
 async function importFromDir(packageName, dir) {
-  const pkgDir = path22.join(dir, "node_modules", ...packageName.split("/"));
-  const pkgJsonPath = path22.join(pkgDir, "package.json");
+  const pkgDir = path24.join(dir, "node_modules", ...packageName.split("/"));
+  const pkgJsonPath = path24.join(pkgDir, "package.json");
   let pkgJson;
   try {
-    pkgJson = JSON.parse(await fs26.readFile(pkgJsonPath, "utf-8"));
+    pkgJson = JSON.parse(await fs27.readFile(pkgJsonPath, "utf-8"));
   } catch (err) {
     throw new Error(`Cannot read package.json for "${packageName}" at ${pkgJsonPath}: ${err.message}`);
   }
@@ -2320,9 +2431,9 @@ async function importFromDir(packageName, dir) {
   } else {
     entry = pkgJson.main ?? "index.js";
   }
-  const entryPath = path22.join(pkgDir, entry);
+  const entryPath = path24.join(pkgDir, entry);
   try {
-    await fs26.access(entryPath);
+    await fs27.access(entryPath);
   } catch {
     throw new Error(`Entry point "${entry}" not found for "${packageName}" at ${entryPath}`);
   }
@@ -2332,7 +2443,7 @@ async function installNpmPlugin(packageName, pluginsDir) {
   if (!VALID_NPM_NAME.test(packageName)) {
     throw new Error(`Invalid package name: "${packageName}". Must be a valid npm package name.`);
   }
-  const dir = pluginsDir ?? path22.join(os12.homedir(), ".openacp", "plugins");
+  const dir = pluginsDir ?? path24.join(os12.homedir(), ".openacp", "plugins");
   try {
     return await importFromDir(packageName, dir);
   } catch {
@@ -2351,113 +2462,6 @@ var init_plugin_installer = __esm({
   }
 });
 
-// src/core/plugin/settings-manager.ts
-var settings_manager_exports = {};
-__export(settings_manager_exports, {
-  SettingsManager: () => SettingsManager
-});
-import fs27 from "fs";
-import path23 from "path";
-var SettingsManager, SettingsAPIImpl;
-var init_settings_manager = __esm({
-  "src/core/plugin/settings-manager.ts"() {
-    "use strict";
-    SettingsManager = class {
-      constructor(basePath) {
-        this.basePath = basePath;
-      }
-      getBasePath() {
-        return this.basePath;
-      }
-      createAPI(pluginName) {
-        const settingsPath = this.getSettingsPath(pluginName);
-        return new SettingsAPIImpl(settingsPath);
-      }
-      async loadSettings(pluginName) {
-        const settingsPath = this.getSettingsPath(pluginName);
-        try {
-          const content = fs27.readFileSync(settingsPath, "utf-8");
-          return JSON.parse(content);
-        } catch {
-          return {};
-        }
-      }
-      validateSettings(_pluginName, settings, schema) {
-        if (!schema) return { valid: true };
-        const result = schema.safeParse(settings);
-        if (result.success) return { valid: true };
-        return {
-          valid: false,
-          errors: result.error.errors.map(
-            (e) => `${e.path.join(".")}: ${e.message}`
-          )
-        };
-      }
-      getSettingsPath(pluginName) {
-        return path23.join(this.basePath, pluginName, "settings.json");
-      }
-      async getPluginSettings(pluginName) {
-        return this.loadSettings(pluginName);
-      }
-      async updatePluginSettings(pluginName, updates) {
-        const api = this.createAPI(pluginName);
-        const current = await api.getAll();
-        await api.setAll({ ...current, ...updates });
-      }
-    };
-    SettingsAPIImpl = class {
-      constructor(settingsPath) {
-        this.settingsPath = settingsPath;
-      }
-      cache = null;
-      readFile() {
-        if (this.cache !== null) return this.cache;
-        try {
-          const content = fs27.readFileSync(this.settingsPath, "utf-8");
-          this.cache = JSON.parse(content);
-          return this.cache;
-        } catch {
-          this.cache = {};
-          return this.cache;
-        }
-      }
-      writeFile(data) {
-        const dir = path23.dirname(this.settingsPath);
-        fs27.mkdirSync(dir, { recursive: true });
-        fs27.writeFileSync(this.settingsPath, JSON.stringify(data, null, 2));
-        this.cache = data;
-      }
-      async get(key) {
-        const data = this.readFile();
-        return data[key];
-      }
-      async set(key, value) {
-        const data = this.readFile();
-        data[key] = value;
-        this.writeFile(data);
-      }
-      async getAll() {
-        return { ...this.readFile() };
-      }
-      async setAll(settings) {
-        this.writeFile({ ...settings });
-      }
-      async delete(key) {
-        const data = this.readFile();
-        delete data[key];
-        this.writeFile(data);
-      }
-      async clear() {
-        this.writeFile({});
-      }
-      async has(key) {
-        const data = this.readFile();
-        return key in data;
-      }
-    };
-  }
-});
-
 // src/core/plugin/terminal-io.ts
 import * as clack from "@clack/prompts";
 function isCancel(value) {
@@ -2521,10 +2525,10 @@ var install_context_exports = {};
 __export(install_context_exports, {
   createInstallContext: () => createInstallContext
 });
-import path24 from "path";
+import path25 from "path";
 function createInstallContext(opts) {
   const { pluginName, settingsManager, basePath, legacyConfig, instanceRoot } = opts;
-  const dataDir = path24.join(basePath, pluginName, "data");
+  const dataDir = path25.join(basePath, pluginName, "data");
   return {
     pluginName,
     terminal: createTerminalIO(),
@@ -2552,13 +2556,13 @@ __export(api_client_exports, {
   removeStalePortFile: () => removeStalePortFile
 });
 import * as fs28 from "fs";
-import * as path25 from "path";
+import * as path26 from "path";
 import * as os13 from "os";
 function defaultPortFile(root) {
-  return path25.join(root ?? DEFAULT_ROOT, "api.port");
+  return path26.join(root ?? DEFAULT_ROOT, "api.port");
 }
 function defaultSecretFile(root) {
-  return path25.join(root ?? DEFAULT_ROOT, "api-secret");
+  return path26.join(root ?? DEFAULT_ROOT, "api-secret");
 }
 function readApiPort(portFilePath, instanceRoot) {
   const filePath = portFilePath ?? defaultPortFile(instanceRoot);
@@ -2598,7 +2602,7 @@ var DEFAULT_ROOT;
 var init_api_client = __esm({
   "src/cli/api-client.ts"() {
     "use strict";
-    DEFAULT_ROOT = path25.join(os13.homedir(), ".openacp");
+    DEFAULT_ROOT = path26.join(os13.homedir(), ".openacp");
   }
 });
 
@@ -2633,7 +2637,7 @@ var init_notification = __esm({
 
 // src/plugins/file-service/file-service.ts
 import fs30 from "fs";
-import path28 from "path";
+import path29 from "path";
 import { OggOpusDecoder } from "ogg-opus-decoder";
 import wav from "node-wav";
 function classifyMime(mimeType) {
@@ -2692,7 +2696,7 @@ var init_file_service = __esm({
           const entries = await fs30.promises.readdir(this.baseDir, { withFileTypes: true });
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
-            const dirPath = path28.join(this.baseDir, entry.name);
+            const dirPath = path29.join(this.baseDir, entry.name);
             try {
               const stat = await fs30.promises.stat(dirPath);
               if (stat.mtimeMs < cutoff) {
@@ -2707,10 +2711,10 @@ var init_file_service = __esm({
         return removed;
       }
       async saveFile(sessionId, fileName, data, mimeType) {
-        const sessionDir = path28.join(this.baseDir, sessionId);
+        const sessionDir = path29.join(this.baseDir, sessionId);
         await fs30.promises.mkdir(sessionDir, { recursive: true });
         const safeName = `${Date.now()}-${fileName.replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-        const filePath = path28.join(sessionDir, safeName);
+        const filePath = path29.join(sessionDir, safeName);
         await fs30.promises.writeFile(filePath, data);
         return {
           type: classifyMime(mimeType),
@@ -2724,12 +2728,12 @@ var init_file_service = __esm({
         try {
           const stat = await fs30.promises.stat(filePath);
           if (!stat.isFile()) return null;
-          const ext = path28.extname(filePath).toLowerCase();
+          const ext = path29.extname(filePath).toLowerCase();
           const mimeType = EXT_TO_MIME[ext] || "application/octet-stream";
           return {
             type: classifyMime(mimeType),
             filePath,
-            fileName: path28.basename(filePath),
+            fileName: path29.basename(filePath),
             mimeType,
             size: stat.size
           };
@@ -3253,7 +3257,7 @@ data: ${JSON.stringify(data)}
 
 // src/plugins/api-server/static-server.ts
 import * as fs31 from "fs";
-import * as path29 from "path";
+import * as path30 from "path";
 import { fileURLToPath } from "url";
 var MIME_TYPES, StaticServer;
 var init_static_server = __esm({
@@ -3277,16 +3281,16 @@ var init_static_server = __esm({
         this.uiDir = uiDir;
         if (!this.uiDir) {
           const __filename = fileURLToPath(import.meta.url);
-          const candidate = path29.resolve(path29.dirname(__filename), "../../ui/dist");
-          if (fs31.existsSync(path29.join(candidate, "index.html"))) {
+          const candidate = path30.resolve(path30.dirname(__filename), "../../ui/dist");
+          if (fs31.existsSync(path30.join(candidate, "index.html"))) {
             this.uiDir = candidate;
           }
           if (!this.uiDir) {
-            const publishCandidate = path29.resolve(
-              path29.dirname(__filename),
+            const publishCandidate = path30.resolve(
+              path30.dirname(__filename),
               "../ui"
             );
-            if (fs31.existsSync(path29.join(publishCandidate, "index.html"))) {
+            if (fs31.existsSync(path30.join(publishCandidate, "index.html"))) {
               this.uiDir = publishCandidate;
             }
           }
@@ -3298,12 +3302,12 @@ var init_static_server = __esm({
       serve(req, res) {
         if (!this.uiDir) return false;
         const urlPath = (req.url || "/").split("?")[0];
-        const safePath = path29.normalize(urlPath);
-        const filePath = path29.join(this.uiDir, safePath);
-        if (!filePath.startsWith(this.uiDir + path29.sep) && filePath !== this.uiDir)
+        const safePath = path30.normalize(urlPath);
+        const filePath = path30.join(this.uiDir, safePath);
+        if (!filePath.startsWith(this.uiDir + path30.sep) && filePath !== this.uiDir)
           return false;
         if (fs31.existsSync(filePath) && fs31.statSync(filePath).isFile()) {
-          const ext = path29.extname(filePath);
+          const ext = path30.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";
@@ -3314,7 +3318,7 @@ var init_static_server = __esm({
           fs31.createReadStream(filePath).pipe(res);
           return true;
         }
-        const indexPath = path29.join(this.uiDir, "index.html");
+        const indexPath = path30.join(this.uiDir, "index.html");
         if (fs31.existsSync(indexPath)) {
           res.writeHead(200, {
             "Content-Type": "text/html; charset=utf-8",
@@ -3476,7 +3480,7 @@ var init_exports = __esm({
 
 // src/plugins/context/context-cache.ts
 import * as fs32 from "fs";
-import * as path30 from "path";
+import * as path31 from "path";
 import * as crypto from "crypto";
 var DEFAULT_TTL_MS, ContextCache;
 var init_context_cache = __esm({
@@ -3493,7 +3497,7 @@ var init_context_cache = __esm({
         return crypto.createHash("sha256").update(`${repoPath}:${queryKey}`).digest("hex").slice(0, 16);
       }
       filePath(repoPath, queryKey) {
-        return path30.join(this.cacheDir, `${this.keyHash(repoPath, queryKey)}.json`);
+        return path31.join(this.cacheDir, `${this.keyHash(repoPath, queryKey)}.json`);
       }
       get(repoPath, queryKey) {
         const fp = this.filePath(repoPath, queryKey);
@@ -3517,7 +3521,7 @@ var init_context_cache = __esm({
 
 // src/plugins/context/context-manager.ts
 import * as os15 from "os";
-import * as path31 from "path";
+import * as path32 from "path";
 var ContextManager;
 var init_context_manager = __esm({
   "src/plugins/context/context-manager.ts"() {
@@ -3528,7 +3532,7 @@ var init_context_manager = __esm({
       cache;
       historyStore;
       constructor(cachePath) {
-        this.cache = new ContextCache(cachePath ?? path31.join(os15.homedir(), ".openacp", "cache", "entire"));
+        this.cache = new ContextCache(cachePath ?? path32.join(os15.homedir(), ".openacp", "cache", "entire"));
       }
       setHistoryStore(store) {
         this.historyStore = store;
@@ -4429,8 +4433,8 @@ function formatToolSummary(name, rawInput, displaySummary) {
   }
   if (lowerName === "grep") {
     const pattern = args.pattern ?? "";
-    const path32 = args.path ?? "";
-    return pattern ? `\u{1F50D} Grep "${pattern}"${path32 ? ` in ${path32}` : ""}` : `\u{1F527} ${name}`;
+    const path33 = args.path ?? "";
+    return pattern ? `\u{1F50D} Grep "${pattern}"${path33 ? ` in ${path33}` : ""}` : `\u{1F527} ${name}`;
   }
   if (lowerName === "glob") {
     const pattern = args.pattern ?? "";
@@ -4466,8 +4470,8 @@ function formatToolTitle(name, rawInput, displayTitle) {
   }
   if (lowerName === "grep") {
     const pattern = args.pattern ?? "";
-    const path32 = args.path ?? "";
-    return pattern ? `"${pattern}"${path32 ? ` in ${path32}` : ""}` : name;
+    const path33 = args.path ?? "";
+    return pattern ? `"${pattern}"${path33 ? ` in ${path33}` : ""}` : name;
   }
   if (lowerName === "glob") {
     return String(args.pattern ?? name);
@@ -5608,12 +5612,12 @@ __export(version_exports, {
   runUpdate: () => runUpdate
 });
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname11, join as join20, resolve as resolve5 } from "path";
+import { dirname as dirname11, join as join21, resolve as resolve5 } from "path";
 import { existsSync as existsSync18, readFileSync as readFileSync14 } from "fs";
 function findPackageJson() {
   let dir = dirname11(fileURLToPath2(import.meta.url));
   for (let i = 0; i < 5; i++) {
-    const candidate = join20(dir, "package.json");
+    const candidate = join21(dir, "package.json");
     if (existsSync18(candidate)) return candidate;
     const parent = resolve5(dir, "..");
     if (parent === dir) break;
@@ -6451,7 +6455,7 @@ __export(integrate_exports, {
   uninstallIntegration: () => uninstallIntegration
 });
 import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync12, unlinkSync as unlinkSync7, chmodSync, rmdirSync } from "fs";
-import { join as join21, dirname as dirname12 } from "path";
+import { join as join22, dirname as dirname12 } from "path";
 import { homedir as homedir10 } from "os";
 function expandPath(p) {
   return p.replace(/^~/, homedir10());
@@ -6653,30 +6657,30 @@ async function installIntegration(agentKey, spec) {
     }
     const hooksDir = expandPath(spec.hooksDirPath);
     mkdirSync12(hooksDir, { recursive: true });
-    const injectPath = join21(hooksDir, "openacp-inject-session.sh");
+    const injectPath = join22(hooksDir, "openacp-inject-session.sh");
     writeFileSync12(injectPath, generateInjectScript(agentKey, spec));
     chmodSync(injectPath, 493);
     logs.push(`Created ${injectPath}`);
-    const handoffPath = join21(hooksDir, "openacp-handoff.sh");
+    const handoffPath = join22(hooksDir, "openacp-handoff.sh");
     writeFileSync12(handoffPath, generateHandoffScript(agentKey));
     chmodSync(handoffPath, 493);
     logs.push(`Created ${handoffPath}`);
     if (spec.commandsPath && spec.handoffCommandName) {
       if (spec.commandFormat === "skill") {
-        const skillDir = expandPath(join21(spec.commandsPath, spec.handoffCommandName));
+        const skillDir = expandPath(join22(spec.commandsPath, spec.handoffCommandName));
         mkdirSync12(skillDir, { recursive: true });
-        const skillPath = join21(skillDir, "SKILL.md");
+        const skillPath = join22(skillDir, "SKILL.md");
         writeFileSync12(skillPath, generateHandoffCommand(agentKey, spec));
         logs.push(`Created ${skillPath}`);
       } else {
         const cmdsDir = expandPath(spec.commandsPath);
         mkdirSync12(cmdsDir, { recursive: true });
-        const cmdPath = join21(cmdsDir, `${spec.handoffCommandName}.md`);
+        const cmdPath = join22(cmdsDir, `${spec.handoffCommandName}.md`);
         writeFileSync12(cmdPath, generateHandoffCommand(agentKey, spec));
         logs.push(`Created ${cmdPath}`);
       }
     }
-    const injectFullPath = join21(hooksDir, "openacp-inject-session.sh");
+    const injectFullPath = join22(hooksDir, "openacp-inject-session.sh");
     if (spec.settingsFormat === "hooks_json") {
       mergeHooksJson(spec.settingsPath, spec.hookEvent, injectFullPath);
     } else {
@@ -6694,7 +6698,7 @@ async function uninstallIntegration(agentKey, spec) {
   try {
     const hooksDir = expandPath(spec.hooksDirPath);
     for (const filename of ["openacp-inject-session.sh", "openacp-handoff.sh"]) {
-      const filePath = join21(hooksDir, filename);
+      const filePath = join22(hooksDir, filename);
       if (existsSync19(filePath)) {
         unlinkSync7(filePath);
         logs.push(`Removed ${filePath}`);
@@ -6702,8 +6706,8 @@ async function uninstallIntegration(agentKey, spec) {
     }
     if (spec.commandsPath && spec.handoffCommandName) {
       if (spec.commandFormat === "skill") {
-        const skillDir = expandPath(join21(spec.commandsPath, spec.handoffCommandName));
-        const skillPath = join21(skillDir, "SKILL.md");
+        const skillDir = expandPath(join22(spec.commandsPath, spec.handoffCommandName));
+        const skillPath = join22(skillDir, "SKILL.md");
         if (existsSync19(skillPath)) {
           unlinkSync7(skillPath);
           try {
@@ -6713,7 +6717,7 @@ async function uninstallIntegration(agentKey, spec) {
           logs.push(`Removed ${skillPath}`);
         }
       } else {
-        const cmdPath = expandPath(join21(spec.commandsPath, `${spec.handoffCommandName}.md`));
+        const cmdPath = expandPath(join22(spec.commandsPath, `${spec.handoffCommandName}.md`));
         if (existsSync19(cmdPath)) {
           unlinkSync7(cmdPath);
           logs.push(`Removed ${cmdPath}`);
@@ -6739,7 +6743,7 @@ function buildHandoffItem(agentKey, spec) {
     name: "Handoff",
     description: "Transfer sessions between terminal and messaging platforms",
     isInstalled() {
-      return existsSync19(join21(hooksDir, "openacp-inject-session.sh")) && existsSync19(join21(hooksDir, "openacp-handoff.sh"));
+      return existsSync19(join22(hooksDir, "openacp-inject-session.sh")) && existsSync19(join22(hooksDir, "openacp-handoff.sh"));
     },
     install: () => installIntegration(agentKey, spec),
     uninstall: () => uninstallIntegration(agentKey, spec)
@@ -6753,7 +6757,7 @@ function getSkillBasePath(spec) {
 function buildTunnelItem(spec) {
   if (!spec.commandsPath) return null;
   function getTunnelPath() {
-    return join21(getSkillBasePath(spec), "openacp-tunnel", "SKILL.md");
+    return join22(getSkillBasePath(spec), "openacp-tunnel", "SKILL.md");
   }
   return {
     id: "tunnel",
@@ -15409,19 +15413,19 @@ init_doctor();
 init_config_registry();
 
 // src/core/config/config-editor.ts
-import * as path26 from "path";
+import * as path27 from "path";
 import * as clack2 from "@clack/prompts";
 
 // src/cli/autostart.ts
 init_log();
 import { execFileSync as execFileSync5 } from "child_process";
-import * as fs25 from "fs";
-import * as path21 from "path";
+import * as fs26 from "fs";
+import * as path23 from "path";
 import * as os11 from "os";
 var log18 = createChildLogger({ module: "autostart" });
 var LAUNCHD_LABEL = "com.openacp.daemon";
-var LAUNCHD_PLIST_PATH = path21.join(os11.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-var SYSTEMD_SERVICE_PATH = path21.join(os11.homedir(), ".config", "systemd", "user", "openacp.service");
+var LAUNCHD_PLIST_PATH = path23.join(os11.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+var SYSTEMD_SERVICE_PATH = path23.join(os11.homedir(), ".config", "systemd", "user", "openacp.service");
 function isAutoStartSupported() {
   return process.platform === "darwin" || process.platform === "linux";
 }
@@ -15433,7 +15437,7 @@ function escapeSystemdValue(str) {
   return `"${escaped}"`;
 }
 function generateLaunchdPlist(nodePath, cliPath, logDir2) {
-  const logFile = path21.join(logDir2, "openacp.log");
+  const logFile = path23.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">
@@ -15478,23 +15482,23 @@ function installAutoStart(logDir2) {
     return { success: false, error: "Auto-start not supported on this platform" };
   }
   const nodePath = process.execPath;
-  const cliPath = path21.resolve(process.argv[1]);
-  const resolvedLogDir = logDir2.startsWith("~") ? path21.join(os11.homedir(), logDir2.slice(1)) : logDir2;
+  const cliPath = path23.resolve(process.argv[1]);
+  const resolvedLogDir = logDir2.startsWith("~") ? path23.join(os11.homedir(), logDir2.slice(1)) : logDir2;
   try {
     if (process.platform === "darwin") {
       const plist = generateLaunchdPlist(nodePath, cliPath, resolvedLogDir);
-      const dir = path21.dirname(LAUNCHD_PLIST_PATH);
-      fs25.mkdirSync(dir, { recursive: true });
-      fs25.writeFileSync(LAUNCHD_PLIST_PATH, plist);
+      const dir = path23.dirname(LAUNCHD_PLIST_PATH);
+      fs26.mkdirSync(dir, { recursive: true });
+      fs26.writeFileSync(LAUNCHD_PLIST_PATH, plist);
       execFileSync5("launchctl", ["load", LAUNCHD_PLIST_PATH], { stdio: "pipe" });
       log18.info("LaunchAgent installed");
       return { success: true };
     }
     if (process.platform === "linux") {
       const unit = generateSystemdUnit(nodePath, cliPath);
-      const dir = path21.dirname(SYSTEMD_SERVICE_PATH);
-      fs25.mkdirSync(dir, { recursive: true });
-      fs25.writeFileSync(SYSTEMD_SERVICE_PATH, unit);
+      const dir = path23.dirname(SYSTEMD_SERVICE_PATH);
+      fs26.mkdirSync(dir, { recursive: true });
+      fs26.writeFileSync(SYSTEMD_SERVICE_PATH, unit);
       execFileSync5("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
       execFileSync5("systemctl", ["--user", "enable", "openacp"], { stdio: "pipe" });
       log18.info("systemd user service installed");
@@ -15513,23 +15517,23 @@ function uninstallAutoStart() {
   }
   try {
     if (process.platform === "darwin") {
-      if (fs25.existsSync(LAUNCHD_PLIST_PATH)) {
+      if (fs26.existsSync(LAUNCHD_PLIST_PATH)) {
         try {
           execFileSync5("launchctl", ["unload", LAUNCHD_PLIST_PATH], { stdio: "pipe" });
         } catch {
         }
-        fs25.unlinkSync(LAUNCHD_PLIST_PATH);
+        fs26.unlinkSync(LAUNCHD_PLIST_PATH);
         log18.info("LaunchAgent removed");
       }
       return { success: true };
     }
     if (process.platform === "linux") {
-      if (fs25.existsSync(SYSTEMD_SERVICE_PATH)) {
+      if (fs26.existsSync(SYSTEMD_SERVICE_PATH)) {
         try {
           execFileSync5("systemctl", ["--user", "disable", "openacp"], { stdio: "pipe" });
         } catch {
         }
-        fs25.unlinkSync(SYSTEMD_SERVICE_PATH);
+        fs26.unlinkSync(SYSTEMD_SERVICE_PATH);
         execFileSync5("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
         log18.info("systemd user service removed");
       }
@@ -15544,10 +15548,10 @@ function uninstallAutoStart() {
 }
 function isAutoStartInstalled() {
   if (process.platform === "darwin") {
-    return fs25.existsSync(LAUNCHD_PLIST_PATH);
+    return fs26.existsSync(LAUNCHD_PLIST_PATH);
   }
   if (process.platform === "linux") {
-    return fs25.existsSync(SYSTEMD_SERVICE_PATH);
+    return fs26.existsSync(SYSTEMD_SERVICE_PATH);
   }
   return false;
 }
@@ -15752,7 +15756,7 @@ async function editDiscord(_config, _updates) {
     const { createInstallContext: createInstallContext2 } = await Promise.resolve().then(() => (init_install_context(), install_context_exports));
     const { getGlobalRoot: getGlobalRoot2 } = await Promise.resolve().then(() => (init_instance_context(), instance_context_exports));
     const root = getGlobalRoot2();
-    const basePath = path26.join(root, "plugins");
+    const basePath = path27.join(root, "plugins", "data");
     const settingsManager = new SettingsManager2(basePath);
     const ctx = createInstallContext2({
       pluginName: plugin.name,
@@ -15766,11 +15770,17 @@ async function editDiscord(_config, _updates) {
   }
 }
 async function editChannels(config, updates, settingsManager) {
-  const tgEnabled = config.channels?.telegram?.enabled !== false && config.channels?.telegram;
-  const dcEnabled = config.channels?.discord?.enabled !== false && config.channels?.discord;
+  let tgConfigured = !!config.channels?.telegram;
+  let dcConfigured = !!config.channels?.discord;
+  if (settingsManager) {
+    const tgPs = await settingsManager.loadSettings("@openacp/telegram");
+    if (tgPs.botToken && tgPs.chatId) tgConfigured = true;
+    const dcPs = await settingsManager.loadSettings("@openacp/adapter-discord");
+    if (dcPs.guildId || dcPs.token) dcConfigured = true;
+  }
   console.log(header("Channels"));
-  console.log(`  Telegram : ${tgEnabled ? ok("configured") : dim("not configured")}`);
-  console.log(`  Discord  : ${dcEnabled ? ok("configured") : dim("not configured")}`);
+  console.log(`  Telegram : ${tgConfigured ? ok("configured") : dim("not configured")}`);
+  console.log(`  Discord  : ${dcConfigured ? ok("configured") : dim("not configured")}`);
   console.log("");
   while (true) {
     const choice = await select3({
@@ -16267,17 +16277,17 @@ ${c.cyan}${c.bold}OpenACP Config Editor${c.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: path32, value } of paths) {
+  for (const { path: path33, value } of paths) {
     const res = await call(port, "/api/config", {
       method: "PATCH",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ path: path32, value })
+      body: JSON.stringify({ path: path33, value })
     });
     const data = await res.json();
     if (!res.ok) {
-      console.log(warn(`Failed to update ${path32}: ${data.error}`));
+      console.log(warn(`Failed to update ${path33}: ${data.error}`));
     } else if (data.needsRestart) {
-      console.log(warn(`${path32} updated \u2014 restart required`));
+      console.log(warn(`${path33} updated \u2014 restart required`));
     }
   }
 }
@@ -16298,23 +16308,23 @@ function flattenToPaths(obj, prefix = "") {
 init_config();
 import { spawn as spawn3 } from "child_process";
 import * as fs29 from "fs";
-import * as path27 from "path";
+import * as path28 from "path";
 import * as os14 from "os";
-var DEFAULT_ROOT2 = path27.join(os14.homedir(), ".openacp");
+var DEFAULT_ROOT2 = path28.join(os14.homedir(), ".openacp");
 function getPidPath(root) {
   const base = root ?? DEFAULT_ROOT2;
-  return path27.join(base, "openacp.pid");
+  return path28.join(base, "openacp.pid");
 }
 function getLogDir(root) {
   const base = root ?? DEFAULT_ROOT2;
-  return path27.join(base, "logs");
+  return path28.join(base, "logs");
 }
 function getRunningMarker(root) {
   const base = root ?? DEFAULT_ROOT2;
-  return path27.join(base, "running");
+  return path28.join(base, "running");
 }
 function writePidFile(pidPath, pid) {
-  const dir = path27.dirname(pidPath);
+  const dir = path28.dirname(pidPath);
   fs29.mkdirSync(dir, { recursive: true });
   fs29.writeFileSync(pidPath, String(pid));
 }
@@ -16363,8 +16373,8 @@ function startDaemon(pidPath = getPidPath(), logDir2, instanceRoot) {
   }
   const resolvedLogDir = logDir2 ? expandHome3(logDir2) : getLogDir(instanceRoot);
   fs29.mkdirSync(resolvedLogDir, { recursive: true });
-  const logFile = path27.join(resolvedLogDir, "openacp.log");
-  const cliPath = path27.resolve(process.argv[1]);
+  const logFile = path28.join(resolvedLogDir, "openacp.log");
+  const cliPath = path28.resolve(process.argv[1]);
   const nodePath = process.execPath;
   const out = fs29.openSync(logFile, "a");
   const err = fs29.openSync(logFile, "a");
@@ -16448,7 +16458,7 @@ async function stopDaemon(pidPath = getPidPath(), instanceRoot) {
 }
 function markRunning(root) {
   const marker = getRunningMarker(root);
-  fs29.mkdirSync(path27.dirname(marker), { recursive: true });
+  fs29.mkdirSync(path28.dirname(marker), { recursive: true });
   fs29.writeFileSync(marker, "");
 }
 function clearRunning(root) {