@openacp/cli 2026.402.1 → 2026.402.2

package/dist/cli.js

@@ -9,6 +9,284 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/core/utils/log.ts
+var log_exports = {};
+__export(log_exports, {
+  cleanupOldSessionLogs: () => cleanupOldSessionLogs,
+  closeSessionLogger: () => closeSessionLogger,
+  createChildLogger: () => createChildLogger,
+  createSessionLogger: () => createSessionLogger,
+  initLogger: () => initLogger,
+  log: () => log,
+  muteLogger: () => muteLogger,
+  setLogLevel: () => setLogLevel,
+  shutdownLogger: () => shutdownLogger,
+  unmuteLogger: () => unmuteLogger
+});
+import pino from "pino";
+import fs from "fs";
+import path from "path";
+import os from "os";
+function expandHome(p2) {
+  return p2.startsWith("~") ? path.join(os.homedir(), p2.slice(1)) : p2;
+}
+function wrapVariadic(logger) {
+  return {
+    info: (...args2) => {
+      if (args2.length === 0) return;
+      if (typeof args2[0] === "object" && args2[0] !== null && !(args2[0] instanceof Error)) {
+        logger.info(args2[0], args2.slice(1).join(" "));
+      } else {
+        logger.info(args2.map(String).join(" "));
+      }
+    },
+    warn: (...args2) => {
+      if (args2.length === 0) return;
+      if (typeof args2[0] === "object" && args2[0] !== null && !(args2[0] instanceof Error)) {
+        logger.warn(args2[0], args2.slice(1).join(" "));
+      } else {
+        logger.warn(args2.map(String).join(" "));
+      }
+    },
+    error: (...args2) => {
+      if (args2.length === 0) return;
+      if (typeof args2[0] === "object" && args2[0] !== null && !(args2[0] instanceof Error)) {
+        logger.error(args2[0], args2.slice(1).join(" "));
+      } else {
+        logger.error(args2.map(String).join(" "));
+      }
+    },
+    debug: (...args2) => {
+      if (args2.length === 0) return;
+      if (typeof args2[0] === "object" && args2[0] !== null && !(args2[0] instanceof Error)) {
+        logger.debug(args2[0], args2.slice(1).join(" "));
+      } else {
+        logger.debug(args2.map(String).join(" "));
+      }
+    },
+    fatal: (...args2) => {
+      if (args2.length === 0) return;
+      if (typeof args2[0] === "object" && args2[0] !== null && !(args2[0] instanceof Error)) {
+        logger.fatal(args2[0], args2.slice(1).join(" "));
+      } else {
+        logger.fatal(args2.map(String).join(" "));
+      }
+    },
+    child: (bindings) => logger.child(bindings)
+  };
+}
+function muteLogger() {
+  if (muteCount === 0) {
+    savedLevel = rootLogger.level;
+    rootLogger.level = "silent";
+  }
+  muteCount++;
+}
+function unmuteLogger() {
+  muteCount--;
+  if (muteCount <= 0) {
+    muteCount = 0;
+    rootLogger.level = savedLevel;
+  }
+}
+function initLogger(config) {
+  if (initialized) return rootLogger;
+  const resolvedLogDir = expandHome(config.logDir);
+  logDir = resolvedLogDir;
+  try {
+    fs.mkdirSync(resolvedLogDir, { recursive: true });
+    fs.mkdirSync(path.join(resolvedLogDir, "sessions"), { recursive: true });
+  } catch (err) {
+    console.error(`[WARN] Failed to create log directory ${resolvedLogDir}, falling back to console-only:`, err);
+    return rootLogger;
+  }
+  const transports = pino.transport({
+    targets: [
+      {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "SYS:HH:MM:ss",
+          ignore: "pid,hostname",
+          singleLine: true,
+          destination: 2
+        },
+        level: config.level
+      },
+      {
+        target: "pino-roll",
+        options: {
+          file: path.join(resolvedLogDir, "openacp.log"),
+          size: config.maxFileSize,
+          limit: { count: config.maxFiles }
+        },
+        level: config.level
+      }
+    ]
+  });
+  currentTransport = transports;
+  rootLogger = pino({ level: config.level }, transports);
+  initialized = true;
+  Object.assign(log, wrapVariadic(rootLogger));
+  return rootLogger;
+}
+function setLogLevel(level) {
+  rootLogger.level = level;
+}
+function createChildLogger(context) {
+  return new Proxy({}, {
+    get(_target, prop, receiver) {
+      const child = rootLogger.child(context);
+      const value = Reflect.get(child, prop, receiver);
+      return typeof value === "function" ? value.bind(child) : value;
+    }
+  });
+}
+function createSessionLogger(sessionId, parentLogger) {
+  const sessionLogDir = logDir ? path.join(logDir, "sessions") : void 0;
+  if (!sessionLogDir) {
+    return parentLogger.child({ sessionId });
+  }
+  try {
+    const sessionLogPath = path.join(sessionLogDir, `${sessionId}.log`);
+    const dest = pino.destination(sessionLogPath);
+    const sessionFileLogger = pino({ level: parentLogger.level }, dest).child({ sessionId });
+    const combinedChild = parentLogger.child({ sessionId });
+    const originalInfo = combinedChild.info.bind(combinedChild);
+    const originalWarn = combinedChild.warn.bind(combinedChild);
+    const originalError = combinedChild.error.bind(combinedChild);
+    const originalDebug = combinedChild.debug.bind(combinedChild);
+    const originalFatal = combinedChild.fatal.bind(combinedChild);
+    combinedChild.info = ((objOrMsg, ...rest) => {
+      sessionFileLogger.info(objOrMsg, ...rest);
+      return originalInfo(objOrMsg, ...rest);
+    });
+    combinedChild.warn = ((objOrMsg, ...rest) => {
+      sessionFileLogger.warn(objOrMsg, ...rest);
+      return originalWarn(objOrMsg, ...rest);
+    });
+    combinedChild.error = ((objOrMsg, ...rest) => {
+      sessionFileLogger.error(objOrMsg, ...rest);
+      return originalError(objOrMsg, ...rest);
+    });
+    combinedChild.debug = ((objOrMsg, ...rest) => {
+      sessionFileLogger.debug(objOrMsg, ...rest);
+      return originalDebug(objOrMsg, ...rest);
+    });
+    combinedChild.fatal = ((objOrMsg, ...rest) => {
+      sessionFileLogger.fatal(objOrMsg, ...rest);
+      return originalFatal(objOrMsg, ...rest);
+    });
+    combinedChild.__sessionDest = dest;
+    return combinedChild;
+  } catch (err) {
+    parentLogger.warn({ sessionId, err }, "Failed to create session log file, using combined log only");
+    return parentLogger.child({ sessionId });
+  }
+}
+function closeSessionLogger(logger) {
+  const dest = logger.__sessionDest;
+  if (dest && typeof dest.destroy === "function") {
+    dest.destroy();
+  }
+}
+async function shutdownLogger() {
+  if (!initialized) return;
+  const transport = currentTransport;
+  rootLogger = pino({ level: "debug" });
+  Object.assign(log, wrapVariadic(rootLogger));
+  currentTransport = void 0;
+  logDir = void 0;
+  initialized = false;
+  if (transport) {
+    await new Promise((resolve8) => {
+      const timeout = setTimeout(resolve8, 3e3);
+      transport.on("close", () => {
+        clearTimeout(timeout);
+        resolve8();
+      });
+      transport.end();
+    });
+  }
+}
+async function cleanupOldSessionLogs(retentionDays) {
+  if (!logDir) return;
+  const sessionsDir = path.join(logDir, "sessions");
+  try {
+    const files = await fs.promises.readdir(sessionsDir);
+    const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+    for (const file of files) {
+      try {
+        const filePath = path.join(sessionsDir, file);
+        const stat = await fs.promises.stat(filePath);
+        if (stat.mtimeMs < cutoff) {
+          await fs.promises.unlink(filePath);
+          rootLogger.debug({ file }, "Deleted old session log");
+        }
+      } catch (err) {
+        rootLogger.warn({ file, err }, "Failed to delete old session log");
+      }
+    }
+  } catch {
+  }
+}
+var rootLogger, initialized, logDir, currentTransport, log, muteCount, savedLevel;
+var init_log = __esm({
+  "src/core/utils/log.ts"() {
+    "use strict";
+    rootLogger = pino({
+      level: "debug",
+      transport: { target: "pino-pretty", options: { colorize: true, translateTime: "SYS:standard", destination: 2 } }
+    });
+    initialized = false;
+    log = wrapVariadic(rootLogger);
+    muteCount = 0;
+    savedLevel = "info";
+  }
+});
+
+// src/cli/output.ts
+function isJsonMode(args2) {
+  return args2.includes("--json");
+}
+function jsonSuccess(data) {
+  console.log(JSON.stringify({ success: true, data }));
+  process.exit(0);
+}
+function jsonError(code, message) {
+  console.log(JSON.stringify({ success: false, error: { code, message } }));
+  process.exit(1);
+}
+async function muteForJson() {
+  try {
+    const { muteLogger: muteLogger2 } = await Promise.resolve().then(() => (init_log(), log_exports));
+    muteLogger2();
+  } catch {
+  }
+}
+var ErrorCodes;
+var init_output = __esm({
+  "src/cli/output.ts"() {
+    "use strict";
+    ErrorCodes = {
+      DAEMON_NOT_RUNNING: "DAEMON_NOT_RUNNING",
+      INSTANCE_NOT_FOUND: "INSTANCE_NOT_FOUND",
+      PLUGIN_NOT_FOUND: "PLUGIN_NOT_FOUND",
+      AGENT_NOT_FOUND: "AGENT_NOT_FOUND",
+      CONFIG_INVALID: "CONFIG_INVALID",
+      CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+      SETUP_FAILED: "SETUP_FAILED",
+      API_ERROR: "API_ERROR",
+      TUNNEL_ERROR: "TUNNEL_ERROR",
+      INSTALL_FAILED: "INSTALL_FAILED",
+      UNINSTALL_FAILED: "UNINSTALL_FAILED",
+      MISSING_ARGUMENT: "MISSING_ARGUMENT",
+      UNKNOWN_COMMAND: "UNKNOWN_COMMAND",
+      UNKNOWN_ERROR: "UNKNOWN_ERROR"
+    };
+  }
+});
+
 // src/cli/version.ts
 var version_exports = {};
 __export(version_exports, {
@@ -139,8 +417,8 @@ var plugin_registry_exports = {};
 __export(plugin_registry_exports, {
   PluginRegistry: () => PluginRegistry
 });
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 var PluginRegistry;
 var init_plugin_registry = __esm({
   "src/core/plugin/plugin-registry.ts"() {
@@ -183,7 +461,7 @@ var init_plugin_registry = __esm({
       }
       async load() {
         try {
-          const content = fs3.readFileSync(this.registryPath, "utf-8");
+          const content = fs4.readFileSync(this.registryPath, "utf-8");
           const parsed = JSON.parse(content);
           if (parsed && typeof parsed.installed === "object") {
             this.data = parsed;
@@ -193,9 +471,9 @@ var init_plugin_registry = __esm({
         }
       }
       async save() {
-        const dir = path3.dirname(this.registryPath);
-        fs3.mkdirSync(dir, { recursive: true });
-        fs3.writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));
+        const dir = path4.dirname(this.registryPath);
+        fs4.mkdirSync(dir, { recursive: true });
+        fs4.writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));
       }
     };
   }
@@ -254,14 +532,31 @@ __export(plugin_search_exports, {
   cmdPluginSearch: () => cmdPluginSearch
 });
 async function cmdPluginSearch(args2) {
-  const query = args2.join(" ").trim();
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
+  const query = args2.filter((a) => a !== "--json").join(" ").trim();
   if (!query) {
+    if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Search query is required");
     console.error("Usage: openacp plugin search <query>");
     process.exit(1);
   }
   const client = new RegistryClient();
   try {
     const results = await client.search(query);
+    if (json) {
+      jsonSuccess({
+        results: results.map((p2) => ({
+          name: p2.name,
+          displayName: p2.displayName ?? p2.name,
+          version: p2.version,
+          description: p2.description,
+          npm: p2.npm,
+          category: p2.category,
+          verified: p2.verified ?? false,
+          featured: p2.featured ?? false
+        }))
+      });
+    }
     if (results.length === 0) {
       console.log(`No plugins found matching "${query}"`);
       return;
@@ -279,6 +574,7 @@ Found ${results.length} plugin${results.length > 1 ? "s" : ""} matching "${query
       console.log();
     }
   } catch (err) {
+    if (json) jsonError(ErrorCodes.API_ERROR, `Failed to search registry: ${err}`);
     console.error(`Failed to search registry: ${err}`);
     process.exit(1);
   }
@@ -287,6 +583,7 @@ var init_plugin_search = __esm({
   "src/cli/commands/plugin-search.ts"() {
     "use strict";
     init_registry_client();
+    init_output();
   }
 });
 
@@ -1234,8 +1531,8 @@ __export(plugin_create_exports, {
   cmdPluginCreate: () => cmdPluginCreate
 });
 import * as p from "@clack/prompts";
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 async function cmdPluginCreate() {
   p.intro("Create a new OpenACP plugin");
   const result = await p.group(
@@ -1278,14 +1575,14 @@ async function cmdPluginCreate() {
   );
   const pluginName = result.name.trim();
   const dirName = pluginName.replace(/^@[^/]+\//, "");
-  const targetDir = path4.resolve(process.cwd(), dirName);
-  if (fs4.existsSync(targetDir)) {
+  const targetDir = path5.resolve(process.cwd(), dirName);
+  if (fs5.existsSync(targetDir)) {
     p.cancel(`Directory "${dirName}" already exists.`);
     process.exit(1);
   }
   const spinner4 = p.spinner();
   spinner4.start("Scaffolding plugin...");
-  fs4.mkdirSync(path4.join(targetDir, "src", "__tests__"), { recursive: true });
+  fs5.mkdirSync(path5.join(targetDir, "src", "__tests__"), { recursive: true });
   const params = {
     pluginName,
     description: result.description || "",
@@ -1302,11 +1599,11 @@ async function cmdPluginCreate() {
     { relativePath: "README.md", content: generateReadme(params) },
     { relativePath: "CLAUDE.md", content: generateClaudeMd(params) },
     { relativePath: "PLUGIN_GUIDE.md", content: generatePluginGuide(params) },
-    { relativePath: path4.join("src", "index.ts"), content: generatePluginSource(params) },
-    { relativePath: path4.join("src", "__tests__", "index.test.ts"), content: generatePluginTest(params) }
+    { relativePath: path5.join("src", "index.ts"), content: generatePluginSource(params) },
+    { relativePath: path5.join("src", "__tests__", "index.test.ts"), content: generatePluginTest(params) }
   ];
   for (const file of files) {
-    fs4.writeFileSync(path4.join(targetDir, file.relativePath), file.content);
+    fs5.writeFileSync(path5.join(targetDir, file.relativePath), file.content);
   }
   spinner4.stop("Plugin scaffolded!");
   p.note(
@@ -1478,9 +1775,9 @@ var read_text_file_exports = {};
 __export(read_text_file_exports, {
   readTextFileWithRange: () => readTextFileWithRange
 });
-import fs5 from "fs";
+import fs6 from "fs";
 async function readTextFileWithRange(filePath, options) {
-  const content = await fs5.promises.readFile(filePath, "utf-8");
+  const content = await fs6.promises.readFile(filePath, "utf-8");
   if (!options?.line && !options?.limit) return content;
   const lines = content.split("\n");
   const start = Math.max(0, (options.line ?? 1) - 1);
@@ -1494,8 +1791,8 @@ var init_read_text_file = __esm({
 });
 
 // src/plugins/file-service/file-service.ts
-import fs6 from "fs";
-import path5 from "path";
+import fs7 from "fs";
+import path6 from "path";
 import { OggOpusDecoder } from "ogg-opus-decoder";
 import wav from "node-wav";
 function classifyMime(mimeType) {
@@ -1551,14 +1848,14 @@ var init_file_service = __esm({
         const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
         let removed = 0;
         try {
-          const entries = await fs6.promises.readdir(this.baseDir, { withFileTypes: true });
+          const entries = await fs7.promises.readdir(this.baseDir, { withFileTypes: true });
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
-            const dirPath = path5.join(this.baseDir, entry.name);
+            const dirPath = path6.join(this.baseDir, entry.name);
             try {
-              const stat = await fs6.promises.stat(dirPath);
+              const stat = await fs7.promises.stat(dirPath);
               if (stat.mtimeMs < cutoff) {
-                await fs6.promises.rm(dirPath, { recursive: true, force: true });
+                await fs7.promises.rm(dirPath, { recursive: true, force: true });
                 removed++;
               }
             } catch {
@@ -1569,11 +1866,11 @@ var init_file_service = __esm({
         return removed;
       }
       async saveFile(sessionId, fileName, data, mimeType) {
-        const sessionDir = path5.join(this.baseDir, sessionId);
-        await fs6.promises.mkdir(sessionDir, { recursive: true });
+        const sessionDir = path6.join(this.baseDir, sessionId);
+        await fs7.promises.mkdir(sessionDir, { recursive: true });
         const safeName = `${Date.now()}-${fileName.replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-        const filePath = path5.join(sessionDir, safeName);
-        await fs6.promises.writeFile(filePath, data);
+        const filePath = path6.join(sessionDir, safeName);
+        await fs7.promises.writeFile(filePath, data);
         return {
           type: classifyMime(mimeType),
           filePath,
@@ -1584,14 +1881,14 @@ var init_file_service = __esm({
       }
       async resolveFile(filePath) {
         try {
-          const stat = await fs6.promises.stat(filePath);
+          const stat = await fs7.promises.stat(filePath);
           if (!stat.isFile()) return null;
-          const ext = path5.extname(filePath).toLowerCase();
+          const ext = path6.extname(filePath).toLowerCase();
           const mimeType = EXT_TO_MIME[ext] || "application/octet-stream";
           return {
             type: classifyMime(mimeType),
             filePath,
-            fileName: path5.basename(filePath),
+            fileName: path6.basename(filePath),
             mimeType,
             size: stat.size
           };
@@ -1638,8 +1935,8 @@ var file_service_exports = {};
 __export(file_service_exports, {
   default: () => file_service_default
 });
-import path6 from "path";
-import os3 from "os";
+import path7 from "path";
+import os4 from "os";
 function createFileServicePlugin() {
   return {
     name: "@openacp/file-service",
@@ -1649,7 +1946,7 @@ function createFileServicePlugin() {
     permissions: ["services:register"],
     async install(ctx) {
       const { settings, legacyConfig, terminal } = ctx;
-      const defaultFilesDir = path6.join(ctx.instanceRoot ?? path6.join(os3.homedir(), ".openacp"), "files");
+      const defaultFilesDir = path7.join(ctx.instanceRoot ?? path7.join(os4.homedir(), ".openacp"), "files");
       if (legacyConfig) {
         const filesCfg = legacyConfig.files;
         if (filesCfg) {
@@ -1668,7 +1965,7 @@ function createFileServicePlugin() {
     async configure(ctx) {
       const { terminal, settings } = ctx;
       const current = await settings.getAll();
-      const defaultFilesDir = path6.join(ctx.instanceRoot ?? path6.join(os3.homedir(), ".openacp"), "files");
+      const defaultFilesDir = path7.join(ctx.instanceRoot ?? path7.join(os4.homedir(), ".openacp"), "files");
       const val = await terminal.text({
         message: "File storage directory:",
         defaultValue: current.baseDir ?? defaultFilesDir
@@ -1684,7 +1981,7 @@ function createFileServicePlugin() {
     },
     async setup(ctx) {
       const config = ctx.pluginConfig;
-      const baseDir = config.baseDir ?? path6.join(ctx.instanceRoot, "files");
+      const baseDir = config.baseDir ?? path7.join(ctx.instanceRoot, "files");
       const retentionDays = config.retentionDays ?? 30;
       const service = new FileService(baseDir);
       ctx.registerService("file-service", service);
@@ -1706,8 +2003,8 @@ var init_file_service2 = __esm({
 });
 
 // src/plugins/context/context-cache.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 import * as crypto from "crypto";
 var DEFAULT_TTL_MS, ContextCache;
 var init_context_cache = __esm({
@@ -1718,37 +2015,37 @@ var init_context_cache = __esm({
       constructor(cacheDir, ttlMs = DEFAULT_TTL_MS) {
         this.cacheDir = cacheDir;
         this.ttlMs = ttlMs;
-        fs7.mkdirSync(cacheDir, { recursive: true });
+        fs8.mkdirSync(cacheDir, { recursive: true });
       }
       keyHash(repoPath, queryKey) {
         return crypto.createHash("sha256").update(`${repoPath}:${queryKey}`).digest("hex").slice(0, 16);
       }
       filePath(repoPath, queryKey) {
-        return path7.join(this.cacheDir, `${this.keyHash(repoPath, queryKey)}.json`);
+        return path8.join(this.cacheDir, `${this.keyHash(repoPath, queryKey)}.json`);
       }
       get(repoPath, queryKey) {
         const fp = this.filePath(repoPath, queryKey);
         try {
-          const stat = fs7.statSync(fp);
+          const stat = fs8.statSync(fp);
           if (Date.now() - stat.mtimeMs > this.ttlMs) {
-            fs7.unlinkSync(fp);
+            fs8.unlinkSync(fp);
             return null;
           }
-          return JSON.parse(fs7.readFileSync(fp, "utf-8"));
+          return JSON.parse(fs8.readFileSync(fp, "utf-8"));
         } catch {
           return null;
         }
       }
       set(repoPath, queryKey, result) {
-        fs7.writeFileSync(this.filePath(repoPath, queryKey), JSON.stringify(result));
+        fs8.writeFileSync(this.filePath(repoPath, queryKey), JSON.stringify(result));
       }
     };
   }
 });
 
 // src/plugins/context/context-manager.ts
-import * as os4 from "os";
-import * as path8 from "path";
+import * as os5 from "os";
+import * as path9 from "path";
 var ContextManager;
 var init_context_manager = __esm({
   "src/plugins/context/context-manager.ts"() {
@@ -1759,7 +2056,7 @@ var init_context_manager = __esm({
       cache;
       historyStore;
       constructor(cachePath) {
-        this.cache = new ContextCache(cachePath ?? path8.join(os4.homedir(), ".openacp", "cache", "entire"));
+        this.cache = new ContextCache(cachePath ?? path9.join(os5.homedir(), ".openacp", "cache", "entire"));
       }
       setHistoryStore(store) {
         this.historyStore = store;
@@ -3189,8 +3486,8 @@ var init_history_recorder = __esm({
 });
 
 // src/plugins/context/history/history-store.ts
-import fs8 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path10 from "path";
 var HistoryStore;
 var init_history_store = __esm({
   "src/plugins/context/history/history-store.ts"() {
@@ -3200,14 +3497,14 @@ var init_history_store = __esm({
         this.dir = dir;
       }
       async write(history) {
-        await fs8.promises.mkdir(this.dir, { recursive: true });
+        await fs9.promises.mkdir(this.dir, { recursive: true });
         const filePath = this.filePath(history.sessionId);
-        await fs8.promises.writeFile(filePath, JSON.stringify(history, null, 2));
+        await fs9.promises.writeFile(filePath, JSON.stringify(history, null, 2));
       }
       async read(sessionId) {
         const filePath = this.filePath(sessionId);
         try {
-          const raw = await fs8.promises.readFile(filePath, "utf-8");
+          const raw = await fs9.promises.readFile(filePath, "utf-8");
           return JSON.parse(raw);
         } catch {
           return null;
@@ -3215,7 +3512,7 @@ var init_history_store = __esm({
       }
       async exists(sessionId) {
         try {
-          await fs8.promises.access(this.filePath(sessionId));
+          await fs9.promises.access(this.filePath(sessionId));
           return true;
         } catch {
           return false;
@@ -3223,7 +3520,7 @@ var init_history_store = __esm({
       }
       async list() {
         try {
-          const files = await fs8.promises.readdir(this.dir);
+          const files = await fs9.promises.readdir(this.dir);
           return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
         } catch {
           return [];
@@ -3231,13 +3528,13 @@ var init_history_store = __esm({
       }
       async delete(sessionId) {
         try {
-          await fs8.promises.unlink(this.filePath(sessionId));
+          await fs9.promises.unlink(this.filePath(sessionId));
         } catch {
         }
       }
       filePath(sessionId) {
-        const basename2 = path9.basename(sessionId);
-        const resolved = path9.join(this.dir, `${basename2}.json`);
+        const basename2 = path10.basename(sessionId);
+        const resolved = path10.join(this.dir, `${basename2}.json`);
         if (!resolved.startsWith(this.dir)) {
           throw new Error(`Invalid session ID: ${sessionId}`);
         }
@@ -3252,7 +3549,7 @@ var context_exports = {};
 __export(context_exports, {
   default: () => context_default
 });
-import * as path10 from "path";
+import * as path11 from "path";
 var contextPlugin, context_default;
 var init_context = __esm({
   "src/plugins/context/index.ts"() {
@@ -3293,12 +3590,12 @@ var init_context = __esm({
         }
       },
       async setup(ctx) {
-        const historyDir = path10.join(ctx.instanceRoot, "history");
+        const historyDir = path11.join(ctx.instanceRoot, "history");
         const store = new HistoryStore(historyDir);
         const recorder = new HistoryRecorder(store);
         const sessionManager = ctx.sessions;
         const getRecords = () => sessionManager.listRecords();
-        const cachePath = path10.join(ctx.instanceRoot, "cache", "entire");
+        const cachePath = path11.join(ctx.instanceRoot, "cache", "entire");
         const manager = new ContextManager(cachePath);
         manager.register(new HistoryProvider(store, getRecords));
         manager.register(new EntireProvider());
@@ -3499,16 +3796,16 @@ __export(plugin_installer_exports, {
 });
 import { exec } from "child_process";
 import { promisify } from "util";
-import * as fs9 from "fs/promises";
-import * as os5 from "os";
-import * as path11 from "path";
+import * as fs10 from "fs/promises";
+import * as os6 from "os";
+import * as path12 from "path";
 import { pathToFileURL } from "url";
 async function importFromDir(packageName, dir) {
-  const pkgDir = path11.join(dir, "node_modules", ...packageName.split("/"));
-  const pkgJsonPath = path11.join(pkgDir, "package.json");
+  const pkgDir = path12.join(dir, "node_modules", ...packageName.split("/"));
+  const pkgJsonPath = path12.join(pkgDir, "package.json");
   let pkgJson;
   try {
-    pkgJson = JSON.parse(await fs9.readFile(pkgJsonPath, "utf-8"));
+    pkgJson = JSON.parse(await fs10.readFile(pkgJsonPath, "utf-8"));
   } catch (err) {
     throw new Error(`Cannot read package.json for "${packageName}" at ${pkgJsonPath}: ${err.message}`);
   }
@@ -3521,9 +3818,9 @@ async function importFromDir(packageName, dir) {
   } else {
     entry = pkgJson.main ?? "index.js";
   }
-  const entryPath = path11.join(pkgDir, entry);
+  const entryPath = path12.join(pkgDir, entry);
   try {
-    await fs9.access(entryPath);
+    await fs10.access(entryPath);
   } catch {
     throw new Error(`Entry point "${entry}" not found for "${packageName}" at ${entryPath}`);
   }
@@ -3533,7 +3830,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 ?? path11.join(os5.homedir(), ".openacp", "plugins");
+  const dir = pluginsDir ?? path12.join(os6.homedir(), ".openacp", "plugins");
   try {
     return await importFromDir(packageName, dir);
   } catch {
@@ -3557,7 +3854,7 @@ var speech_exports = {};
 __export(speech_exports, {
   default: () => speech_default
 });
-import path12 from "path";
+import path13 from "path";
 var EDGE_TTS_PLUGIN, speechPlugin, speech_default;
 var init_speech = __esm({
   "src/plugins/speech/index.ts"() {
@@ -3575,7 +3872,7 @@ var init_speech = __esm({
       inheritableKeys: ["tts"],
       async install(ctx) {
         const { terminal, settings, legacyConfig } = ctx;
-        const pluginsDir = ctx.instanceRoot ? path12.join(ctx.instanceRoot, "plugins") : void 0;
+        const pluginsDir = ctx.instanceRoot ? path13.join(ctx.instanceRoot, "plugins") : void 0;
         if (legacyConfig) {
           const speechCfg = legacyConfig.speech;
           if (speechCfg) {
@@ -3678,7 +3975,7 @@ var init_speech = __esm({
         }
       },
       async setup(ctx) {
-        const pluginsDir = ctx.instanceRoot ? path12.join(ctx.instanceRoot, "plugins") : void 0;
+        const pluginsDir = ctx.instanceRoot ? path13.join(ctx.instanceRoot, "plugins") : void 0;
         const config = ctx.pluginConfig;
         const groqApiKey = config.groqApiKey;
         const sttProvider = groqApiKey ? "groq" : null;
@@ -3805,301 +4102,65 @@ var init_notification = __esm({
         for (const adapter of this.adapters.values()) {
           try {
             await adapter.sendNotification(notification);
-          } catch {
-          }
-        }
-      }
-    };
-  }
-});
-
-// src/plugins/notifications/index.ts
-var notifications_exports = {};
-__export(notifications_exports, {
-  default: () => notifications_default
-});
-function createNotificationsPlugin() {
-  return {
-    name: "@openacp/notifications",
-    version: "1.0.0",
-    description: "Cross-session notification routing",
-    essential: false,
-    pluginDependencies: { "@openacp/security": "^1.0.0" },
-    permissions: ["services:register", "kernel:access"],
-    async install(ctx) {
-      const { settings, terminal } = ctx;
-      await settings.setAll({ enabled: true });
-      terminal.log.success("Notifications defaults saved");
-    },
-    async configure(ctx) {
-      const { terminal, settings } = ctx;
-      const current = await settings.getAll();
-      const toggle = await terminal.confirm({
-        message: `Notifications are ${current.enabled !== false ? "enabled" : "disabled"}. Toggle?`,
-        initialValue: false
-      });
-      if (toggle) {
-        const newState = current.enabled === false;
-        await settings.set("enabled", newState);
-        terminal.log.success(`Notifications ${newState ? "enabled" : "disabled"}`);
-      }
-    },
-    async uninstall(ctx, opts) {
-      if (opts.purge) {
-        await ctx.settings.clear();
-        ctx.terminal.log.success("Notifications settings cleared");
-      }
-    },
-    async setup(ctx) {
-      const core = ctx.core;
-      const manager = new NotificationManager(core.adapters);
-      ctx.registerService("notifications", manager);
-      ctx.log.info("Notifications service ready");
-    }
-  };
-}
-var notifications_default;
-var init_notifications = __esm({
-  "src/plugins/notifications/index.ts"() {
-    "use strict";
-    init_notification();
-    notifications_default = createNotificationsPlugin();
-  }
-});
-
-// src/core/utils/log.ts
-var log_exports = {};
-__export(log_exports, {
-  cleanupOldSessionLogs: () => cleanupOldSessionLogs,
-  closeSessionLogger: () => closeSessionLogger,
-  createChildLogger: () => createChildLogger,
-  createSessionLogger: () => createSessionLogger,
-  initLogger: () => initLogger,
-  log: () => log,
-  muteLogger: () => muteLogger,
-  setLogLevel: () => setLogLevel,
-  shutdownLogger: () => shutdownLogger,
-  unmuteLogger: () => unmuteLogger
-});
-import pino from "pino";
-import fs10 from "fs";
-import path13 from "path";
-import os6 from "os";
-function expandHome(p2) {
-  return p2.startsWith("~") ? path13.join(os6.homedir(), p2.slice(1)) : p2;
-}
-function wrapVariadic(logger) {
-  return {
-    info: (...args2) => {
-      if (args2.length === 0) return;
-      if (typeof args2[0] === "object" && args2[0] !== null && !(args2[0] instanceof Error)) {
-        logger.info(args2[0], args2.slice(1).join(" "));
-      } else {
-        logger.info(args2.map(String).join(" "));
-      }
-    },
-    warn: (...args2) => {
-      if (args2.length === 0) return;
-      if (typeof args2[0] === "object" && args2[0] !== null && !(args2[0] instanceof Error)) {
-        logger.warn(args2[0], args2.slice(1).join(" "));
-      } else {
-        logger.warn(args2.map(String).join(" "));
-      }
-    },
-    error: (...args2) => {
-      if (args2.length === 0) return;
-      if (typeof args2[0] === "object" && args2[0] !== null && !(args2[0] instanceof Error)) {
-        logger.error(args2[0], args2.slice(1).join(" "));
-      } else {
-        logger.error(args2.map(String).join(" "));
-      }
-    },
-    debug: (...args2) => {
-      if (args2.length === 0) return;
-      if (typeof args2[0] === "object" && args2[0] !== null && !(args2[0] instanceof Error)) {
-        logger.debug(args2[0], args2.slice(1).join(" "));
-      } else {
-        logger.debug(args2.map(String).join(" "));
-      }
-    },
-    fatal: (...args2) => {
-      if (args2.length === 0) return;
-      if (typeof args2[0] === "object" && args2[0] !== null && !(args2[0] instanceof Error)) {
-        logger.fatal(args2[0], args2.slice(1).join(" "));
-      } else {
-        logger.fatal(args2.map(String).join(" "));
-      }
-    },
-    child: (bindings) => logger.child(bindings)
-  };
-}
-function muteLogger() {
-  if (muteCount === 0) {
-    savedLevel = rootLogger.level;
-    rootLogger.level = "silent";
-  }
-  muteCount++;
-}
-function unmuteLogger() {
-  muteCount--;
-  if (muteCount <= 0) {
-    muteCount = 0;
-    rootLogger.level = savedLevel;
-  }
-}
-function initLogger(config) {
-  if (initialized) return rootLogger;
-  const resolvedLogDir = expandHome(config.logDir);
-  logDir = resolvedLogDir;
-  try {
-    fs10.mkdirSync(resolvedLogDir, { recursive: true });
-    fs10.mkdirSync(path13.join(resolvedLogDir, "sessions"), { recursive: true });
-  } catch (err) {
-    console.error(`[WARN] Failed to create log directory ${resolvedLogDir}, falling back to console-only:`, err);
-    return rootLogger;
-  }
-  const transports = pino.transport({
-    targets: [
-      {
-        target: "pino-pretty",
-        options: {
-          colorize: true,
-          translateTime: "SYS:HH:MM:ss",
-          ignore: "pid,hostname",
-          singleLine: true,
-          destination: 2
-        },
-        level: config.level
-      },
-      {
-        target: "pino-roll",
-        options: {
-          file: path13.join(resolvedLogDir, "openacp.log"),
-          size: config.maxFileSize,
-          limit: { count: config.maxFiles }
-        },
-        level: config.level
-      }
-    ]
-  });
-  currentTransport = transports;
-  rootLogger = pino({ level: config.level }, transports);
-  initialized = true;
-  Object.assign(log, wrapVariadic(rootLogger));
-  return rootLogger;
-}
-function setLogLevel(level) {
-  rootLogger.level = level;
-}
-function createChildLogger(context) {
-  return new Proxy({}, {
-    get(_target, prop, receiver) {
-      const child = rootLogger.child(context);
-      const value = Reflect.get(child, prop, receiver);
-      return typeof value === "function" ? value.bind(child) : value;
-    }
-  });
-}
-function createSessionLogger(sessionId, parentLogger) {
-  const sessionLogDir = logDir ? path13.join(logDir, "sessions") : void 0;
-  if (!sessionLogDir) {
-    return parentLogger.child({ sessionId });
-  }
-  try {
-    const sessionLogPath = path13.join(sessionLogDir, `${sessionId}.log`);
-    const dest = pino.destination(sessionLogPath);
-    const sessionFileLogger = pino({ level: parentLogger.level }, dest).child({ sessionId });
-    const combinedChild = parentLogger.child({ sessionId });
-    const originalInfo = combinedChild.info.bind(combinedChild);
-    const originalWarn = combinedChild.warn.bind(combinedChild);
-    const originalError = combinedChild.error.bind(combinedChild);
-    const originalDebug = combinedChild.debug.bind(combinedChild);
-    const originalFatal = combinedChild.fatal.bind(combinedChild);
-    combinedChild.info = ((objOrMsg, ...rest) => {
-      sessionFileLogger.info(objOrMsg, ...rest);
-      return originalInfo(objOrMsg, ...rest);
-    });
-    combinedChild.warn = ((objOrMsg, ...rest) => {
-      sessionFileLogger.warn(objOrMsg, ...rest);
-      return originalWarn(objOrMsg, ...rest);
-    });
-    combinedChild.error = ((objOrMsg, ...rest) => {
-      sessionFileLogger.error(objOrMsg, ...rest);
-      return originalError(objOrMsg, ...rest);
-    });
-    combinedChild.debug = ((objOrMsg, ...rest) => {
-      sessionFileLogger.debug(objOrMsg, ...rest);
-      return originalDebug(objOrMsg, ...rest);
-    });
-    combinedChild.fatal = ((objOrMsg, ...rest) => {
-      sessionFileLogger.fatal(objOrMsg, ...rest);
-      return originalFatal(objOrMsg, ...rest);
-    });
-    combinedChild.__sessionDest = dest;
-    return combinedChild;
-  } catch (err) {
-    parentLogger.warn({ sessionId, err }, "Failed to create session log file, using combined log only");
-    return parentLogger.child({ sessionId });
-  }
-}
-function closeSessionLogger(logger) {
-  const dest = logger.__sessionDest;
-  if (dest && typeof dest.destroy === "function") {
-    dest.destroy();
+          } catch {
+          }
+        }
+      }
+    };
   }
-}
-async function shutdownLogger() {
-  if (!initialized) return;
-  const transport = currentTransport;
-  rootLogger = pino({ level: "debug" });
-  Object.assign(log, wrapVariadic(rootLogger));
-  currentTransport = void 0;
-  logDir = void 0;
-  initialized = false;
-  if (transport) {
-    await new Promise((resolve8) => {
-      const timeout = setTimeout(resolve8, 3e3);
-      transport.on("close", () => {
-        clearTimeout(timeout);
-        resolve8();
+});
+
+// src/plugins/notifications/index.ts
+var notifications_exports = {};
+__export(notifications_exports, {
+  default: () => notifications_default
+});
+function createNotificationsPlugin() {
+  return {
+    name: "@openacp/notifications",
+    version: "1.0.0",
+    description: "Cross-session notification routing",
+    essential: false,
+    pluginDependencies: { "@openacp/security": "^1.0.0" },
+    permissions: ["services:register", "kernel:access"],
+    async install(ctx) {
+      const { settings, terminal } = ctx;
+      await settings.setAll({ enabled: true });
+      terminal.log.success("Notifications defaults saved");
+    },
+    async configure(ctx) {
+      const { terminal, settings } = ctx;
+      const current = await settings.getAll();
+      const toggle = await terminal.confirm({
+        message: `Notifications are ${current.enabled !== false ? "enabled" : "disabled"}. Toggle?`,
+        initialValue: false
       });
-      transport.end();
-    });
-  }
-}
-async function cleanupOldSessionLogs(retentionDays) {
-  if (!logDir) return;
-  const sessionsDir = path13.join(logDir, "sessions");
-  try {
-    const files = await fs10.promises.readdir(sessionsDir);
-    const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
-    for (const file of files) {
-      try {
-        const filePath = path13.join(sessionsDir, file);
-        const stat = await fs10.promises.stat(filePath);
-        if (stat.mtimeMs < cutoff) {
-          await fs10.promises.unlink(filePath);
-          rootLogger.debug({ file }, "Deleted old session log");
-        }
-      } catch (err) {
-        rootLogger.warn({ file, err }, "Failed to delete old session log");
+      if (toggle) {
+        const newState = current.enabled === false;
+        await settings.set("enabled", newState);
+        terminal.log.success(`Notifications ${newState ? "enabled" : "disabled"}`);
+      }
+    },
+    async uninstall(ctx, opts) {
+      if (opts.purge) {
+        await ctx.settings.clear();
+        ctx.terminal.log.success("Notifications settings cleared");
       }
+    },
+    async setup(ctx) {
+      const core = ctx.core;
+      const manager = new NotificationManager(core.adapters);
+      ctx.registerService("notifications", manager);
+      ctx.log.info("Notifications service ready");
     }
-  } catch {
-  }
+  };
 }
-var rootLogger, initialized, logDir, currentTransport, log, muteCount, savedLevel;
-var init_log = __esm({
-  "src/core/utils/log.ts"() {
+var notifications_default;
+var init_notifications = __esm({
+  "src/plugins/notifications/index.ts"() {
     "use strict";
-    rootLogger = pino({
-      level: "debug",
-      transport: { target: "pino-pretty", options: { colorize: true, translateTime: "SYS:standard", destination: 2 } }
-    });
-    initialized = false;
-    log = wrapVariadic(rootLogger);
-    muteCount = 0;
-    savedLevel = "info";
+    init_notification();
+    notifications_default = createNotificationsPlugin();
   }
 });
 
@@ -9738,6 +9799,14 @@ var init_validators = __esm({
 });
 
 // src/plugins/telegram/topics.ts
+var topics_exports2 = {};
+__export(topics_exports2, {
+  buildDeepLink: () => buildDeepLink,
+  createSessionTopic: () => createSessionTopic,
+  deleteSessionTopic: () => deleteSessionTopic,
+  ensureTopics: () => ensureTopics,
+  renameSessionTopic: () => renameSessionTopic
+});
 async function ensureTopics(bot, chatId, config, saveConfig) {
   let notificationTopicId = config.notificationTopicId;
   let assistantTopicId = config.assistantTopicId;
@@ -10452,76 +10521,328 @@ function setupVerbosityCallbacks(bot, core) {
       "channels.telegram.outputMode"
     );
     try {
-      await ctx.answerCallbackQuery({
-        text: `${OUTPUT_MODE_LABELS[level]} Output mode: ${level}`
-      });
+      await ctx.answerCallbackQuery({
+        text: `${OUTPUT_MODE_LABELS[level]} Output mode: ${level}`
+      });
+    } catch {
+    }
+  });
+}
+async function handleUpdate(ctx, core) {
+  if (!core.requestRestart) {
+    await ctx.reply(
+      "\u26A0\uFE0F Update is not available (no restart handler registered).",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  const { getCurrentVersion: getCurrentVersion2, getLatestVersion: getLatestVersion2, compareVersions: compareVersions2, runUpdate: runUpdate2 } = await Promise.resolve().then(() => (init_version(), version_exports));
+  const current = getCurrentVersion2();
+  const statusMsg = await ctx.reply(
+    `\u{1F50D} Checking for updates... (current: v${escapeHtml4(current)})`,
+    { parse_mode: "HTML" }
+  );
+  const latest = await getLatestVersion2();
+  if (!latest) {
+    await ctx.api.editMessageText(
+      ctx.chat.id,
+      statusMsg.message_id,
+      "\u274C Could not check for updates.",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  if (compareVersions2(current, latest) >= 0) {
+    await ctx.api.editMessageText(
+      ctx.chat.id,
+      statusMsg.message_id,
+      `\u2705 Already up to date (v${escapeHtml4(current)}).`,
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  await ctx.api.editMessageText(
+    ctx.chat.id,
+    statusMsg.message_id,
+    `\u2B07\uFE0F Updating v${escapeHtml4(current)} \u2192 v${escapeHtml4(latest)}...`,
+    { parse_mode: "HTML" }
+  );
+  const ok3 = await runUpdate2();
+  if (!ok3) {
+    await ctx.api.editMessageText(
+      ctx.chat.id,
+      statusMsg.message_id,
+      "\u274C Update failed. Try manually: <code>npm install -g @openacp/cli@latest</code>",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  await ctx.api.editMessageText(
+    ctx.chat.id,
+    statusMsg.message_id,
+    `\u2705 Updated to v${escapeHtml4(latest)}. Restarting...`,
+    { parse_mode: "HTML" }
+  );
+  await new Promise((r) => setTimeout(r, 500));
+  await core.requestRestart();
+}
+async function handleRestart(ctx, core) {
+  if (!core.requestRestart) {
+    await ctx.reply(
+      "\u26A0\uFE0F Restart is not available (no restart handler registered).",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  await ctx.reply(
+    "\u{1F504} <b>Restarting OpenACP...</b>\nRebuilding and restarting. Be back shortly.",
+    { parse_mode: "HTML" }
+  );
+  await new Promise((r) => setTimeout(r, 500));
+  await core.requestRestart();
+}
+var log13, OUTPUT_MODE_LABELS;
+var init_admin = __esm({
+  "src/plugins/telegram/commands/admin.ts"() {
+    "use strict";
+    init_bypass_detection();
+    init_formatting();
+    init_log();
+    log13 = createChildLogger({ module: "telegram-cmd-admin" });
+    OUTPUT_MODE_LABELS = {
+      low: "\u{1F507} Low",
+      medium: "\u{1F4CA} Medium",
+      high: "\u{1F50D} High"
+    };
+  }
+});
+
+// src/plugins/telegram/commands/new-session.ts
+import { InlineKeyboard as InlineKeyboard2 } from "grammy";
+function botFromCtx(ctx) {
+  return { api: ctx.api };
+}
+async function createSessionDirect(ctx, core, chatId, agentName, workspace, onControlMessage) {
+  log14.info({ userId: ctx.from?.id, agentName, workspace }, "New session command (direct)");
+  let threadId;
+  try {
+    const topicName = `\u{1F504} New Session`;
+    threadId = await createSessionTopic(botFromCtx(ctx), chatId, topicName);
+    await ctx.api.sendMessage(chatId, `\u23F3 Setting up session, please wait...`, {
+      message_thread_id: threadId,
+      parse_mode: "HTML"
+    });
+    const session = await core.handleNewSession("telegram", agentName, workspace);
+    session.threadId = String(threadId);
+    await core.sessionManager.patchRecord(session.id, { platform: { topicId: threadId } });
+    const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
+    try {
+      await ctx.api.editForumTopic(chatId, threadId, { name: finalName });
+    } catch {
+    }
+    const controlMsg = await ctx.api.sendMessage(
+      chatId,
+      buildSessionStatusText(session, `\u2705 <b>Session started</b>`),
+      {
+        message_thread_id: threadId,
+        parse_mode: "HTML",
+        reply_markup: buildSessionControlKeyboard(session.id, false, false)
+      }
+    );
+    onControlMessage?.(session.id, controlMsg.message_id);
+    return threadId ?? null;
+  } catch (err) {
+    log14.error({ err }, "Session creation failed");
+    if (threadId) {
+      try {
+        await ctx.api.deleteForumTopic(chatId, threadId);
+      } catch {
+      }
+    }
+    const message = err instanceof Error ? err.message : typeof err === "object" ? JSON.stringify(err) : String(err);
+    await ctx.reply(`\u274C ${escapeHtml4(message)}`, { parse_mode: "HTML" });
+    return null;
+  }
+}
+function cacheWorkspace(agentKey, workspace) {
+  const now = Date.now();
+  if (workspaceCache.size > WS_CACHE_MAX) {
+    for (const [id2, entry] of workspaceCache) {
+      if (now - entry.ts > 5 * 6e4 || workspaceCache.size > WS_CACHE_MAX) {
+        workspaceCache.delete(id2);
+      }
+    }
+  }
+  const id = nextWsId++;
+  workspaceCache.set(id, { agentKey, workspace, ts: now });
+  return id;
+}
+function shortenPath2(ws) {
+  const home = process.env.HOME || "";
+  return home && ws.startsWith(home) ? "~" + ws.slice(home.length) : ws;
+}
+async function showAgentPicker(ctx, core, chatId) {
+  const catalog = core.agentCatalog;
+  const installed = catalog.getAvailable().filter((i) => i.installed);
+  if (installed.length === 0) {
+    await ctx.reply("No agents installed. Use /install to add one.", { parse_mode: "HTML" }).catch(() => {
+    });
+    return;
+  }
+  if (installed.length === 1) {
+    await showWorkspacePicker(ctx, core, chatId, installed[0].key, true);
+    return;
+  }
+  const kb = new InlineKeyboard2();
+  for (let i = 0; i < installed.length; i += 2) {
+    const row = installed.slice(i, i + 2);
+    for (const agent of row) {
+      kb.text(agent.name, `ns:agent:${agent.key}`);
+    }
+    kb.row();
+  }
+  await ctx.reply("<b>\u{1F195} New Session</b>\nSelect an agent:", {
+    parse_mode: "HTML",
+    reply_markup: kb
+  }).catch(() => {
+  });
+}
+async function showWorkspacePicker(ctx, core, chatId, agentKey, newMessage = false) {
+  const records = core.sessionManager.listRecords();
+  const recentWorkspaces = [...new Set(records.map((r) => r.workingDir).filter(Boolean))].slice(0, 5);
+  const config = core.configManager.get();
+  const baseDir = config.workspace.baseDir;
+  const resolvedBaseDir = core.configManager.resolveWorkspace(baseDir);
+  const hasBaseDir = recentWorkspaces.some((ws) => ws === baseDir || ws === resolvedBaseDir);
+  const workspaces = hasBaseDir ? recentWorkspaces : [resolvedBaseDir, ...recentWorkspaces].slice(0, 5);
+  const kb = new InlineKeyboard2();
+  for (const ws of workspaces) {
+    const id = cacheWorkspace(agentKey, ws);
+    kb.text(`\u{1F4C1} ${shortenPath2(ws)}`, `ns:ws:${id}`).row();
+  }
+  kb.text("\u{1F4C1} Custom path...", `ns:custom:${agentKey}`).row();
+  const agentLabel = escapeHtml4(agentKey);
+  const text6 = `<b>\u{1F195} New Session</b>
+Agent: <code>${agentLabel}</code>
+
+Select workspace:`;
+  const opts = { parse_mode: "HTML", reply_markup: kb };
+  if (newMessage) {
+    await ctx.reply(text6, opts).catch(() => {
+    });
+  } else {
+    try {
+      await ctx.editMessageText(text6, opts);
+    } catch {
+      await ctx.reply(text6, opts).catch(() => {
+      });
+    }
+  }
+}
+function setupNewSessionCallbacks(bot, core, chatId, getAssistantSession) {
+  bot.callbackQuery("ns:start", async (ctx) => {
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    await showAgentPicker(ctx, core, chatId);
+  });
+  bot.callbackQuery(/^ns:agent:/, async (ctx) => {
+    const agentKey = ctx.callbackQuery.data.replace("ns:agent:", "");
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    await showWorkspacePicker(ctx, core, chatId, agentKey);
+  });
+  bot.callbackQuery(/^ns:ws:/, async (ctx) => {
+    const id = parseInt(ctx.callbackQuery.data.replace("ns:ws:", ""), 10);
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    const entry = workspaceCache.get(id);
+    if (!entry) {
+      try {
+        await ctx.editMessageText("\u26A0\uFE0F Session expired. Please try again via /menu.");
+      } catch {
+      }
+      return;
+    }
+    workspaceCache.delete(id);
+    try {
+      await ctx.editMessageText(
+        `<b>\u{1F195} New Session</b>
+Agent: <code>${escapeHtml4(entry.agentKey)}</code>
+Workspace: <code>${escapeHtml4(shortenPath2(entry.workspace))}</code>
+
+\u23F3 Creating session...`,
+        { parse_mode: "HTML" }
+      );
     } catch {
     }
-  });
-}
-var log13, OUTPUT_MODE_LABELS;
-var init_admin = __esm({
-  "src/plugins/telegram/commands/admin.ts"() {
-    "use strict";
-    init_bypass_detection();
-    init_formatting();
-    init_log();
-    log13 = createChildLogger({ module: "telegram-cmd-admin" });
-    OUTPUT_MODE_LABELS = {
-      low: "\u{1F507} Low",
-      medium: "\u{1F4CA} Medium",
-      high: "\u{1F50D} High"
-    };
-  }
-});
+    const threadId = await createSessionDirect(ctx, core, chatId, entry.agentKey, entry.workspace);
+    if (threadId) {
+      const { buildDeepLink: buildDeepLink2 } = await Promise.resolve().then(() => (init_topics2(), topics_exports2));
+      const link = buildDeepLink2(chatId, threadId);
+      try {
+        await ctx.editMessageText(
+          `<b>\u2705 Session created</b>
+Agent: <code>${escapeHtml4(entry.agentKey)}</code>
+Workspace: <code>${escapeHtml4(shortenPath2(entry.workspace))}</code>
 
-// src/plugins/telegram/commands/new-session.ts
-function botFromCtx(ctx) {
-  return { api: ctx.api };
-}
-async function createSessionDirect(ctx, core, chatId, agentName, workspace, onControlMessage) {
-  log14.info({ userId: ctx.from?.id, agentName, workspace }, "New session command (direct)");
-  let threadId;
-  try {
-    const topicName = `\u{1F504} New Session`;
-    threadId = await createSessionTopic(botFromCtx(ctx), chatId, topicName);
-    await ctx.api.sendMessage(chatId, `\u23F3 Setting up session, please wait...`, {
-      message_thread_id: threadId,
-      parse_mode: "HTML"
-    });
-    const session = await core.handleNewSession("telegram", agentName, workspace);
-    session.threadId = String(threadId);
-    await core.sessionManager.patchRecord(session.id, { platform: { topicId: threadId } });
-    const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
+<a href="${link}">Open session \u2192</a>`,
+          { parse_mode: "HTML" }
+        );
+      } catch {
+      }
+    } else {
+      try {
+        await ctx.editMessageText(
+          `<b>\u274C Session creation failed</b>
+Agent: <code>${escapeHtml4(entry.agentKey)}</code>
+Workspace: <code>${escapeHtml4(shortenPath2(entry.workspace))}</code>
+
+Try again with /new or /menu`,
+          { parse_mode: "HTML" }
+        );
+      } catch {
+      }
+    }
+  });
+  bot.callbackQuery(/^ns:custom:/, async (ctx) => {
+    const agentKey = ctx.callbackQuery.data.replace("ns:custom:", "");
     try {
-      await ctx.api.editForumTopic(chatId, threadId, { name: finalName });
+      await ctx.answerCallbackQuery();
     } catch {
     }
-    const controlMsg = await ctx.api.sendMessage(
-      chatId,
-      buildSessionStatusText(session, `\u2705 <b>Session started</b>`),
-      {
-        message_thread_id: threadId,
-        parse_mode: "HTML",
-        reply_markup: buildSessionControlKeyboard(session.id, false, false)
+    const assistant = getAssistantSession?.();
+    if (assistant) {
+      try {
+        await ctx.editMessageText(
+          `<b>\u{1F195} New Session</b>
+Agent: <code>${escapeHtml4(agentKey)}</code>
+
+\u{1F4AC} Type your workspace path in the chat below.`,
+          { parse_mode: "HTML" }
+        );
+      } catch {
       }
-    );
-    onControlMessage?.(session.id, controlMsg.message_id);
-    return threadId ?? null;
-  } catch (err) {
-    log14.error({ err }, "Session creation failed");
-    if (threadId) {
+      await assistant.enqueuePrompt(
+        `User wants to create a new session with agent "${agentKey}". Ask them for the workspace (project directory) path, then create the session.`
+      );
+    } else {
       try {
-        await ctx.api.deleteForumTopic(chatId, threadId);
+        await ctx.editMessageText(
+          `Usage: <code>/new ${escapeHtml4(agentKey)} &lt;workspace-path&gt;</code>`,
+          { parse_mode: "HTML" }
+        );
       } catch {
       }
     }
-    const message = err instanceof Error ? err.message : typeof err === "object" ? JSON.stringify(err) : String(err);
-    await ctx.reply(`\u274C ${escapeHtml4(message)}`, { parse_mode: "HTML" });
-    return null;
-  }
+  });
 }
-var log14;
+var log14, WS_CACHE_MAX, workspaceCache, nextWsId;
 var init_new_session = __esm({
   "src/plugins/telegram/commands/new-session.ts"() {
     "use strict";
@@ -10530,11 +10851,74 @@ var init_new_session = __esm({
     init_log();
     init_admin();
     log14 = createChildLogger({ module: "telegram-cmd-new-session" });
+    WS_CACHE_MAX = 50;
+    workspaceCache = /* @__PURE__ */ new Map();
+    nextWsId = 0;
   }
 });
 
 // src/plugins/telegram/commands/session.ts
-import { InlineKeyboard as InlineKeyboard2 } from "grammy";
+import { InlineKeyboard as InlineKeyboard3 } from "grammy";
+async function handleTopics(ctx, core) {
+  try {
+    const allRecords = core.sessionManager.listRecords();
+    const records = allRecords.filter((r) => {
+      const platform2 = r.platform;
+      return !!platform2?.topicId;
+    });
+    const headlessCount = allRecords.length - records.length;
+    if (records.length === 0) {
+      const extra = headlessCount > 0 ? ` (${headlessCount} headless hidden)` : "";
+      await ctx.reply(`No sessions with topics found.${extra}`, { parse_mode: "HTML" });
+      return;
+    }
+    const statusEmoji = {
+      active: "\u{1F7E2}",
+      initializing: "\u{1F7E1}",
+      finished: "\u2705",
+      error: "\u274C",
+      cancelled: "\u26D4"
+    };
+    const statusOrder = { active: 0, initializing: 1, error: 2, finished: 3, cancelled: 4 };
+    records.sort((a, b) => (statusOrder[a.status] ?? 5) - (statusOrder[b.status] ?? 5));
+    const MAX_DISPLAY = 30;
+    const displayed = records.slice(0, MAX_DISPLAY);
+    const lines = displayed.map((r) => {
+      const emoji = statusEmoji[r.status] || "\u26AA";
+      const name = r.name?.trim();
+      const label = name ? escapeHtml4(name) : `<i>${escapeHtml4(r.agentName)} session</i>`;
+      return `${emoji} ${label}  <code>[${r.status}]</code>`;
+    });
+    const header2 = `<b>Sessions: ${records.length}</b>` + (headlessCount > 0 ? ` (${headlessCount} headless hidden)` : "");
+    const truncated = records.length > MAX_DISPLAY ? `
+
+<i>...and ${records.length - MAX_DISPLAY} more</i>` : "";
+    const finishedCount = allRecords.filter((r) => r.status === "finished").length;
+    const errorCount = allRecords.filter((r) => r.status === "error" || r.status === "cancelled").length;
+    const keyboard = new InlineKeyboard3();
+    if (finishedCount > 0) {
+      keyboard.text(`Cleanup finished (${finishedCount})`, "m:cleanup:finished").row();
+    }
+    if (errorCount > 0) {
+      keyboard.text(`Cleanup errors (${errorCount})`, "m:cleanup:errors").row();
+    }
+    if (finishedCount + errorCount > 0) {
+      keyboard.text(`Cleanup all non-active (${finishedCount + errorCount})`, "m:cleanup:all").row();
+    }
+    keyboard.text(`\u26A0\uFE0F Cleanup ALL (${allRecords.length})`, "m:cleanup:everything").row();
+    keyboard.text("Refresh", "m:topics");
+    await ctx.reply(
+      `${header2}
+
+${lines.join("\n")}${truncated}`,
+      { parse_mode: "HTML", reply_markup: keyboard }
+    );
+  } catch (err) {
+    log15.error({ err }, "handleTopics error");
+    await ctx.reply("\u274C Failed to list sessions.", { parse_mode: "HTML" }).catch(() => {
+    });
+  }
+}
 async function handleCleanup(ctx, core, chatId, statuses) {
   const allRecords = core.sessionManager.listRecords();
   const cleanable = allRecords.filter((r) => statuses.includes(r.status));
@@ -10593,7 +10977,7 @@ async function handleCleanupEverything(ctx, core, chatId, systemTopicIds) {
   const activeWarning = activeCount > 0 ? `
 
 \u26A0\uFE0F <b>${activeCount} active session(s) will be cancelled and their agents stopped!</b>` : "";
-  const keyboard = new InlineKeyboard2().text("Yes, delete all", "m:cleanup:everything:confirm").text("Cancel", "m:topics");
+  const keyboard = new InlineKeyboard3().text("Yes, delete all", "m:cleanup:everything:confirm").text("Cancel", "m:topics");
   await ctx.reply(
     `<b>Delete ${cleanable.length} topics?</b>
 
@@ -10676,6 +11060,13 @@ function setupSessionCallbacks(bot, core, chatId, systemTopicIds) {
         break;
     }
   });
+  bot.callbackQuery("m:topics", async (ctx) => {
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    await handleTopics(ctx, core);
+  });
 }
 async function handleArchiveConfirm(ctx, core, chatId) {
   const data = ctx.callbackQuery?.data;
@@ -11087,7 +11478,73 @@ var init_integrate = __esm({
 });
 
 // src/plugins/telegram/commands/agents.ts
-import { InlineKeyboard as InlineKeyboard3 } from "grammy";
+import { InlineKeyboard as InlineKeyboard4 } from "grammy";
+async function handleAgents(ctx, core, page = 0) {
+  const catalog = core.agentCatalog;
+  const items = catalog.getAvailable();
+  const installed = items.filter((i) => i.installed);
+  const available = items.filter((i) => !i.installed);
+  let text6 = "<b>\u{1F916} Agents</b>\n\n";
+  if (installed.length > 0) {
+    text6 += "<b>Installed:</b>\n";
+    for (const item of installed) {
+      text6 += `\u2705 <b>${escapeHtml4(item.name)}</b>`;
+      if (item.description) {
+        text6 += ` \u2014 <i>${escapeHtml4(truncate(item.description, 50))}</i>`;
+      }
+      text6 += "\n";
+    }
+    text6 += "\n";
+  }
+  if (available.length > 0) {
+    const totalPages = Math.ceil(available.length / AGENTS_PER_PAGE);
+    const safePage = Math.max(0, Math.min(page, totalPages - 1));
+    const pageItems = available.slice(safePage * AGENTS_PER_PAGE, (safePage + 1) * AGENTS_PER_PAGE);
+    text6 += `<b>Available to install:</b>`;
+    if (totalPages > 1) {
+      text6 += ` (${safePage + 1}/${totalPages})`;
+    }
+    text6 += "\n";
+    for (const item of pageItems) {
+      if (item.available) {
+        text6 += `\u2B07\uFE0F <b>${escapeHtml4(item.name)}</b>`;
+      } else {
+        const deps = item.missingDeps?.join(", ") ?? "requirements not met";
+        text6 += `\u26A0\uFE0F <b>${escapeHtml4(item.name)}</b> <i>(needs: ${escapeHtml4(deps)})</i>`;
+      }
+      if (item.description) {
+        text6 += `
+    <i>${escapeHtml4(truncate(item.description, 60))}</i>`;
+      }
+      text6 += "\n";
+    }
+    const keyboard = new InlineKeyboard4();
+    const installable = pageItems.filter((i) => i.available);
+    for (let i = 0; i < installable.length; i += 2) {
+      const row = installable.slice(i, i + 2);
+      for (const item of row) {
+        keyboard.text(`\u2B07\uFE0F ${item.name}`, `ag:install:${item.key}`);
+      }
+      keyboard.row();
+    }
+    if (totalPages > 1) {
+      if (safePage > 0) {
+        keyboard.text("\u25C0\uFE0F Prev", `ag:page:${safePage - 1}`);
+      }
+      if (safePage < totalPages - 1) {
+        keyboard.text("Next \u25B6\uFE0F", `ag:page:${safePage + 1}`);
+      }
+      keyboard.row();
+    }
+    if (available.some((i) => !i.available)) {
+      text6 += "\n\u{1F4A1} <i>Agents marked \u26A0\uFE0F need additional setup. Use</i> <code>openacp agents info &lt;name&gt;</code> <i>for details.</i>\n";
+    }
+    await ctx.reply(text6, { parse_mode: "HTML", reply_markup: keyboard });
+  } else {
+    text6 += "<i>All agents are already installed!</i>";
+    await ctx.reply(text6, { parse_mode: "HTML" });
+  }
+}
 async function handleAgentCallback(ctx, core) {
   const data = ctx.callbackQuery?.data ?? "";
   await ctx.answerCallbackQuery();
@@ -11136,7 +11593,7 @@ async function handleAgentCallback(ctx, core) {
         }
         text6 += "\n";
       }
-      const keyboard = new InlineKeyboard3();
+      const keyboard = new InlineKeyboard4();
       const installable = pageItems.filter((i) => i.available);
       for (let i = 0; i < installable.length; i += 2) {
         const row = installable.slice(i, i + 2);
@@ -11191,7 +11648,7 @@ Downloading... ${bar} ${percent}%`, { parse_mode: "HTML" });
     },
     async onSuccess(name) {
       try {
-        const keyboard = new InlineKeyboard3().text(`\u{1F680} Start session with ${name}`, `na:${nameOrId}`);
+        const keyboard = new InlineKeyboard4().text(`\u{1F680} Start session with ${name}`, `na:${nameOrId}`);
         await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u2705 <b>${escapeHtml4(name)}</b> installed!`, { parse_mode: "HTML", reply_markup: keyboard });
       } catch {
       }
@@ -11309,13 +11766,13 @@ __export(menu_exports, {
   handleHelp: () => handleHelp,
   handleMenu: () => handleMenu
 });
-import { InlineKeyboard as InlineKeyboard4 } from "grammy";
+import { InlineKeyboard as InlineKeyboard5 } from "grammy";
 function buildMenuKeyboard(menuRegistry) {
   if (!menuRegistry) {
-    return new InlineKeyboard4().text("\u{1F195} New Session", "m:core:new").text("\u{1F4CB} Sessions", "m:core:sessions").row().text("\u{1F4CA} Status", "m:core:status").text("\u{1F916} Agents", "m:core:agents").row().text("\u2753 Help", "m:core:help");
+    return new InlineKeyboard5().text("\u{1F195} New Session", "m:core:new").text("\u{1F4CB} Sessions", "m:core:sessions").row().text("\u{1F4CA} Status", "m:core:status").text("\u{1F916} Agents", "m:core:agents").row().text("\u2753 Help", "m:core:help");
   }
   const items = menuRegistry.getItems();
-  const kb = new InlineKeyboard4();
+  const kb = new InlineKeyboard5();
   let currentGroup;
   let rowCount = 0;
   for (const item of items) {
@@ -11333,11 +11790,11 @@ function buildMenuKeyboard(menuRegistry) {
   }
   return kb;
 }
-async function handleMenu(ctx) {
+async function handleMenu(ctx, menuRegistry) {
   await ctx.reply(`<b>OpenACP Menu</b>
 Choose an action:`, {
     parse_mode: "HTML",
-    reply_markup: buildMenuKeyboard()
+    reply_markup: buildMenuKeyboard(menuRegistry)
   });
 }
 async function handleHelp(ctx) {
@@ -11354,7 +11811,7 @@ Each session gets its own topic \u2014 chat there to work with the agent.
 /status \u2014 Show session or system status
 /sessions \u2014 List all sessions
 /agents \u2014 Browse & install agents
-/install <name> \u2014 Install an agent
+/install &lt;name&gt; \u2014 Install an agent
 
 \u2699\uFE0F <b>System</b>
 /restart \u2014 Restart OpenACP
@@ -11418,11 +11875,11 @@ var init_menu = __esm({
 });
 
 // src/plugins/telegram/commands/settings.ts
-import { InlineKeyboard as InlineKeyboard5 } from "grammy";
+import { InlineKeyboard as InlineKeyboard6 } from "grammy";
 function buildSettingsKeyboard(core) {
   const config = core.configManager.get();
   const fields = getSafeFields();
-  const kb = new InlineKeyboard5();
+  const kb = new InlineKeyboard6();
   for (const field of fields) {
     const value = getConfigValue(config, field.path);
     const label = formatFieldLabel(field, value);
@@ -11454,6 +11911,14 @@ function formatFieldLabel(field, value) {
   const displayValue = value === null || value === void 0 ? "Not set" : String(value);
   return `${icon} ${field.displayName}: ${displayValue}`;
 }
+async function handleSettings(ctx, core) {
+  const kb = buildSettingsKeyboard(core);
+  await ctx.reply(`<b>\u2699\uFE0F Settings</b>
+Tap to change:`, {
+    parse_mode: "HTML",
+    reply_markup: kb
+  });
+}
 function setupSettingsCallbacks(bot, core, getAssistantSession) {
   bot.callbackQuery(/^s:toggle:/, async (ctx) => {
     const fieldPath = ctx.callbackQuery.data.replace("s:toggle:", "");
@@ -11487,7 +11952,7 @@ function setupSettingsCallbacks(bot, core, getAssistantSession) {
     if (!fieldDef) return;
     const options = resolveOptions(fieldDef, config) ?? [];
     const currentValue = getConfigValue(config, fieldPath);
-    const kb = new InlineKeyboard5();
+    const kb = new InlineKeyboard6();
     for (const opt of options) {
       const marker = opt === String(currentValue) ? " \u2713" : "";
       kb.text(`${opt}${marker}`, `s:pick:${fieldPath}:${opt}`).row();
@@ -11581,11 +12046,12 @@ Tap to change:`, {
     } catch {
     }
     const { buildMenuKeyboard: buildMenuKeyboard2 } = await Promise.resolve().then(() => (init_menu(), menu_exports));
+    const menuRegistry = core.lifecycleManager?.serviceRegistry?.get("menu-registry");
     try {
       await ctx.editMessageText(`<b>OpenACP Menu</b>
 Choose an action:`, {
         parse_mode: "HTML",
-        reply_markup: buildMenuKeyboard2()
+        reply_markup: buildMenuKeyboard2(menuRegistry)
       });
     } catch {
     }
@@ -12335,7 +12801,7 @@ var init_doctor = __esm({
 });
 
 // src/plugins/telegram/commands/doctor.ts
-import { InlineKeyboard as InlineKeyboard6 } from "grammy";
+import { InlineKeyboard as InlineKeyboard7 } from "grammy";
 function renderReport(report) {
   const icons = { pass: "\u2705", warn: "\u26A0\uFE0F", fail: "\u274C" };
   const lines = ["\u{1FA7A} <b>OpenACP Doctor</b>\n"];
@@ -12351,7 +12817,7 @@ function renderReport(report) {
   lines.push(`<b>Result:</b> ${passed} passed, ${warnings} warnings, ${failed} failed${fixedStr}`);
   let keyboard;
   if (report.pendingFixes.length > 0) {
-    keyboard = new InlineKeyboard6();
+    keyboard = new InlineKeyboard7();
     for (let i = 0; i < report.pendingFixes.length; i++) {
       const label = `\u{1F527} Fix: ${report.pendingFixes[i].message.slice(0, 30)}`;
       keyboard.text(label, `m:doctor:fix:${i}`).row();
@@ -12449,7 +12915,7 @@ var init_doctor2 = __esm({
 });
 
 // src/plugins/telegram/commands/tunnel.ts
-import { InlineKeyboard as InlineKeyboard7 } from "grammy";
+import { InlineKeyboard as InlineKeyboard8 } from "grammy";
 function setupTunnelCallbacks(bot, core) {
   bot.callbackQuery(/^tn:/, async (ctx) => {
     const data = ctx.callbackQuery.data;
@@ -12476,7 +12942,7 @@ function setupTunnelCallbacks(bot, core) {
         if (remaining2.length === 0) {
           await ctx.editMessageText("\u{1F50C} All tunnels stopped.", { parse_mode: "HTML" });
         } else {
-          const kb = new InlineKeyboard7();
+          const kb = new InlineKeyboard8();
           for (const e of remaining2) {
             kb.text(`\u{1F50C} Stop ${e.port}${e.label ? ` (${e.label})` : ""}`, `tn:stop:${e.port}`).row();
           }
@@ -12513,7 +12979,7 @@ var init_tunnel4 = __esm({
 });
 
 // src/plugins/telegram/commands/switch.ts
-import { InlineKeyboard as InlineKeyboard8 } from "grammy";
+import { InlineKeyboard as InlineKeyboard9 } from "grammy";
 async function executeSwitchAgent(ctx, core, sessionId, agentName) {
   try {
     const { resumed } = await core.switchSessionAgent(sessionId, agentName);
@@ -12540,7 +13006,7 @@ function setupSwitchCallbacks(bot, core) {
       return;
     }
     if (session.promptRunning) {
-      const keyboard = new InlineKeyboard8();
+      const keyboard = new InlineKeyboard9();
       keyboard.text("Yes, switch now", `swc:${agentName}`).text("Cancel", "swc:cancel");
       await ctx.reply(
         `A prompt is currently running. Switching will interrupt it.
@@ -12580,10 +13046,35 @@ var init_switch = __esm({
   }
 });
 
+// src/plugins/telegram/commands/telegram-overrides.ts
+var TELEGRAM_OVERRIDES;
+var init_telegram_overrides = __esm({
+  "src/plugins/telegram/commands/telegram-overrides.ts"() {
+    "use strict";
+    init_agents2();
+    init_session();
+    init_doctor2();
+    init_admin();
+    init_menu();
+    TELEGRAM_OVERRIDES = {
+      agents: (ctx, core) => handleAgents(ctx, core),
+      sessions: (ctx, core) => handleTopics(ctx, core),
+      doctor: (ctx) => handleDoctor(ctx),
+      update: (ctx, core) => handleUpdate(ctx, core),
+      restart: (ctx, core) => handleRestart(ctx, core),
+      help: (ctx) => handleHelp(ctx),
+      menu: (ctx, core) => {
+        const menuRegistry = core.lifecycleManager?.serviceRegistry?.get("menu-registry");
+        return handleMenu(ctx, menuRegistry);
+      }
+    };
+  }
+});
+
 // src/plugins/telegram/commands/integrate.ts
-import { InlineKeyboard as InlineKeyboard9 } from "grammy";
+import { InlineKeyboard as InlineKeyboard10 } from "grammy";
 function buildAgentItemsKeyboard(agentName, items) {
-  const keyboard = new InlineKeyboard9();
+  const keyboard = new InlineKeyboard10();
   for (const item of items) {
     const installed = item.isInstalled();
     keyboard.text(
@@ -12604,7 +13095,7 @@ function setupIntegrateCallbacks(bot, core) {
     if (data === "i:back") {
       const { listIntegrations: listIntegrations2 } = await Promise.resolve().then(() => (init_integrate(), integrate_exports));
       const agents = listIntegrations2();
-      const keyboard2 = new InlineKeyboard9();
+      const keyboard2 = new InlineKeyboard10();
       for (const agent of agents) {
         keyboard2.text(`\u{1F916} ${agent}`, `i:agent:${agent}`).row();
       }
@@ -12697,16 +13188,19 @@ __export(assistant_exports, {
   redirectToAssistant: () => redirectToAssistant
 });
 function buildWelcomeMessage(ctx) {
-  const { activeCount, errorCount, totalCount, agents, defaultAgent } = ctx;
+  const { activeCount, errorCount, totalCount, agents, defaultAgent, workspace } = ctx;
   const agentList = agents.map((a) => `${a}${a === defaultAgent ? " (default)" : ""}`).join(", ");
   if (totalCount === 0) {
     return `\u{1F44B} <b>OpenACP is ready!</b>
 
+\u{1F4C2} ${workspace}
+
 No sessions yet. Tap \u{1F195} New Session to start, or ask me anything!`;
   }
   if (errorCount > 0) {
     return `\u{1F44B} <b>OpenACP is ready!</b>
 
+\u{1F4C2} ${workspace}
 \u{1F4CA} ${activeCount} active, ${errorCount} errors / ${totalCount} total
 \u26A0\uFE0F ${errorCount} session${errorCount > 1 ? "s have" : " has"} errors \u2014 ask me to check if you'd like.
 
@@ -12714,6 +13208,7 @@ Agents: ${agentList}`;
   }
   return `\u{1F44B} <b>OpenACP is ready!</b>
 
+\u{1F4C2} ${workspace}
 \u{1F4CA} ${activeCount} active / ${totalCount} total
 Agents: ${agentList}`;
 }
@@ -12748,6 +13243,7 @@ function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSessio
       core.configManager.get().workspace.baseDir
     );
   });
+  setupNewSessionCallbacks(bot, core, chatId, getAssistantSession);
   bot.callbackQuery(/^ar:/, (ctx) => handleArchiveConfirm(ctx, core, chatId));
   bot.callbackQuery(/^m:/, async (ctx) => {
     const itemId = ctx.callbackQuery.data.replace("m:", "");
@@ -12763,6 +13259,17 @@ function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSessio
     const registry = core.lifecycleManager?.serviceRegistry?.get("command-registry");
     switch (item.action.type) {
       case "command": {
+        const cmdName = item.action.command.replace(/^\//, "").split(" ")[0];
+        const telegramOverride = TELEGRAM_OVERRIDES[cmdName];
+        if (telegramOverride) {
+          try {
+            await telegramOverride(ctx, core);
+          } catch (err) {
+            await ctx.reply(`\u26A0\uFE0F Command failed: ${String(err)}`).catch(() => {
+            });
+          }
+          break;
+        }
         if (!registry) return;
         const response = await registry.execute(item.action.command, {
           raw: "",
@@ -12785,16 +13292,16 @@ function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSessio
 ${lines}`, { parse_mode: "HTML" }).catch(() => {
             });
           } else if (response.type === "menu") {
-            const { InlineKeyboard: InlineKeyboard11 } = await import("grammy");
-            const kb = new InlineKeyboard11();
+            const { InlineKeyboard: InlineKeyboard12 } = await import("grammy");
+            const kb = new InlineKeyboard12();
             for (const opt of response.options) {
               kb.text(opt.label, `c/${opt.command}`).row();
             }
             await ctx.reply(response.title, { parse_mode: "HTML", reply_markup: kb }).catch(() => {
             });
           } else if (response.type === "confirm") {
-            const { InlineKeyboard: InlineKeyboard11 } = await import("grammy");
-            const kb = new InlineKeyboard11().text("\u2705 Yes", `c/${response.onYes}`).text("\u274C No", `c/${response.onNo}`);
+            const { InlineKeyboard: InlineKeyboard12 } = await import("grammy");
+            const kb = new InlineKeyboard12().text("\u2705 Yes", `c/${response.onYes}`).text("\u274C No", `c/${response.onNo}`);
             await ctx.reply(response.question, { reply_markup: kb }).catch(() => {
             });
           }
@@ -12802,6 +13309,10 @@ ${lines}`, { parse_mode: "HTML" }).catch(() => {
         break;
       }
       case "delegate": {
+        if (itemId === "core:new") {
+          await showAgentPicker(ctx, core, chatId);
+          break;
+        }
         const assistant = core.assistantManager?.get("telegram");
         if (assistant) {
           if (topicId && systemTopicIds && topicId !== systemTopicIds.assistantTopicId) {
@@ -12817,8 +13328,13 @@ ${lines}`, { parse_mode: "HTML" }).catch(() => {
         }
         break;
       }
-      case "callback":
+      case "callback": {
+        const cbData = item.action.callbackData;
+        if (cbData === "s:settings") {
+          await handleSettings(ctx, core);
+        }
         break;
+      }
     }
   });
 }
@@ -12834,8 +13350,10 @@ var init_commands3 = __esm({
     init_doctor2();
     init_tunnel4();
     init_switch();
+    init_telegram_overrides();
     init_menu();
     init_menu();
+    init_telegram_overrides();
     init_new_session();
     init_session();
     init_admin();
@@ -12877,7 +13395,7 @@ var init_commands3 = __esm({
 });
 
 // src/plugins/telegram/permissions.ts
-import { InlineKeyboard as InlineKeyboard10 } from "grammy";
+import { InlineKeyboard as InlineKeyboard11 } from "grammy";
 import { nanoid as nanoid2 } from "nanoid";
 var log21, PermissionHandler;
 var init_permissions = __esm({
@@ -12903,7 +13421,7 @@ var init_permissions = __esm({
           requestId: request.id,
           options: request.options.map((o) => ({ id: o.id, isAllow: o.isAllow }))
         });
-        const keyboard = new InlineKeyboard10();
+        const keyboard = new InlineKeyboard11();
         for (const option of request.options) {
           const emoji = option.isAllow ? "\u2705" : "\u274C";
           keyboard.text(`${emoji} ${option.label}`, `p:${callbackKey}:${option.id}`);
@@ -14545,6 +15063,7 @@ var init_adapter2 = __esm({
     init_log();
     init_topics2();
     init_commands3();
+    init_telegram_overrides();
     init_admin();
     init_permissions();
     init_assistant();
@@ -14757,6 +15276,15 @@ var init_adapter2 = __esm({
           const commandName = atIdx === -1 ? rawCommand : rawCommand.slice(0, atIdx);
           const def = registry.get(commandName);
           if (!def) return next();
+          const telegramOverride = TELEGRAM_OVERRIDES[commandName];
+          if (telegramOverride) {
+            try {
+              await telegramOverride(ctx, this.core);
+            } catch (err) {
+              await ctx.reply(`\u26A0\uFE0F Command failed: ${String(err)}`);
+            }
+            return;
+          }
           const chatId = ctx.chat.id;
           const topicId = ctx.message.message_thread_id;
           try {
@@ -14862,7 +15390,16 @@ var init_adapter2 = __esm({
             if (!assistant) return void 0;
             return {
               topicId: this.assistantTopicId,
-              enqueuePrompt: (p2) => assistant.enqueuePrompt(p2)
+              enqueuePrompt: (p2) => {
+                const pending = this.core.assistantManager?.consumePendingSystemPrompt("telegram");
+                const text6 = pending ? `${pending}
+
+---
+
+User message:
+${p2}` : p2;
+                return assistant.enqueuePrompt(text6);
+              }
             };
           },
           (sessionId, msgId) => {
@@ -14923,7 +15460,8 @@ var init_adapter2 = __esm({
             errorCount: allRecords.filter((r) => r.status === "error").length,
             totalCount: allRecords.length,
             agents: agents.map((a) => a.name),
-            defaultAgent: config.defaultAgent
+            defaultAgent: config.defaultAgent,
+            workspace: this.core.configManager.resolveWorkspace()
           });
           await this.bot.api.sendMessage(this.telegramConfig.chatId, welcomeText, {
             message_thread_id: this.assistantTopicId,
@@ -16505,8 +17043,10 @@ __export(stop_exports, {
 import path36 from "path";
 import os17 from "os";
 async function cmdStop(args2 = [], instanceRoot) {
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
   const root = instanceRoot ?? path36.join(os17.homedir(), ".openacp");
-  if (wantsHelp(args2)) {
+  if (!json && wantsHelp(args2)) {
     console.log(`
 \x1B[1mopenacp stop\x1B[0m \u2014 Stop the background daemon
 
@@ -16514,14 +17054,20 @@ async function cmdStop(args2 = [], instanceRoot) {
   openacp stop
 
 Sends a stop signal to the running OpenACP daemon process.
+
+\x1B[1mOptions:\x1B[0m
+  --json          Output result as JSON
+  -h, --help      Show this help message
 `);
     return;
   }
   const { stopDaemon: stopDaemon2, getPidPath: getPidPath2 } = await Promise.resolve().then(() => (init_daemon2(), daemon_exports));
   const result = await stopDaemon2(getPidPath2(root), root);
   if (result.stopped) {
+    if (json) jsonSuccess({ stopped: true, pid: result.pid });
     console.log(`OpenACP daemon stopped (was PID ${result.pid})`);
   } else {
+    if (json) jsonError(ErrorCodes.DAEMON_NOT_RUNNING, result.error ?? "Daemon is not running.");
     console.error(result.error);
     process.exit(1);
   }
@@ -16530,6 +17076,80 @@ var init_stop = __esm({
   "src/cli/commands/stop.ts"() {
     "use strict";
     init_helpers();
+    init_output();
+  }
+});
+
+// src/core/instance/instance-registry.ts
+var instance_registry_exports = {};
+__export(instance_registry_exports, {
+  InstanceRegistry: () => InstanceRegistry
+});
+import fs34 from "fs";
+import path37 from "path";
+var InstanceRegistry;
+var init_instance_registry = __esm({
+  "src/core/instance/instance-registry.ts"() {
+    "use strict";
+    InstanceRegistry = class {
+      constructor(registryPath) {
+        this.registryPath = registryPath;
+      }
+      data = { version: 1, instances: {} };
+      load() {
+        try {
+          const raw = fs34.readFileSync(this.registryPath, "utf-8");
+          const parsed = JSON.parse(raw);
+          if (parsed.version === 1 && parsed.instances) {
+            this.data = parsed;
+            this.deduplicate();
+          }
+        } catch {
+        }
+      }
+      /** Remove duplicate entries that point to the same root, keeping the first one */
+      deduplicate() {
+        const seen = /* @__PURE__ */ new Set();
+        const toRemove = [];
+        for (const [id, entry] of Object.entries(this.data.instances)) {
+          if (seen.has(entry.root)) {
+            toRemove.push(id);
+          } else {
+            seen.add(entry.root);
+          }
+        }
+        if (toRemove.length > 0) {
+          for (const id of toRemove) delete this.data.instances[id];
+          this.save();
+        }
+      }
+      save() {
+        const dir = path37.dirname(this.registryPath);
+        fs34.mkdirSync(dir, { recursive: true });
+        fs34.writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));
+      }
+      register(id, root) {
+        this.data.instances[id] = { id, root };
+      }
+      remove(id) {
+        delete this.data.instances[id];
+      }
+      get(id) {
+        return this.data.instances[id];
+      }
+      getByRoot(root) {
+        return Object.values(this.data.instances).find((e) => e.root === root);
+      }
+      list() {
+        return Object.values(this.data.instances);
+      }
+      uniqueId(baseId) {
+        if (!this.data.instances[baseId]) return baseId;
+        let n = 2;
+        while (this.data.instances[`${baseId}-${n}`]) n++;
+        return `${baseId}-${n}`;
+      }
+    };
   }
 });
 
@@ -16839,8 +17459,8 @@ var init_mcp_manager = __esm({
 });
 
 // src/core/utils/debug-tracer.ts
-import fs34 from "fs";
-import path37 from "path";
+import fs35 from "fs";
+import path38 from "path";
 function createDebugTracer(sessionId, workingDirectory) {
   if (!DEBUG_ENABLED) return null;
   return new DebugTracer(sessionId, workingDirectory);
@@ -16854,17 +17474,17 @@ var init_debug_tracer = __esm({
       constructor(sessionId, workingDirectory) {
         this.sessionId = sessionId;
         this.workingDirectory = workingDirectory;
-        this.logDir = path37.join(workingDirectory, ".log");
+        this.logDir = path38.join(workingDirectory, ".log");
       }
       dirCreated = false;
       logDir;
       log(layer, data) {
         try {
           if (!this.dirCreated) {
-            fs34.mkdirSync(this.logDir, { recursive: true });
+            fs35.mkdirSync(this.logDir, { recursive: true });
             this.dirCreated = true;
           }
-          const filePath = path37.join(this.logDir, `${this.sessionId}_${layer}.jsonl`);
+          const filePath = path38.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) {
@@ -16873,7 +17493,7 @@ var init_debug_tracer = __esm({
             }
             return value;
           }) + "\n";
-          fs34.appendFileSync(filePath, line);
+          fs35.appendFileSync(filePath, line);
         } catch {
         }
       }
@@ -16887,17 +17507,17 @@ var init_debug_tracer = __esm({
 // src/core/agents/agent-instance.ts
 import { spawn as spawn7, execFileSync as execFileSync5 } from "child_process";
 import { Transform } from "stream";
-import fs35 from "fs";
-import path38 from "path";
+import fs36 from "fs";
+import path39 from "path";
 import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
 import { PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
 function findPackageRoot(startDir) {
   let dir = startDir;
-  while (dir !== path38.dirname(dir)) {
-    if (fs35.existsSync(path38.join(dir, "package.json"))) {
+  while (dir !== path39.dirname(dir)) {
+    if (fs36.existsSync(path39.join(dir, "package.json"))) {
       return dir;
     }
-    dir = path38.dirname(dir);
+    dir = path39.dirname(dir);
   }
   return startDir;
 }
@@ -16909,26 +17529,26 @@ function resolveAgentCommand(cmd) {
   }
   for (const root of searchRoots) {
     const packageDirs = [
-      path38.resolve(root, "node_modules", "@zed-industries", cmd, "dist", "index.js"),
-      path38.resolve(root, "node_modules", cmd, "dist", "index.js")
+      path39.resolve(root, "node_modules", "@zed-industries", cmd, "dist", "index.js"),
+      path39.resolve(root, "node_modules", cmd, "dist", "index.js")
     ];
     for (const jsPath of packageDirs) {
-      if (fs35.existsSync(jsPath)) {
+      if (fs36.existsSync(jsPath)) {
         return { command: process.execPath, args: [jsPath] };
       }
     }
   }
   for (const root of searchRoots) {
-    const localBin = path38.resolve(root, "node_modules", ".bin", cmd);
-    if (fs35.existsSync(localBin)) {
-      const content = fs35.readFileSync(localBin, "utf-8");
+    const localBin = path39.resolve(root, "node_modules", ".bin", cmd);
+    if (fs36.existsSync(localBin)) {
+      const content = fs36.readFileSync(localBin, "utf-8");
       if (content.startsWith("#!/usr/bin/env node")) {
         return { command: process.execPath, args: [localBin] };
       }
       const match = content.match(/"([^"]+\.js)"/);
       if (match) {
-        const target = path38.resolve(path38.dirname(localBin), match[1]);
-        if (fs35.existsSync(target)) {
+        const target = path39.resolve(path39.dirname(localBin), match[1]);
+        if (fs36.existsSync(target)) {
           return { command: process.execPath, args: [target] };
         }
       }
@@ -16937,7 +17557,7 @@ function resolveAgentCommand(cmd) {
   try {
     const fullPath = execFileSync5("which", [cmd], { encoding: "utf-8" }).trim();
     if (fullPath) {
-      const content = fs35.readFileSync(fullPath, "utf-8");
+      const content = fs36.readFileSync(fullPath, "utf-8");
       if (content.startsWith("#!/usr/bin/env node")) {
         return { command: process.execPath, args: [fullPath] };
       }
@@ -17328,8 +17948,8 @@ ${stderr}`
               writePath = result.path;
               writeContent = result.content;
             }
-            await fs35.promises.mkdir(path38.dirname(writePath), { recursive: true });
-            await fs35.promises.writeFile(writePath, writeContent, "utf-8");
+            await fs36.promises.mkdir(path39.dirname(writePath), { recursive: true });
+            await fs36.promises.writeFile(writePath, writeContent, "utf-8");
             return {};
           },
           // ── Terminal operations (delegated to TerminalManager) ─────────────
@@ -17404,10 +18024,10 @@ ${stderr}`
         for (const att of attachments ?? []) {
           const tooLarge = att.size > 10 * 1024 * 1024;
           if (att.type === "image" && this.promptCapabilities?.image && !tooLarge && SUPPORTED_IMAGE_MIMES.has(att.mimeType)) {
-            const data = await fs35.promises.readFile(att.filePath);
+            const data = await fs36.promises.readFile(att.filePath);
             contentBlocks.push({ type: "image", data: data.toString("base64"), mimeType: att.mimeType });
           } else if (att.type === "audio" && this.promptCapabilities?.audio && !tooLarge) {
-            const data = await fs35.promises.readFile(att.filePath);
+            const data = await fs36.promises.readFile(att.filePath);
             contentBlocks.push({ type: "audio", data: data.toString("base64"), mimeType: att.mimeType });
           } else {
             if ((att.type === "image" || att.type === "audio") && !tooLarge) {
@@ -17631,7 +18251,7 @@ var init_permission_gate = __esm({
 
 // src/core/sessions/session.ts
 import { nanoid as nanoid3 } from "nanoid";
-import * as fs36 from "fs";
+import * as fs37 from "fs";
 var moduleLog, TTS_PROMPT_INSTRUCTION, TTS_BLOCK_REGEX, TTS_MAX_LENGTH, TTS_TIMEOUT_MS, VALID_TRANSITIONS, Session;
 var init_session2 = __esm({
   "src/core/sessions/session.ts"() {
@@ -17862,7 +18482,7 @@ ${text6}`;
           try {
             const audioPath = att.originalFilePath || att.filePath;
             const audioMime = att.originalFilePath ? "audio/ogg" : att.mimeType;
-            const audioBuffer = await fs36.promises.readFile(audioPath);
+            const audioBuffer = await fs37.promises.readFile(audioPath);
             const result = await this.speechService.transcribe(audioBuffer, audioMime);
             this.log.info({ provider: "stt", duration: result.duration }, "Voice transcribed");
             this.emit("agent_event", {
@@ -18939,8 +19559,8 @@ var init_message_transformer = __esm({
 });
 
 // src/core/sessions/session-store.ts
-import fs37 from "fs";
-import path39 from "path";
+import fs38 from "fs";
+import path40 from "path";
 var log29, DEBOUNCE_MS2, JsonFileSessionStore;
 var init_session_store = __esm({
   "src/core/sessions/session-store.ts"() {
@@ -19016,9 +19636,9 @@ var init_session_store = __esm({
           version: 1,
           sessions: Object.fromEntries(this.records)
         };
-        const dir = path39.dirname(this.filePath);
-        if (!fs37.existsSync(dir)) fs37.mkdirSync(dir, { recursive: true });
-        fs37.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+        const dir = path40.dirname(this.filePath);
+        if (!fs38.existsSync(dir)) fs38.mkdirSync(dir, { recursive: true });
+        fs38.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
       }
       destroy() {
         if (this.debounceTimer) clearTimeout(this.debounceTimer);
@@ -19031,10 +19651,10 @@ var init_session_store = __esm({
         }
       }
       load() {
-        if (!fs37.existsSync(this.filePath)) return;
+        if (!fs38.existsSync(this.filePath)) return;
         try {
           const raw = JSON.parse(
-            fs37.readFileSync(this.filePath, "utf-8")
+            fs38.readFileSync(this.filePath, "utf-8")
           );
           if (raw.version !== 1) {
             log29.warn(
@@ -19050,7 +19670,7 @@ var init_session_store = __esm({
         } catch (err) {
           log29.error({ err }, "Failed to load session store, backing up corrupt file");
           try {
-            fs37.renameSync(this.filePath, `${this.filePath}.bak`);
+            fs38.renameSync(this.filePath, `${this.filePath}.bak`);
           } catch {
           }
         }
@@ -19590,8 +20210,8 @@ var agent_store_exports = {};
 __export(agent_store_exports, {
   AgentStore: () => AgentStore
 });
-import * as fs38 from "fs";
-import * as path40 from "path";
+import * as fs39 from "fs";
+import * as path41 from "path";
 import * as os18 from "os";
 import { z as z7 } from "zod";
 var log32, InstalledAgentSchema, AgentStoreSchema, AgentStore;
@@ -19620,15 +20240,15 @@ var init_agent_store = __esm({
       data = { version: 1, installed: {} };
       filePath;
       constructor(filePath) {
-        this.filePath = filePath ?? path40.join(os18.homedir(), ".openacp", "agents.json");
+        this.filePath = filePath ?? path41.join(os18.homedir(), ".openacp", "agents.json");
       }
       load() {
-        if (!fs38.existsSync(this.filePath)) {
+        if (!fs39.existsSync(this.filePath)) {
           this.data = { version: 1, installed: {} };
           return;
         }
         try {
-          const raw = JSON.parse(fs38.readFileSync(this.filePath, "utf-8"));
+          const raw = JSON.parse(fs39.readFileSync(this.filePath, "utf-8"));
           const result = AgentStoreSchema.safeParse(raw);
           if (result.success) {
             this.data = result.data;
@@ -19642,7 +20262,7 @@ var init_agent_store = __esm({
         }
       }
       exists() {
-        return fs38.existsSync(this.filePath);
+        return fs39.existsSync(this.filePath);
       }
       getInstalled() {
         return this.data.installed;
@@ -19662,18 +20282,18 @@ var init_agent_store = __esm({
         return key in this.data.installed;
       }
       save() {
-        fs38.mkdirSync(path40.dirname(this.filePath), { recursive: true });
+        fs39.mkdirSync(path41.dirname(this.filePath), { recursive: true });
         const tmpPath = this.filePath + ".tmp";
-        fs38.writeFileSync(tmpPath, JSON.stringify(this.data, null, 2));
-        fs38.renameSync(tmpPath, this.filePath);
+        fs39.writeFileSync(tmpPath, JSON.stringify(this.data, null, 2));
+        fs39.renameSync(tmpPath, this.filePath);
       }
     };
   }
 });
 
 // src/core/agents/agent-installer.ts
-import * as fs39 from "fs";
-import * as path41 from "path";
+import * as fs40 from "fs";
+import * as path42 from "path";
 import * as os19 from "os";
 function getPlatformKey() {
   const platform2 = PLATFORM_MAP[process.platform] ?? process.platform;
@@ -19725,7 +20345,7 @@ function buildInstalledAgent(registryId, name, version, dist, binaryPath) {
       binaryPath: null
     };
   }
-  const absCmd = path41.resolve(binaryPath, dist.cmd);
+  const absCmd = path42.resolve(binaryPath, dist.cmd);
   return {
     registryId,
     name,
@@ -19798,8 +20418,8 @@ Install it with: pip install uv`;
   return { ok: true, agentKey, setupSteps: setup?.setupSteps };
 }
 async function downloadAndExtract(agentId, archiveUrl, progress, agentsDir) {
-  const destDir = path41.join(agentsDir ?? DEFAULT_AGENTS_DIR, agentId);
-  fs39.mkdirSync(destDir, { recursive: true });
+  const destDir = path42.join(agentsDir ?? DEFAULT_AGENTS_DIR, agentId);
+  fs40.mkdirSync(destDir, { recursive: true });
   await progress?.onStep("Downloading...");
   log33.info({ agentId, url: archiveUrl }, "Downloading agent binary");
   const response = await fetch(archiveUrl);
@@ -19837,52 +20457,52 @@ async function readResponseWithProgress(response, contentLength, progress) {
   return Buffer.concat(chunks);
 }
 function validateExtractedPaths(destDir) {
-  const realDest = fs39.realpathSync(destDir);
-  const entries = fs39.readdirSync(destDir, { recursive: true, withFileTypes: true });
+  const realDest = fs40.realpathSync(destDir);
+  const entries = fs40.readdirSync(destDir, { recursive: true, withFileTypes: true });
   for (const entry of entries) {
     const dirent = entry;
     const parentPath = dirent.parentPath ?? dirent.path ?? destDir;
-    const fullPath = path41.join(parentPath, entry.name);
+    const fullPath = path42.join(parentPath, entry.name);
     let realPath;
     try {
-      realPath = fs39.realpathSync(fullPath);
+      realPath = fs40.realpathSync(fullPath);
     } catch {
-      const linkTarget = fs39.readlinkSync(fullPath);
-      realPath = path41.resolve(path41.dirname(fullPath), linkTarget);
+      const linkTarget = fs40.readlinkSync(fullPath);
+      realPath = path42.resolve(path42.dirname(fullPath), linkTarget);
     }
-    if (!realPath.startsWith(realDest + path41.sep) && realPath !== realDest) {
-      fs39.rmSync(destDir, { recursive: true, force: true });
+    if (!realPath.startsWith(realDest + path42.sep) && realPath !== realDest) {
+      fs40.rmSync(destDir, { recursive: true, force: true });
       throw new Error(`Archive contains unsafe path: ${entry.name}`);
     }
   }
 }
 async function extractTarGz(buffer, destDir) {
   const { execFileSync: execFileSync8 } = await import("child_process");
-  const tmpFile = path41.join(destDir, "_archive.tar.gz");
-  fs39.writeFileSync(tmpFile, buffer);
+  const tmpFile = path42.join(destDir, "_archive.tar.gz");
+  fs40.writeFileSync(tmpFile, buffer);
   try {
     execFileSync8("tar", ["xzf", tmpFile, "-C", destDir], { stdio: "pipe" });
   } finally {
-    fs39.unlinkSync(tmpFile);
+    fs40.unlinkSync(tmpFile);
   }
   validateExtractedPaths(destDir);
 }
 async function extractZip(buffer, destDir) {
   const { execFileSync: execFileSync8 } = await import("child_process");
-  const tmpFile = path41.join(destDir, "_archive.zip");
-  fs39.writeFileSync(tmpFile, buffer);
+  const tmpFile = path42.join(destDir, "_archive.zip");
+  fs40.writeFileSync(tmpFile, buffer);
   try {
     execFileSync8("unzip", ["-o", tmpFile, "-d", destDir], { stdio: "pipe" });
   } finally {
-    fs39.unlinkSync(tmpFile);
+    fs40.unlinkSync(tmpFile);
   }
   validateExtractedPaths(destDir);
 }
 async function uninstallAgent(agentKey, store) {
   const agent = store.getAgent(agentKey);
   if (!agent) return;
-  if (agent.binaryPath && fs39.existsSync(agent.binaryPath)) {
-    fs39.rmSync(agent.binaryPath, { recursive: true, force: true });
+  if (agent.binaryPath && fs40.existsSync(agent.binaryPath)) {
+    fs40.rmSync(agent.binaryPath, { recursive: true, force: true });
     log33.info({ agentKey, binaryPath: agent.binaryPath }, "Deleted agent binary");
   }
   store.removeAgent(agentKey);
@@ -19894,7 +20514,7 @@ var init_agent_installer = __esm({
     init_log();
     init_agent_dependencies();
     log33 = createChildLogger({ module: "agent-installer" });
-    DEFAULT_AGENTS_DIR = path41.join(os19.homedir(), ".openacp", "agents");
+    DEFAULT_AGENTS_DIR = path42.join(os19.homedir(), ".openacp", "agents");
     ARCH_MAP = {
       arm64: "aarch64",
       x64: "x86_64"
@@ -19912,8 +20532,8 @@ var agent_catalog_exports = {};
 __export(agent_catalog_exports, {
   AgentCatalog: () => AgentCatalog
 });
-import * as fs40 from "fs";
-import * as path42 from "path";
+import * as fs41 from "fs";
+import * as path43 from "path";
 import * as os20 from "os";
 var log34, REGISTRY_URL2, DEFAULT_TTL_HOURS, AgentCatalog;
 var init_agent_catalog = __esm({
@@ -19933,7 +20553,7 @@ var init_agent_catalog = __esm({
       agentsDir;
       constructor(store, cachePath, agentsDir) {
         this.store = store ?? new AgentStore();
-        this.cachePath = cachePath ?? path42.join(os20.homedir(), ".openacp", "registry-cache.json");
+        this.cachePath = cachePath ?? path43.join(os20.homedir(), ".openacp", "registry-cache.json");
         this.agentsDir = agentsDir;
       }
       load() {
@@ -19954,8 +20574,8 @@ var init_agent_catalog = __esm({
             ttlHours: DEFAULT_TTL_HOURS,
             data
           };
-          fs40.mkdirSync(path42.dirname(this.cachePath), { recursive: true });
-          fs40.writeFileSync(this.cachePath, JSON.stringify(cache, null, 2));
+          fs41.mkdirSync(path43.dirname(this.cachePath), { recursive: true });
+          fs41.writeFileSync(this.cachePath, JSON.stringify(cache, null, 2));
           log34.info({ count: this.registryAgents.length }, "Registry updated");
         } catch (err) {
           log34.warn({ err }, "Failed to fetch registry, using cached data");
@@ -20115,9 +20735,9 @@ var init_agent_catalog = __esm({
         }
       }
       isCacheStale() {
-        if (!fs40.existsSync(this.cachePath)) return true;
+        if (!fs41.existsSync(this.cachePath)) return true;
         try {
-          const raw = JSON.parse(fs40.readFileSync(this.cachePath, "utf-8"));
+          const raw = JSON.parse(fs41.readFileSync(this.cachePath, "utf-8"));
           const fetchedAt = new Date(raw.fetchedAt).getTime();
           const ttlMs = (raw.ttlHours ?? DEFAULT_TTL_HOURS) * 60 * 60 * 1e3;
           return Date.now() - fetchedAt > ttlMs;
@@ -20126,9 +20746,9 @@ var init_agent_catalog = __esm({
         }
       }
       loadRegistryFromCacheOrSnapshot() {
-        if (fs40.existsSync(this.cachePath)) {
+        if (fs41.existsSync(this.cachePath)) {
           try {
-            const raw = JSON.parse(fs40.readFileSync(this.cachePath, "utf-8"));
+            const raw = JSON.parse(fs41.readFileSync(this.cachePath, "utf-8"));
             if (raw.data?.agents) {
               this.registryAgents = raw.data.agents;
               log34.debug({ count: this.registryAgents.length }, "Loaded registry from cache");
@@ -20140,13 +20760,13 @@ var init_agent_catalog = __esm({
         }
         try {
           const candidates = [
-            path42.join(import.meta.dirname, "data", "registry-snapshot.json"),
-            path42.join(import.meta.dirname, "..", "data", "registry-snapshot.json"),
-            path42.join(import.meta.dirname, "..", "..", "data", "registry-snapshot.json")
+            path43.join(import.meta.dirname, "data", "registry-snapshot.json"),
+            path43.join(import.meta.dirname, "..", "data", "registry-snapshot.json"),
+            path43.join(import.meta.dirname, "..", "..", "data", "registry-snapshot.json")
           ];
           for (const candidate of candidates) {
-            if (fs40.existsSync(candidate)) {
-              const raw = JSON.parse(fs40.readFileSync(candidate, "utf-8"));
+            if (fs41.existsSync(candidate)) {
+              const raw = JSON.parse(fs41.readFileSync(candidate, "utf-8"));
               this.registryAgents = raw.agents ?? [];
               log34.debug({ count: this.registryAgents.length }, "Loaded registry from bundled snapshot");
               return;
@@ -20439,8 +21059,8 @@ var init_error_tracker = __esm({
 });
 
 // src/core/plugin/plugin-storage.ts
-import fs41 from "fs";
-import path43 from "path";
+import fs42 from "fs";
+import path44 from "path";
 var PluginStorageImpl;
 var init_plugin_storage = __esm({
   "src/core/plugin/plugin-storage.ts"() {
@@ -20450,20 +21070,20 @@ var init_plugin_storage = __esm({
       dataDir;
       writeChain = Promise.resolve();
       constructor(baseDir) {
-        this.dataDir = path43.join(baseDir, "data");
-        this.kvPath = path43.join(baseDir, "kv.json");
-        fs41.mkdirSync(baseDir, { recursive: true });
+        this.dataDir = path44.join(baseDir, "data");
+        this.kvPath = path44.join(baseDir, "kv.json");
+        fs42.mkdirSync(baseDir, { recursive: true });
       }
       readKv() {
         try {
-          const raw = fs41.readFileSync(this.kvPath, "utf-8");
+          const raw = fs42.readFileSync(this.kvPath, "utf-8");
           return JSON.parse(raw);
         } catch {
           return {};
         }
       }
       writeKv(data) {
-        fs41.writeFileSync(this.kvPath, JSON.stringify(data), "utf-8");
+        fs42.writeFileSync(this.kvPath, JSON.stringify(data), "utf-8");
       }
       async get(key) {
         const data = this.readKv();
@@ -20489,7 +21109,7 @@ var init_plugin_storage = __esm({
         return Object.keys(this.readKv());
       }
       getDataDir() {
-        fs41.mkdirSync(this.dataDir, { recursive: true });
+        fs42.mkdirSync(this.dataDir, { recursive: true });
         return this.dataDir;
       }
     };
@@ -20497,7 +21117,7 @@ var init_plugin_storage = __esm({
 });
 
 // src/core/plugin/plugin-context.ts
-import path44 from "path";
+import path45 from "path";
 import os21 from "os";
 function requirePermission(permissions, required, action) {
   if (!permissions.includes(required)) {
@@ -20517,7 +21137,7 @@ function createPluginContext(opts) {
     config,
     core
   } = opts;
-  const instanceRoot = opts.instanceRoot ?? path44.join(os21.homedir(), ".openacp");
+  const instanceRoot = opts.instanceRoot ?? path45.join(os21.homedir(), ".openacp");
   const registeredListeners = [];
   const registeredCommands = [];
   const noopLog = {
@@ -21105,8 +21725,8 @@ var init_assistant_manager = __esm({
         this.registry = registry;
       }
       sessions = /* @__PURE__ */ new Map();
-      readyState = /* @__PURE__ */ new Map();
       respawning = /* @__PURE__ */ new Set();
+      pendingSystemPrompts = /* @__PURE__ */ new Map();
       async spawn(channelId, threadId) {
         const session = await this.core.createSession({
           channelId,
@@ -21118,17 +21738,22 @@ var init_assistant_manager = __esm({
         session.threadId = threadId;
         this.sessions.set(channelId, session);
         const systemPrompt = this.registry.buildSystemPrompt(channelId);
-        const ready = session.enqueuePrompt(systemPrompt).then(() => {
-          log37.info({ sessionId: session.id, channelId }, "Assistant ready");
-        }).catch((err) => {
-          log37.warn({ err, channelId }, "Assistant system prompt failed");
-        });
-        this.readyState.set(channelId, ready);
+        this.pendingSystemPrompts.set(channelId, systemPrompt);
+        log37.info({ sessionId: session.id, channelId }, "Assistant spawned (system prompt deferred)");
         return session;
       }
       get(channelId) {
         return this.sessions.get(channelId) ?? null;
       }
+      /**
+       * Consume and return any pending system prompt for a channel.
+       * Should be prepended to the first real user message.
+       */
+      consumePendingSystemPrompt(channelId) {
+        const prompt = this.pendingSystemPrompts.get(channelId);
+        if (prompt) this.pendingSystemPrompts.delete(channelId);
+        return prompt;
+      }
       isAssistant(sessionId) {
         for (const s of this.sessions.values()) {
           if (s.id === sessionId) return true;
@@ -21148,9 +21773,6 @@ var init_assistant_manager = __esm({
           this.respawning.delete(channelId);
         }
       }
-      async waitReady(channelId) {
-        await this.readyState.get(channelId);
-      }
     };
   }
 });
@@ -21358,7 +21980,7 @@ var init_core_items = __esm({
 });
 
 // src/core/core.ts
-import path45 from "path";
+import path46 from "path";
 import os22 from "os";
 var log38, OpenACPCore;
 var init_core = __esm({
@@ -21438,7 +22060,7 @@ var init_core = __esm({
         );
         this.agentCatalog.load();
         this.agentManager = new AgentManager(this.agentCatalog);
-        const storePath = ctx?.paths.sessions ?? path45.join(os22.homedir(), ".openacp", "sessions.json");
+        const storePath = ctx?.paths.sessions ?? path46.join(os22.homedir(), ".openacp", "sessions.json");
         this.sessionStore = new JsonFileSessionStore(
           storePath,
           config.sessionStore.ttlDays
@@ -21462,7 +22084,7 @@ var init_core = __esm({
           sessions: this.sessionManager,
           config: this.configManager,
           core: this,
-          storagePath: ctx?.paths.pluginsData ?? path45.join(os22.homedir(), ".openacp", "plugins", "data"),
+          storagePath: ctx?.paths.pluginsData ?? path46.join(os22.homedir(), ".openacp", "plugins", "data"),
           instanceRoot: ctx?.root,
           log: createChildLogger({ module: "plugin" })
         });
@@ -21509,7 +22131,7 @@ var init_core = __esm({
         );
         registerCoreMenuItems(this.menuRegistry);
         if (ctx?.root) {
-          this.assistantRegistry.setInstanceRoot(path45.dirname(ctx.root));
+          this.assistantRegistry.setInstanceRoot(path46.dirname(ctx.root));
         }
         this.assistantRegistry.register(createSessionsSection(this));
         this.assistantRegistry.register(createAgentsSection(this));
@@ -21635,7 +22257,19 @@ var init_core = __esm({
         this.sessionManager.patchRecord(session.id, {
           lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
         });
-        await session.enqueuePrompt(message.text, message.attachments);
+        let text6 = message.text;
+        if (this.assistantManager?.isAssistant(session.id)) {
+          const pending = this.assistantManager.consumePendingSystemPrompt(message.channelId);
+          if (pending) {
+            text6 = `${pending}
+
+---
+
+User message:
+${text6}`;
+          }
+        }
+        await session.enqueuePrompt(text6, message.attachments);
       }
       // --- Unified Session Creation Pipeline ---
       async createSession(params) {
@@ -22775,79 +23409,6 @@ var init_commands4 = __esm({
   }
 });
 
-// src/core/instance/instance-registry.ts
-var instance_registry_exports = {};
-__export(instance_registry_exports, {
-  InstanceRegistry: () => InstanceRegistry
-});
-import fs42 from "fs";
-import path46 from "path";
-var InstanceRegistry;
-var init_instance_registry = __esm({
-  "src/core/instance/instance-registry.ts"() {
-    "use strict";
-    InstanceRegistry = class {
-      constructor(registryPath) {
-        this.registryPath = registryPath;
-      }
-      data = { version: 1, instances: {} };
-      load() {
-        try {
-          const raw = fs42.readFileSync(this.registryPath, "utf-8");
-          const parsed = JSON.parse(raw);
-          if (parsed.version === 1 && parsed.instances) {
-            this.data = parsed;
-            this.deduplicate();
-          }
-        } catch {
-        }
-      }
-      /** Remove duplicate entries that point to the same root, keeping the first one */
-      deduplicate() {
-        const seen = /* @__PURE__ */ new Set();
-        const toRemove = [];
-        for (const [id, entry] of Object.entries(this.data.instances)) {
-          if (seen.has(entry.root)) {
-            toRemove.push(id);
-          } else {
-            seen.add(entry.root);
-          }
-        }
-        if (toRemove.length > 0) {
-          for (const id of toRemove) delete this.data.instances[id];
-          this.save();
-        }
-      }
-      save() {
-        const dir = path46.dirname(this.registryPath);
-        fs42.mkdirSync(dir, { recursive: true });
-        fs42.writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));
-      }
-      register(id, root) {
-        this.data.instances[id] = { id, root };
-      }
-      remove(id) {
-        delete this.data.instances[id];
-      }
-      get(id) {
-        return this.data.instances[id];
-      }
-      getByRoot(root) {
-        return Object.values(this.data.instances).find((e) => e.root === root);
-      }
-      list() {
-        return Object.values(this.data.instances);
-      }
-      uniqueId(baseId) {
-        if (!this.data.instances[baseId]) return baseId;
-        let n = 2;
-        while (this.data.instances[`${baseId}-${n}`]) n++;
-        return `${baseId}-${n}`;
-      }
-    };
-  }
-});
-
 // src/core/setup/types.ts
 var ONBOARD_SECTION_OPTIONS, CHANNEL_META;
 var init_types = __esm({
@@ -23701,6 +24262,7 @@ import * as path51 from "path";
 import * as fs46 from "fs";
 import * as os24 from "os";
 import * as clack8 from "@clack/prompts";
+import { randomUUID as randomUUID2 } from "crypto";
 async function fetchCommunityAdapters() {
   try {
     const client = new RegistryClient();
@@ -24069,7 +24631,7 @@ async function runSetup(configManager, opts) {
     }
     const existingEntry = instanceRegistry.getByRoot(instanceRoot);
     if (!existingEntry) {
-      const id = instanceRegistry.uniqueId(generateSlug(instanceName));
+      const id = randomUUID2();
       instanceRegistry.register(id, instanceRoot);
       await instanceRegistry.save();
     }
@@ -24408,13 +24970,17 @@ __export(main_exports, {
   startServer: () => startServer
 });
 import path53 from "path";
+import { randomUUID as randomUUID3 } from "crypto";
 import fs48 from "fs";
 async function startServer(opts) {
-  const ctx = opts?.instanceContext ?? createInstanceContext({
-    id: "main",
-    root: getGlobalRoot(),
-    isGlobal: true
-  });
+  const globalRoot = getGlobalRoot();
+  if (!opts?.instanceContext) {
+    const reg = new InstanceRegistry(path53.join(globalRoot, "instances.json"));
+    reg.load();
+    const entry = reg.getByRoot(globalRoot);
+    opts = { ...opts, instanceContext: createInstanceContext({ id: entry?.id ?? randomUUID3(), root: globalRoot, isGlobal: true }) };
+  }
+  const ctx = opts.instanceContext;
   if (process.argv.includes("--daemon-child")) {
     const { writePidFile: writePidFile2, readPidFile: readPidFile2, shouldAutoStart: shouldAutoStart2 } = await Promise.resolve().then(() => (init_daemon2(), daemon_exports));
     console.error(`[startup] Daemon child starting (pid=${process.pid}, root=${ctx.root}, env.OPENACP_INSTANCE_ROOT=${process.env.OPENACP_INSTANCE_ROOT ?? "unset"})`);
@@ -24689,8 +25255,8 @@ async function startServer(opts) {
   });
   await core.start();
   try {
-    const globalRoot = getGlobalRoot();
-    const registryPath = path53.join(globalRoot, "instances.json");
+    const globalRoot2 = getGlobalRoot();
+    const registryPath = path53.join(globalRoot2, "instances.json");
     const instanceReg = new InstanceRegistry(registryPath);
     await instanceReg.load();
     if (!instanceReg.getByRoot(ctx.root)) {
@@ -24855,9 +25421,12 @@ __export(restart_exports, {
 });
 import path54 from "path";
 import os25 from "os";
+import { randomUUID as randomUUID4 } from "crypto";
 async function cmdRestart(args2 = [], instanceRoot) {
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
   const root = instanceRoot ?? path54.join(os25.homedir(), ".openacp");
-  if (wantsHelp(args2)) {
+  if (!json && wantsHelp(args2)) {
     console.log(`
 \x1B[1mopenacp restart\x1B[0m \u2014 Restart the background daemon
 
@@ -24868,6 +25437,10 @@ async function cmdRestart(args2 = [], instanceRoot) {
 
 Stops the running daemon (if any) and starts a new one.
 
+\x1B[1mOptions:\x1B[0m
+  --json          Output result as JSON
+  -h, --help      Show this help message
+
 \x1B[1mSee also:\x1B[0m
   openacp start       Start the daemon
   openacp stop        Stop the daemon
@@ -24888,19 +25461,23 @@ Stops the running daemon (if any) and starts a new one.
   }
   const cm = new ConfigManager2();
   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.');
     process.exit(1);
   }
   await cm.load();
   const config = cm.get();
-  const useForeground = forceForeground || !forceDaemon && config.runMode !== "daemon";
+  const useForeground = json ? false : forceForeground || !forceDaemon && config.runMode !== "daemon";
   if (useForeground) {
     markRunning2(root);
     printInstanceHint(root);
     console.log("Starting in foreground mode...");
     const { startServer: startServer2 } = await Promise.resolve().then(() => (init_main(), main_exports));
+    const reg = new InstanceRegistry(path54.join(getGlobalRoot(), "instances.json"));
+    reg.load();
+    const existingEntry = reg.getByRoot(root);
     const ctx = createInstanceContext({
-      id: "default",
+      id: existingEntry?.id ?? randomUUID4(),
       root,
       isGlobal: root === getGlobalRoot()
     });
@@ -24908,9 +25485,11 @@ Stops the running daemon (if any) and starts a new one.
   } else {
     const result = startDaemon2(pidPath, config.logging.logDir, root);
     if ("error" in result) {
+      if (json) jsonError(ErrorCodes.DAEMON_NOT_RUNNING, result.error);
       console.error(result.error);
       process.exit(1);
     }
+    if (json) jsonSuccess({ pid: result.pid, instanceId: path54.basename(root), dir: root });
     printInstanceHint(root);
     console.log(`OpenACP daemon started (PID ${result.pid})`);
   }
@@ -24919,8 +25498,10 @@ var init_restart = __esm({
   "src/cli/commands/restart.ts"() {
     "use strict";
     init_helpers();
+    init_output();
     init_instance_hint();
     init_instance_context();
+    init_instance_registry();
   }
 });
 
@@ -24935,23 +25516,43 @@ import fs49 from "fs";
 import path55 from "path";
 import os26 from "os";
 async function cmdStatus(args2 = [], instanceRoot) {
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
   if (args2.includes("--all")) {
-    await showAllInstances();
+    await showAllInstances(json);
     return;
   }
   const idIdx = args2.indexOf("--id");
   if (idIdx !== -1 && args2[idIdx + 1]) {
-    await showInstanceById(args2[idIdx + 1]);
+    await showInstanceById(args2[idIdx + 1], json);
     return;
   }
   const root = instanceRoot ?? getGlobalRoot();
-  await showSingleInstance(root);
+  await showSingleInstance(root, json);
 }
-async function showAllInstances() {
+async function showAllInstances(json = false) {
   const registryPath = path55.join(getGlobalRoot(), "instances.json");
   const registry = new InstanceRegistry(registryPath);
   await registry.load();
   const instances = registry.list();
+  if (json) {
+    jsonSuccess({
+      instances: instances.map((entry) => {
+        const info = readInstanceInfo(entry.root);
+        return {
+          id: entry.id,
+          name: info.name,
+          status: info.pid ? "online" : "offline",
+          pid: info.pid,
+          dir: entry.root,
+          mode: info.runMode,
+          channels: info.channels,
+          apiPort: info.apiPort,
+          tunnelPort: info.tunnelPort
+        };
+      })
+    });
+  }
   if (instances.length === 0) {
     console.log("No workspaces registered.");
     return;
@@ -24972,19 +25573,33 @@ async function showAllInstances() {
   }
   console.log("");
 }
-async function showInstanceById(id) {
+async function showInstanceById(id, json = false) {
   const registryPath = path55.join(getGlobalRoot(), "instances.json");
   const registry = new InstanceRegistry(registryPath);
   await registry.load();
   const entry = registry.get(id);
   if (!entry) {
+    if (json) jsonError(ErrorCodes.INSTANCE_NOT_FOUND, `Workspace "${id}" not found.`);
     console.error(`Workspace "${id}" not found.`);
     process.exit(1);
   }
-  await showSingleInstance(entry.root);
+  await showSingleInstance(entry.root, json);
 }
-async function showSingleInstance(root) {
+async function showSingleInstance(root, json = false) {
   const info = readInstanceInfo(root);
+  if (json) {
+    jsonSuccess({
+      id: path55.basename(root),
+      name: info.name,
+      status: info.pid ? "online" : "offline",
+      pid: info.pid,
+      dir: root,
+      mode: info.runMode,
+      channels: info.channels,
+      apiPort: info.apiPort,
+      tunnelPort: info.tunnelPort
+    });
+  }
   if (info.pid) {
     console.log(`OpenACP is running (PID ${info.pid})`);
     if (info.name) console.log(`  Name: ${info.name}`);
@@ -25062,6 +25677,7 @@ var init_status = __esm({
     "use strict";
     init_instance_registry();
     init_instance_context();
+    init_output();
   }
 });
 
@@ -25936,21 +26552,21 @@ Connect messaging platforms (Telegram, Discord) to 28+ AI coding agents via ACP
 
 \x1B[1mServer:\x1B[0m
   openacp                              Start (mode from config)
-  openacp start                        Start as background daemon
-  openacp stop                         Stop background daemon
-  openacp restart                      Restart (same mode)
+  openacp start                        Start as background daemon  \x1B[2m[--json]\x1B[0m
+  openacp stop                         Stop background daemon       \x1B[2m[--json]\x1B[0m
+  openacp restart                      Restart (same mode)          \x1B[2m[--json]\x1B[0m
   openacp restart --foreground         Restart in foreground mode
   openacp restart --daemon             Restart as background daemon
   openacp attach                       Attach to running daemon
-  openacp status                       Show daemon status
+  openacp status                       Show daemon status           \x1B[2m[--json]\x1B[0m
   openacp logs                         Tail daemon log file
   openacp --foreground                 Force foreground mode
 
 \x1B[1mAgent Management:\x1B[0m
-  openacp agents                       Browse all agents (installed + available)
-  openacp agents install <name>        Install an agent from the ACP Registry
-  openacp agents uninstall <name>      Remove an installed agent
-  openacp agents info <name>           Show details, dependencies & setup guide
+  openacp agents                       Browse all agents (installed + available)  \x1B[2m[--json]\x1B[0m
+  openacp agents install <name>        Install an agent from the ACP Registry     \x1B[2m[--json]\x1B[0m
+  openacp agents uninstall <name>      Remove an installed agent                  \x1B[2m[--json]\x1B[0m
+  openacp agents info <name>           Show details, dependencies & setup guide   \x1B[2m[--json]\x1B[0m
   openacp agents run <name> [-- args]  Run agent CLI directly (login, config...)
   openacp agents refresh               Force-refresh agent list from registry
 
@@ -25961,17 +26577,17 @@ Connect messaging platforms (Telegram, Discord) to 28+ AI coding agents via ACP
 
 \x1B[1mConfiguration:\x1B[0m
   openacp config                       Interactive config editor
-  openacp config set <key> <value>     Set a config value
+  openacp config set <key> <value>     Set a config value  \x1B[2m[--json]\x1B[0m
   openacp onboard                      Re-run onboarding setup wizard
   openacp reset                        Re-run setup wizard
   openacp update                       Update to latest version
-  openacp doctor                       Run system diagnostics
+  openacp doctor                       Run system diagnostics  \x1B[2m[--json]\x1B[0m
   openacp doctor --dry-run             Check only, don't fix
 
 \x1B[1mPlugins:\x1B[0m
-  openacp install <package>            Install adapter plugin
-  openacp uninstall <package>          Remove adapter
-  openacp plugins                      List installed plugins
+  openacp install <package>            Install adapter plugin    \x1B[2m[--json]\x1B[0m
+  openacp uninstall <package>          Remove adapter            \x1B[2m[--json]\x1B[0m
+  openacp plugins                      List installed plugins    \x1B[2m[--json]\x1B[0m
   openacp plugin create                Scaffold a new plugin project
 
 \x1B[1mDevelopment:\x1B[0m
@@ -25982,25 +26598,25 @@ Connect messaging platforms (Telegram, Discord) to 28+ AI coding agents via ACP
 \x1B[1mSession Transfer:\x1B[0m
   openacp integrate <agent>            Install handoff integration
   openacp integrate <agent> --uninstall
-  openacp adopt <agent> <id>           Adopt an external session
+  openacp adopt <agent> <id>           Adopt an external session  \x1B[2m[--json]\x1B[0m
 
 \x1B[1mTunnels:\x1B[0m
-  openacp tunnel add <port> [--label name]  Create tunnel to local port
-  openacp tunnel list                       List active tunnels
-  openacp tunnel stop <port>                Stop a tunnel
-  openacp tunnel stop-all                   Stop all user tunnels
+  openacp tunnel add <port> [--label name]  Create tunnel to local port  \x1B[2m[--json]\x1B[0m
+  openacp tunnel list                       List active tunnels           \x1B[2m[--json]\x1B[0m
+  openacp tunnel stop <port>                Stop a tunnel                 \x1B[2m[--json]\x1B[0m
+  openacp tunnel stop-all                   Stop all user tunnels         \x1B[2m[--json]\x1B[0m
 
 \x1B[1mDaemon API:\x1B[0m \x1B[2m(requires running daemon)\x1B[0m
-  openacp api status                   Active sessions
-  openacp api session <id>             Session details
-  openacp api new [agent] [workspace]  Create session
-  openacp api send <id> <prompt>       Send prompt
-  openacp api cancel <id>              Cancel session
-  openacp api bypass <id> on|off       Toggle bypass permissions
-  openacp api topics [--status ...]    List topics
-  openacp api cleanup [--status ...]   Cleanup old topics
-  openacp api health                   System health check
-  openacp api restart                  Restart daemon
+  openacp api status                   Active sessions     \x1B[2m[--json]\x1B[0m
+  openacp api session <id>             Session details     \x1B[2m[--json]\x1B[0m
+  openacp api new [agent] [workspace]  Create session      \x1B[2m[--json]\x1B[0m
+  openacp api send <id> <prompt>       Send prompt         \x1B[2m[--json]\x1B[0m
+  openacp api cancel <id>              Cancel session      \x1B[2m[--json]\x1B[0m
+  openacp api bypass <id> on|off       Toggle bypass permissions  \x1B[2m[--json]\x1B[0m
+  openacp api topics [--status ...]    List topics         \x1B[2m[--json]\x1B[0m
+  openacp api cleanup [--status ...]   Cleanup old topics  \x1B[2m[--json]\x1B[0m
+  openacp api health                   System health check \x1B[2m[--json]\x1B[0m
+  openacp api restart                  Restart daemon      \x1B[2m[--json]\x1B[0m
 
 \x1B[1mWorkspace Flags:\x1B[0m
   --local              Use workspace in current directory
@@ -26009,26 +26625,42 @@ Connect messaging platforms (Telegram, Discord) to 28+ AI coding agents via ACP
   --from <path>        Copy settings from existing workspace (on create)
   --name <name>        Set workspace name (on create)
 
+\x1B[1mOutput Flags:\x1B[0m
+  --json               Output result as JSON (single-line, stdout)
+                       Commands marked \x1B[2m[--json]\x1B[0m support machine-readable output.
+                       Success: { "success": true, "data": { ... } }
+                       Error:   { "success": false, "error": { "code": "...", "message": "..." } }
+
 \x1B[2mMore info: https://github.com/Open-ACP/OpenACP\x1B[0m
 `);
 }
 
 // src/cli/commands/version.ts
-async function cmdVersion() {
+init_output();
+async function cmdVersion(args2 = []) {
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
   const { getCurrentVersion: getCurrentVersion2 } = await Promise.resolve().then(() => (init_version(), version_exports));
-  console.log(`openacp v${getCurrentVersion2()}`);
+  const version = getCurrentVersion2();
+  if (json) {
+    jsonSuccess({ version });
+  }
+  console.log(`openacp v${version}`);
 }
 
 // src/cli/commands/install.ts
 init_helpers();
+init_output();
 import { execSync } from "child_process";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
 async function cmdInstall(args2, instanceRoot) {
-  const root = instanceRoot ?? path.join(os.homedir(), ".openacp");
-  const pluginsDir = path.join(root, "plugins");
-  if (wantsHelp(args2)) {
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
+  const root = instanceRoot ?? path2.join(os2.homedir(), ".openacp");
+  const pluginsDir = path2.join(root, "plugins");
+  if (!json && wantsHelp(args2)) {
     console.log(`
 \x1B[1mopenacp install\x1B[0m \u2014 Install a plugin adapter
 
@@ -26040,36 +26672,50 @@ async function cmdInstall(args2, instanceRoot) {
 
 Installs the plugin to ~/.openacp/plugins/.
 
+\x1B[1mOptions:\x1B[0m
+  --json          Output result as JSON
+  -h, --help      Show this help message
+
 \x1B[1mExamples:\x1B[0m
   openacp install @openacp/adapter-discord
 `);
     return;
   }
-  const pkg = args2[0];
+  const pkg = args2.filter((a) => a !== "--json")[0];
   if (!pkg) {
+    if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Package name is required");
     console.error("Usage: openacp install <package>");
     process.exit(1);
   }
-  fs.mkdirSync(pluginsDir, { recursive: true });
-  const pkgPath = path.join(pluginsDir, "package.json");
-  if (!fs.existsSync(pkgPath)) {
-    fs.writeFileSync(pkgPath, JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2));
+  fs2.mkdirSync(pluginsDir, { recursive: true });
+  const pkgPath = path2.join(pluginsDir, "package.json");
+  if (!fs2.existsSync(pkgPath)) {
+    fs2.writeFileSync(pkgPath, JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2));
+  }
+  if (!json) console.log(`Installing ${pkg}...`);
+  try {
+    execSync(`npm install ${pkg} --prefix "${pluginsDir}"`, { stdio: json ? "pipe" : "inherit" });
+  } catch (err) {
+    if (json) jsonError(ErrorCodes.INSTALL_FAILED, `Failed to install ${pkg}`);
+    process.exit(1);
   }
-  console.log(`Installing ${pkg}...`);
-  execSync(`npm install ${pkg} --prefix "${pluginsDir}"`, { stdio: "inherit" });
+  if (json) jsonSuccess({ plugin: pkg, installed: true });
   console.log(`Plugin ${pkg} installed successfully.`);
 }
 
 // src/cli/commands/uninstall.ts
 init_helpers();
+init_output();
 import { execSync as execSync2 } from "child_process";
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os2 from "os";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os3 from "os";
 async function cmdUninstall(args2, instanceRoot) {
-  const root = instanceRoot ?? path2.join(os2.homedir(), ".openacp");
-  const pluginsDir = path2.join(root, "plugins");
-  if (wantsHelp(args2)) {
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
+  const root = instanceRoot ?? path3.join(os3.homedir(), ".openacp");
+  const pluginsDir = path3.join(root, "plugins");
+  if (!json && wantsHelp(args2)) {
     console.log(`
 \x1B[1mopenacp uninstall\x1B[0m \u2014 Remove a plugin adapter
 
@@ -26079,36 +26725,54 @@ async function cmdUninstall(args2, instanceRoot) {
 \x1B[1mArguments:\x1B[0m
   <package>       npm package name to remove
 
+\x1B[1mOptions:\x1B[0m
+  --json          Output result as JSON
+  -h, --help      Show this help message
+
 \x1B[1mExamples:\x1B[0m
   openacp uninstall @openacp/adapter-discord
 `);
     return;
   }
-  const pkg = args2[0];
+  const pkg = args2.filter((a) => a !== "--json")[0];
   if (!pkg) {
+    if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Package name is required");
     console.error("Usage: openacp uninstall <package>");
     process.exit(1);
   }
-  fs2.mkdirSync(pluginsDir, { recursive: true });
-  const pkgPath = path2.join(pluginsDir, "package.json");
-  if (!fs2.existsSync(pkgPath)) {
-    fs2.writeFileSync(pkgPath, JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2));
+  fs3.mkdirSync(pluginsDir, { recursive: true });
+  const pkgPath = path3.join(pluginsDir, "package.json");
+  if (!fs3.existsSync(pkgPath)) {
+    fs3.writeFileSync(pkgPath, JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2));
   }
-  console.log(`Uninstalling ${pkg}...`);
-  execSync2(`npm uninstall ${pkg} --prefix "${pluginsDir}"`, { stdio: "inherit" });
+  if (!json) console.log(`Uninstalling ${pkg}...`);
+  try {
+    execSync2(`npm uninstall ${pkg} --prefix "${pluginsDir}"`, { stdio: json ? "pipe" : "inherit" });
+  } catch (err) {
+    if (json) jsonError(ErrorCodes.UNINSTALL_FAILED, `Failed to uninstall ${pkg}`);
+    process.exit(1);
+  }
+  if (json) jsonSuccess({ plugin: pkg, uninstalled: true });
   console.log(`Plugin ${pkg} uninstalled.`);
 }
 
 // src/cli/commands/plugins.ts
 init_helpers();
+init_output();
 async function cmdPlugins(args2 = [], instanceRoot) {
-  if (wantsHelp(args2)) {
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
+  if (!json && wantsHelp(args2)) {
     console.log(`
 \x1B[1mopenacp plugins\x1B[0m \u2014 List installed plugins
 
 \x1B[1mUsage:\x1B[0m
   openacp plugins
 
+\x1B[1mOptions:\x1B[0m
+  --json          Output result as JSON
+  -h, --help      Show this help message
+
 Shows all plugins registered in the plugin registry.
 `);
     return;
@@ -26121,6 +26785,19 @@ Shows all plugins registered in the plugin registry.
   const registry = new PluginRegistry2(registryPath);
   await registry.load();
   const plugins = registry.list();
+  if (json) {
+    const pluginList = [];
+    for (const [name, entry] of plugins) {
+      pluginList.push({
+        name,
+        version: entry.version,
+        enabled: entry.enabled !== false,
+        source: entry.source ?? "unknown",
+        description: entry.description ?? ""
+      });
+    }
+    jsonSuccess({ plugins: pluginList });
+  }
   if (plugins.size === 0) {
     console.log("No plugins installed.");
   } else {
@@ -26150,6 +26827,10 @@ async function cmdPlugin(args2 = [], instanceRoot) {
   openacp plugin configure <name>        Run interactive configuration
   openacp plugin create                  Scaffold a new plugin project
 
+\x1B[1mOptions:\x1B[0m
+  --json          Output result as JSON
+  -h, --help      Show this help message
+
 \x1B[1mExamples:\x1B[0m
   openacp plugin list
   openacp plugin search telegram
@@ -26164,7 +26845,7 @@ async function cmdPlugin(args2 = [], instanceRoot) {
   }
   switch (subcommand) {
     case "list":
-      return cmdPlugins([], instanceRoot);
+      return cmdPlugins(isJsonMode(args2) ? ["--json"] : [], instanceRoot);
     case "search": {
       const { cmdPluginSearch: cmdPluginSearch2 } = await Promise.resolve().then(() => (init_plugin_search(), plugin_search_exports));
       await cmdPluginSearch2(args2.slice(1));
@@ -26174,39 +26855,43 @@ async function cmdPlugin(args2 = [], instanceRoot) {
     case "install": {
       const pkg = args2[1];
       if (!pkg) {
+        if (isJsonMode(args2)) jsonError(ErrorCodes.MISSING_ARGUMENT, "Package name is required");
         console.error("Error: missing package name. Usage: openacp plugin add <package>");
         process.exit(1);
       }
-      await installPlugin(pkg, instanceRoot);
+      await installPlugin(pkg, instanceRoot, isJsonMode(args2));
       return;
     }
     case "remove":
     case "uninstall": {
       const pkg = args2[1];
       if (!pkg) {
+        if (isJsonMode(args2)) jsonError(ErrorCodes.MISSING_ARGUMENT, "Package name is required");
         console.error("Error: missing package name. Usage: openacp plugin remove <package> [--purge]");
         process.exit(1);
       }
       const purge = args2.includes("--purge");
-      await uninstallPlugin(pkg, purge, instanceRoot);
+      await uninstallPlugin(pkg, purge, instanceRoot, isJsonMode(args2));
       return;
     }
     case "enable": {
       const name = args2[1];
       if (!name) {
+        if (isJsonMode(args2)) jsonError(ErrorCodes.MISSING_ARGUMENT, "Plugin name is required");
         console.error("Error: missing plugin name. Usage: openacp plugin enable <name>");
         process.exit(1);
       }
-      await setPluginEnabled(name, true, instanceRoot);
+      await setPluginEnabled(name, true, instanceRoot, isJsonMode(args2));
       return;
     }
     case "disable": {
       const name = args2[1];
       if (!name) {
+        if (isJsonMode(args2)) jsonError(ErrorCodes.MISSING_ARGUMENT, "Plugin name is required");
         console.error("Error: missing plugin name. Usage: openacp plugin disable <name>");
         process.exit(1);
       }
-      await setPluginEnabled(name, false, instanceRoot);
+      await setPluginEnabled(name, false, instanceRoot, isJsonMode(args2));
       return;
     }
     case "configure": {
@@ -26229,7 +26914,8 @@ async function cmdPlugin(args2 = [], instanceRoot) {
       process.exit(1);
   }
 }
-async function setPluginEnabled(name, enabled, instanceRoot) {
+async function setPluginEnabled(name, enabled, instanceRoot, json = false) {
+  if (json) await muteForJson();
   const os31 = await import("os");
   const path65 = await import("path");
   const { PluginRegistry: PluginRegistry2 } = await Promise.resolve().then(() => (init_plugin_registry(), plugin_registry_exports));
@@ -26239,11 +26925,13 @@ async function setPluginEnabled(name, enabled, instanceRoot) {
   await registry.load();
   const entry = registry.get(name);
   if (!entry) {
+    if (json) jsonError(ErrorCodes.PLUGIN_NOT_FOUND, `Plugin "${name}" not found.`);
     console.error(`Plugin "${name}" not found. Run "openacp plugin list" to see installed plugins.`);
     process.exit(1);
   }
   registry.setEnabled(name, enabled);
   await registry.save();
+  if (json) jsonSuccess({ plugin: name, enabled });
   console.log(`Plugin ${name} ${enabled ? "enabled" : "disabled"}. Restart to apply.`);
 }
 async function configurePlugin(name, instanceRoot) {
@@ -26269,7 +26957,8 @@ async function configurePlugin(name, instanceRoot) {
     console.log(`Plugin ${name} has no configure or install hook.`);
   }
 }
-async function installPlugin(input2, instanceRoot) {
+async function installPlugin(input2, instanceRoot, json = false) {
+  if (json) await muteForJson();
   const os31 = await import("os");
   const path65 = await import("path");
   const { execFileSync: execFileSync8 } = await import("child_process");
@@ -26310,16 +26999,16 @@ async function installPlugin(input2, instanceRoot) {
     const registry = await client.getRegistry();
     registryPlugin = registry.plugins.find((p2) => p2.name === pkgName || p2.npm === pkgName);
     if (registryPlugin) {
-      console.log(`Resolved from registry: ${pkgName} \u2192 ${registryPlugin.npm}`);
+      if (!json) console.log(`Resolved from registry: ${pkgName} \u2192 ${registryPlugin.npm}`);
       pkgName = registryPlugin.npm;
-      if (!registryPlugin.verified) {
+      if (!json && !registryPlugin.verified) {
         console.log("\u26A0\uFE0F  This plugin is not verified by the OpenACP team.");
       }
     }
   } catch {
   }
   const installSpec = pkgVersion ? `${pkgName}@${pkgVersion}` : pkgName;
-  console.log(`Installing ${installSpec}...`);
+  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 = path65.join(root, "plugins", "data");
@@ -26340,6 +27029,7 @@ async function installPlugin(input2, instanceRoot) {
       description: builtinPlugin.description
     });
     await pluginRegistry.save();
+    if (json) jsonSuccess({ plugin: builtinPlugin.name, version: builtinPlugin.version, installed: true });
     console.log(`\u2713 ${builtinPlugin.name} installed! Restart to activate.`);
     return;
   }
@@ -26347,10 +27037,11 @@ async function installPlugin(input2, instanceRoot) {
   const nodeModulesDir = path65.join(pluginsDir, "node_modules");
   try {
     execFileSync8("npm", ["install", installSpec, "--prefix", pluginsDir, "--save"], {
-      stdio: "inherit",
+      stdio: json ? "pipe" : "inherit",
       timeout: 6e4
     });
   } catch {
+    if (json) jsonError(ErrorCodes.INSTALL_FAILED, `Failed to install ${installSpec}`);
     console.error(`Failed to install ${installSpec}. Check the package name and try again.`);
     process.exit(1);
   }
@@ -26365,10 +27056,12 @@ async function installPlugin(input2, instanceRoot) {
     if (minVersion) {
       const { compareVersions: compareVersions2 } = await Promise.resolve().then(() => (init_version(), version_exports));
       if (compareVersions2(cliVersion, minVersion) < 0) {
-        console.log(`
+        if (!json) {
+          console.log(`
 \u26A0\uFE0F  This plugin requires OpenACP >= ${minVersion}. You have ${cliVersion}.`);
-        console.log(`   Run 'openacp update' to get the latest version.
+          console.log(`   Run 'openacp update' to get the latest version.
 `);
+        }
       }
     }
     const pluginModule = await import(path65.join(pluginRoot, installedPkg.main ?? "dist/index.js"));
@@ -26385,6 +27078,7 @@ async function installPlugin(input2, instanceRoot) {
       description: plugin2?.description ?? installedPkg.description
     });
     await pluginRegistry.save();
+    if (json) jsonSuccess({ plugin: plugin2?.name ?? pkgName, version: installedPkg.version, installed: true });
     console.log(`\u2713 ${plugin2?.name ?? pkgName} installed! Restart to activate.`);
   } catch (err) {
     pluginRegistry.register(pkgName, {
@@ -26394,10 +27088,12 @@ async function installPlugin(input2, instanceRoot) {
       settingsPath: settingsManager.getSettingsPath(pkgName)
     });
     await pluginRegistry.save();
+    if (json) jsonSuccess({ plugin: pkgName, version: pkgVersion ?? "unknown", installed: true });
     console.log(`\u2713 ${pkgName} installed (npm only). Restart to activate.`);
   }
 }
-async function uninstallPlugin(name, purge, instanceRoot) {
+async function uninstallPlugin(name, purge, instanceRoot, json = false) {
+  if (json) await muteForJson();
   const os31 = await import("os");
   const path65 = await import("path");
   const fs53 = await import("fs");
@@ -26408,10 +27104,12 @@ async function uninstallPlugin(name, purge, instanceRoot) {
   await registry.load();
   const entry = registry.get(name);
   if (!entry) {
+    if (json) jsonError(ErrorCodes.PLUGIN_NOT_FOUND, `Plugin "${name}" not installed.`);
     console.error(`Plugin "${name}" not installed.`);
     process.exit(1);
   }
   if (entry.source === "builtin") {
+    if (json) jsonError(ErrorCodes.UNINSTALL_FAILED, `Cannot uninstall built-in plugin "${name}". Use "openacp plugin disable ${name}" instead.`);
     console.error(`Cannot uninstall built-in plugin. Use "openacp plugin disable ${name}" instead.`);
     process.exit(1);
   }
@@ -26434,12 +27132,14 @@ async function uninstallPlugin(name, purge, instanceRoot) {
   }
   registry.remove(name);
   await registry.save();
+  if (json) jsonSuccess({ plugin: name, uninstalled: true });
   console.log(`Plugin ${name} uninstalled${purge ? " (purged)" : ""}.`);
 }
 
 // src/cli/commands/api.ts
 init_api_client();
 init_helpers();
+init_output();
 function printApiHelp() {
   console.log(`
 \x1B[1mopenacp api\x1B[0m \u2014 Interact with the running OpenACP daemon
@@ -26481,6 +27181,7 @@ function printApiHelp() {
   openacp api version                      Show daemon version
 
 \x1B[1mOptions:\x1B[0m
+  --json                                   Output result as JSON
   -h, --help                               Show this help message
 `);
 }
@@ -26705,8 +27406,11 @@ Shows the version of the currently running daemon process.
     printApiHelp();
     return;
   }
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
   const port = readApiPort(void 0, instanceRoot);
   if (port === null) {
+    if (json) jsonError(ErrorCodes.DAEMON_NOT_RUNNING, "OpenACP is not running.");
     console.error("OpenACP is not running. Start with `openacp start`");
     process.exit(1);
   }
@@ -26729,9 +27433,11 @@ Shows the version of the currently running daemon process.
       });
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess(data);
       console.log("Session created");
       console.log(`  ID        : ${data.sessionId}`);
       console.log(`  Agent     : ${data.agent}`);
@@ -26742,6 +27448,7 @@ Shows the version of the currently running daemon process.
     } else if (subCmd === "cancel") {
       const sessionId = args2[1];
       if (!sessionId) {
+        if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Session ID is required");
         console.error("Usage: openacp api cancel <session-id>");
         process.exit(1);
       }
@@ -26750,13 +27457,16 @@ Shows the version of the currently running daemon process.
       });
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess({ cancelled: true, sessionId });
       console.log(`Session ${sessionId} cancelled`);
     } else if (subCmd === "status") {
       const res = await call("/api/sessions");
       const data = await res.json();
+      if (json) jsonSuccess(data);
       if (data.sessions.length === 0) {
         console.log("No active sessions.");
       } else {
@@ -26770,6 +27480,7 @@ Shows the version of the currently running daemon process.
     } else if (subCmd === "agents") {
       const res = await call("/api/agents");
       const data = await res.json();
+      if (json) jsonSuccess(data);
       console.log("Available agents:");
       for (const a of data.agents) {
         const isDefault = a.name === data.default ? " (default)" : "";
@@ -26781,6 +27492,7 @@ Shows the version of the currently running daemon process.
       const query = statusParam ? `?status=${encodeURIComponent(statusParam)}` : "";
       const res = await call(`/api/topics${query}`);
       const data = await res.json();
+      if (json) jsonSuccess(data);
       if (data.topics.length === 0) {
         console.log("No topics found.");
       } else {
@@ -26795,6 +27507,7 @@ Shows the version of the currently running daemon process.
     } else if (subCmd === "delete-topic") {
       const sessionId = args2[1];
       if (!sessionId) {
+        if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Session ID is required");
         console.error("Usage: openacp api delete-topic <session-id> [--force]");
         process.exit(1);
       }
@@ -26804,13 +27517,16 @@ Shows the version of the currently running daemon process.
       const data = await res.json();
       if (res.status === 409) {
         const session = data.session;
+        if (json) jsonError(ErrorCodes.API_ERROR, `Session "${sessionId}" is active (${session?.status}). Use --force to delete.`);
         console.error(`Session "${sessionId}" is active (${session?.status}). Use --force to delete.`);
         process.exit(1);
       }
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess(data);
       const topicLabel = data.topicId ? `Topic #${data.topicId}` : "headless session";
       console.log(`${topicLabel} deleted (session ${sessionId})`);
     } else if (subCmd === "cleanup") {
@@ -26824,6 +27540,7 @@ Shows the version of the currently running daemon process.
         body: JSON.stringify(body)
       });
       const data = await res.json();
+      if (json) jsonSuccess(data);
       if (data.deleted.length === 0 && data.failed.length === 0) {
         console.log("Nothing to clean up.");
       } else {
@@ -26835,11 +27552,13 @@ Shows the version of the currently running daemon process.
     } else if (subCmd === "send") {
       const sessionId = args2[1];
       if (!sessionId) {
+        if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Session ID is required");
         console.error("Usage: openacp api send <session-id> <prompt>");
         process.exit(1);
       }
       const prompt = args2.slice(2).join(" ");
       if (!prompt) {
+        if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Prompt is required");
         console.error("Usage: openacp api send <session-id> <prompt>");
         process.exit(1);
       }
@@ -26850,22 +27569,27 @@ Shows the version of the currently running daemon process.
       });
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess(data);
       console.log(`Prompt sent to session ${sessionId} (queue depth: ${data.queueDepth})`);
     } else if (subCmd === "session") {
       const sessionId = args2[1];
       if (!sessionId) {
+        if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Session ID is required");
         console.error("Usage: openacp api session <session-id>");
         process.exit(1);
       }
       const res = await call(`/api/sessions/${encodeURIComponent(sessionId)}`);
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess(data);
       const s = data.session ?? data;
       console.log(`Session details:`);
       console.log(`  ID             : ${s.id}`);
@@ -26882,11 +27606,13 @@ Shows the version of the currently running daemon process.
     } else if (subCmd === "dangerous" || subCmd === "bypass") {
       const sessionId = args2[1];
       if (!sessionId) {
+        if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Session ID is required");
         console.error("Usage: openacp api bypass <session-id> [on|off]");
         process.exit(1);
       }
       const toggle = args2[2];
       if (!toggle || toggle !== "on" && toggle !== "off") {
+        if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Toggle value (on|off) is required");
         console.error("Usage: openacp api bypass <session-id> [on|off]");
         process.exit(1);
       }
@@ -26897,18 +27623,22 @@ Shows the version of the currently running daemon process.
       });
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess(data);
       const state = toggle === "on" ? "enabled" : "disabled";
       console.log(`Bypass permissions ${state} for session ${sessionId}`);
     } else if (subCmd === "health") {
       const res = await call("/api/health");
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess(data);
       const uptimeMs = typeof data.uptime === "number" ? data.uptime : 0;
       const uptimeSeconds = Math.floor(uptimeMs / 1e3);
       const hours = Math.floor(uptimeSeconds / 3600);
@@ -26930,9 +27660,11 @@ Shows the version of the currently running daemon process.
       const res = await call("/api/restart", { method: "POST" });
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess({ restarted: true });
       console.log("Restart signal sent. OpenACP is restarting...");
     } else if (subCmd === "config") {
       console.warn('\u26A0\uFE0F  Deprecated: use "openacp config" or "openacp config set" instead.');
@@ -26941,14 +27673,17 @@ Shows the version of the currently running daemon process.
         const res = await call("/api/config");
         const data = await res.json();
         if (!res.ok) {
+          if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
           console.error(`Error: ${data.error}`);
           process.exit(1);
         }
+        if (json) jsonSuccess(data);
         console.log(JSON.stringify(data.config, null, 2));
       } else if (subSubCmd === "set") {
         const configPath = args2[2];
         const configValue = args2[3];
         if (!configPath || configValue === void 0) {
+          if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Config path and value are required");
           console.error("Usage: openacp api config set <path> <value>");
           process.exit(1);
         }
@@ -26964,14 +27699,17 @@ Shows the version of the currently running daemon process.
         });
         const data = await res.json();
         if (!res.ok) {
+          if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
           console.error(`Error: ${data.error}`);
           process.exit(1);
         }
+        if (json) jsonSuccess(data);
         console.log(`Config updated: ${configPath} = ${JSON.stringify(value)}`);
         if (data.needsRestart) {
           console.log("Note: restart required for this change to take effect.");
         }
       } else {
+        if (json) jsonError(ErrorCodes.UNKNOWN_COMMAND, `Unknown config subcommand: ${subSubCmd}`);
         console.error(`Unknown config subcommand: ${subSubCmd}`);
         console.log("  openacp api config                       Show runtime config");
         console.log("  openacp api config set <key> <value>     Update config value");
@@ -26981,9 +27719,11 @@ Shows the version of the currently running daemon process.
       const res = await call("/api/adapters");
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess(data);
       console.log("Registered adapters:");
       for (const a of data.adapters) {
         console.log(`  ${a.name}  (${a.type})`);
@@ -26992,9 +27732,11 @@ Shows the version of the currently running daemon process.
       const res = await call("/api/tunnel");
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess(data);
       if (data.enabled) {
         console.log(`Tunnel provider : ${data.provider}`);
         console.log(`Tunnel URL      : ${data.url}`);
@@ -27004,6 +27746,7 @@ Shows the version of the currently running daemon process.
     } else if (subCmd === "notify") {
       const message = args2.slice(1).join(" ");
       if (!message) {
+        if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Message is required");
         console.error("Usage: openacp api notify <message>");
         process.exit(1);
       }
@@ -27014,21 +27757,26 @@ Shows the version of the currently running daemon process.
       });
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess({ sent: true });
       console.log("Notification sent to all channels.");
     } else if (subCmd === "version") {
       const res = await call("/api/version");
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess(data);
       console.log(`Daemon version: ${data.version}`);
     } else if (subCmd === "session-config") {
       const sessionId = args2[1];
       if (!sessionId) {
+        if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Session ID is required");
         console.error("Usage: openacp api session-config <session-id> [set <opt> <value> | overrides | dangerous [on|off]]");
         process.exit(1);
       }
@@ -27037,9 +27785,11 @@ Shows the version of the currently running daemon process.
         const res = await call(`/api/sessions/${encodeURIComponent(sessionId)}/config`);
         const data = await res.json();
         if (!res.ok) {
+          if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
           console.error(`Error: ${data.error}`);
           process.exit(1);
         }
+        if (json) jsonSuccess(data);
         const configOptions = data.configOptions;
         const clientOverrides = data.clientOverrides;
         if (!configOptions || configOptions.length === 0) {
@@ -27073,6 +27823,7 @@ Client overrides: ${JSON.stringify(clientOverrides)}`);
         const configId = args2[3];
         const value = args2[4];
         if (!configId || value === void 0) {
+          if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Config ID and value are required");
           console.error("Usage: openacp api session-config <session-id> set <config-id> <value>");
           process.exit(1);
         }
@@ -27083,9 +27834,11 @@ Client overrides: ${JSON.stringify(clientOverrides)}`);
         });
         const data = await res.json();
         if (!res.ok) {
+          if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
           console.error(`Error: ${data.error}`);
           process.exit(1);
         }
+        if (json) jsonSuccess(data);
         console.log(`Config option "${configId}" updated to "${value}"`);
         const configOptions = data.configOptions;
         const updated = configOptions?.find((o) => o.id === configId);
@@ -27096,9 +27849,11 @@ Client overrides: ${JSON.stringify(clientOverrides)}`);
         const res = await call(`/api/sessions/${encodeURIComponent(sessionId)}/config/overrides`);
         const data = await res.json();
         if (!res.ok) {
+          if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
           console.error(`Error: ${data.error}`);
           process.exit(1);
         }
+        if (json) jsonSuccess(data);
         const overrides = data.clientOverrides;
         if (!overrides || Object.keys(overrides).length === 0) {
           console.log("No client overrides set.");
@@ -27111,6 +27866,7 @@ Client overrides: ${JSON.stringify(clientOverrides)}`);
       } else if (configSubCmd === "dangerous") {
         const toggle = args2[3];
         if (toggle && toggle !== "on" && toggle !== "off") {
+          if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Toggle value must be on or off");
           console.error("Usage: openacp api session-config <session-id> dangerous [on|off]");
           process.exit(1);
         }
@@ -27122,23 +27878,28 @@ Client overrides: ${JSON.stringify(clientOverrides)}`);
           });
           const data = await res.json();
           if (!res.ok) {
+            if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
             console.error(`Error: ${data.error}`);
             process.exit(1);
           }
+          if (json) jsonSuccess(data);
           const state = toggle === "on" ? "enabled" : "disabled";
           console.log(`bypassPermissions ${state} for session ${sessionId}`);
         } else {
           const res = await call(`/api/sessions/${encodeURIComponent(sessionId)}/config/overrides`);
           const data = await res.json();
           if (!res.ok) {
+            if (json) jsonError(ErrorCodes.API_ERROR, String(data.error ?? "API request failed"));
             console.error(`Error: ${data.error}`);
             process.exit(1);
           }
+          if (json) jsonSuccess(data);
           const overrides = data.clientOverrides;
           const bypass = overrides?.bypassPermissions;
           console.log(`bypassPermissions: ${bypass ?? false}`);
         }
       } else {
+        if (json) jsonError(ErrorCodes.UNKNOWN_COMMAND, `Unknown session-config subcommand: ${configSubCmd}`);
         console.error(`Unknown session-config subcommand: ${configSubCmd}`);
         console.log("  openacp api session-config <id>                    List config options");
         console.log("  openacp api session-config <id> set <opt> <value>  Set a config option");
@@ -27170,6 +27931,7 @@ Client overrides: ${JSON.stringify(clientOverrides)}`);
         "session-config"
       ];
       const suggestion = suggestMatch2(subCmd ?? "", apiSubcommands);
+      if (json) jsonError(ErrorCodes.UNKNOWN_COMMAND, `Unknown api command: ${subCmd || "(none)"}`);
       console.error(`Unknown api command: ${subCmd || "(none)"}
 `);
       if (suggestion) console.error(`Did you mean: ${suggestion}?
@@ -27178,11 +27940,14 @@ Client overrides: ${JSON.stringify(clientOverrides)}`);
       process.exit(1);
     }
   } catch (err) {
+    if (err instanceof Error && err.message.startsWith("process.exit")) throw err;
     if (err instanceof TypeError && err.cause?.code === "ECONNREFUSED") {
+      if (json) jsonError(ErrorCodes.API_ERROR, "OpenACP is not running (stale port file)");
       console.error("OpenACP is not running (stale port file)");
       removeStalePortFile(void 0, instanceRoot);
       process.exit(1);
     }
+    if (json) jsonError(ErrorCodes.API_ERROR, err.message);
     throw err;
   }
 }
@@ -27190,12 +27955,15 @@ Client overrides: ${JSON.stringify(clientOverrides)}`);
 // src/cli/commands/start.ts
 init_version();
 init_helpers();
+init_output();
 init_instance_hint();
 import path35 from "path";
 import os16 from "os";
 async function cmdStart(args2 = [], instanceRoot) {
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
   const root = instanceRoot ?? path35.join(os16.homedir(), ".openacp");
-  if (wantsHelp(args2)) {
+  if (!json && wantsHelp(args2)) {
     console.log(`
 \x1B[1mopenacp start\x1B[0m \u2014 Start OpenACP as a background daemon
 
@@ -27205,6 +27973,10 @@ async function cmdStart(args2 = [], instanceRoot) {
 Starts the server as a background process (daemon mode).
 Requires an existing config \u2014 run 'openacp' first to set up.
 
+\x1B[1mOptions:\x1B[0m
+  --json          Output result as JSON
+  -h, --help      Show this help message
+
 \x1B[1mSee also:\x1B[0m
   openacp stop       Stop the daemon
   openacp restart    Restart the daemon
@@ -27222,12 +27994,15 @@ Requires an existing config \u2014 run 'openacp' first to set up.
     const config = cm.get();
     const result = startDaemon2(getPidPath2(root), config.logging.logDir, root);
     if ("error" in result) {
+      if (json) jsonError(ErrorCodes.DAEMON_NOT_RUNNING, result.error);
       console.error(result.error);
       process.exit(1);
     }
+    if (json) jsonSuccess({ pid: result.pid, instanceId: path35.basename(root), dir: root });
     printInstanceHint(root);
     console.log(`OpenACP daemon started (PID ${result.pid})`);
   } else {
+    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.');
     process.exit(1);
   }
@@ -27242,6 +28017,7 @@ init_logs();
 // src/cli/commands/config.ts
 init_api_client();
 init_helpers();
+init_output();
 import * as pathMod from "path";
 async function cmdConfig(args2 = [], instanceRoot) {
   const subCmd = args2[0];
@@ -27257,6 +28033,7 @@ async function cmdConfig(args2 = [], instanceRoot) {
   <value>         New value (JSON-parsed if possible, otherwise string)
 
 \x1B[1mOptions:\x1B[0m
+  --json          Output result as JSON
   -h, --help      Show this help message
 
 Works with both running and stopped daemon. When running, uses
@@ -27278,6 +28055,7 @@ the API for live updates. When stopped, edits config file directly.
   openacp config set <key> <value>     Set a config value directly
 
 \x1B[1mOptions:\x1B[0m
+  --json                                 Output result as JSON
   -h, --help                           Show this help message
 
 Works with both running and stopped daemon. When running, uses
@@ -27292,9 +28070,12 @@ the API for live updates. When stopped, edits config file directly.
     return;
   }
   if (subCmd === "set") {
+    const json = isJsonMode(args2);
+    if (json) await muteForJson();
     const configPath = args2[1];
     const configValue = args2[2];
     if (!configPath || configValue === void 0) {
+      if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Missing required arguments: <path> and <value>");
       console.error("Usage: openacp config set <path> <value>");
       process.exit(1);
     }
@@ -27302,6 +28083,7 @@ the API for live updates. When stopped, edits config file directly.
     const topLevelKey = configPath.split(".")[0];
     const validConfigKeys = Object.keys(ConfigSchema2.shape);
     if (!validConfigKeys.includes(topLevelKey)) {
+      if (json) jsonError(ErrorCodes.CONFIG_INVALID, `Unknown config key: ${topLevelKey}`);
       const { suggestMatch: suggestMatch2 } = await Promise.resolve().then(() => (init_suggest(), suggest_exports));
       const suggestion = suggestMatch2(topLevelKey, validConfigKeys);
       console.error(`Unknown config key: ${topLevelKey}`);
@@ -27322,9 +28104,11 @@ the API for live updates. When stopped, edits config file directly.
       }, instanceRoot);
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.API_ERROR, `${data.error}`);
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess({ path: configPath, value, needsRestart: data.needsRestart ?? false });
       console.log(`Config updated: ${configPath} = ${JSON.stringify(value)}`);
       if (data.needsRestart) {
         console.log("Note: restart required for this change to take effect.");
@@ -27333,12 +28117,14 @@ the API for live updates. When stopped, edits config file directly.
       const { ConfigManager: ConfigManager3 } = await Promise.resolve().then(() => (init_config2(), config_exports));
       const cm2 = new ConfigManager3(instanceRoot ? pathMod.join(instanceRoot, "config.json") : void 0);
       if (!await cm2.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.');
         process.exit(1);
       }
       await cm2.load();
       const updates = buildNestedUpdateFromPath(configPath, value);
       await cm2.save(updates);
+      if (json) jsonSuccess({ path: configPath, value, needsRestart: false });
       console.log(`Config updated: ${configPath} = ${JSON.stringify(value)}`);
     }
     return;
@@ -27439,6 +28225,7 @@ installs it globally if an update is available.
 // src/cli/commands/adopt.ts
 init_api_client();
 init_helpers();
+init_output();
 async function cmdAdopt(args2) {
   if (wantsHelp(args2)) {
     console.log(`
@@ -27454,6 +28241,7 @@ async function cmdAdopt(args2) {
 \x1B[1mOptions:\x1B[0m
   --cwd <path>       Working directory for the session (default: current dir)
   --channel <name>   Target channel adapter (e.g. telegram, discord). Default: first registered
+  --json             Output result as JSON
   -h, --help         Show this help message
 
 Transfers an existing agent session into OpenACP so it appears
@@ -27466,9 +28254,23 @@ as a messaging thread. Requires a running daemon.
 `);
     return;
   }
-  const agent = args2[0];
-  const sessionId = args2[1];
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
+  const skipFlags = /* @__PURE__ */ new Set(["--json", "-h", "--help"]);
+  const skipWithValue = /* @__PURE__ */ new Set(["--cwd", "--channel"]);
+  const positional = [];
+  for (let i = 0; i < args2.length; i++) {
+    if (skipWithValue.has(args2[i])) {
+      i++;
+      continue;
+    }
+    if (skipFlags.has(args2[i])) continue;
+    positional.push(args2[i]);
+  }
+  const agent = positional[0];
+  const sessionId = positional[1];
   if (!agent || !sessionId) {
+    if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Missing required arguments: <agent> and <session_id>");
     console.log("Usage: openacp adopt <agent> <session_id> [--cwd <path>] [--channel <name>]");
     console.log("Example: openacp adopt claude abc123-def456 --cwd /path/to/project");
     process.exit(1);
@@ -27479,6 +28281,7 @@ as a messaging thread. Requires a running daemon.
   const channel = channelIdx !== -1 && args2[channelIdx + 1] ? args2[channelIdx + 1] : void 0;
   const port = readApiPort();
   if (!port) {
+    if (json) jsonError(ErrorCodes.DAEMON_NOT_RUNNING, "OpenACP is not running. Start it with: openacp start");
     console.log("OpenACP is not running. Start it with: openacp start");
     process.exit(1);
   }
@@ -27491,6 +28294,7 @@ as a messaging thread. Requires a running daemon.
     });
     const data = await res.json();
     if (data.ok) {
+      if (json) jsonSuccess({ sessionId: data.sessionId, threadId: data.threadId, agent, status: data.status ?? "new" });
       if (data.status === "existing") {
         console.log(`Session already active. Topic pinged.`);
       } else {
@@ -27499,10 +28303,13 @@ as a messaging thread. Requires a running daemon.
       console.log(`  Session ID: ${data.sessionId}`);
       console.log(`  Thread ID:  ${data.threadId}`);
     } else {
+      if (json) jsonError(ErrorCodes.API_ERROR, `${data.message || data.error || "Unknown error"}`);
       console.log(`Error: ${data.message || data.error}`);
       process.exit(1);
     }
   } catch (err) {
+    if (err instanceof Error && err.message.startsWith("process.exit")) throw err;
+    if (json) jsonError(ErrorCodes.API_ERROR, `Failed to connect to OpenACP: ${err instanceof Error ? err.message : err}`);
     console.log(`Failed to connect to OpenACP: ${err instanceof Error ? err.message : err}`);
     process.exit(1);
   }
@@ -27581,8 +28388,11 @@ a "Handoff" slash command to Claude Code.
 
 // src/cli/commands/doctor.ts
 init_helpers();
+init_output();
 async function cmdDoctor(args2, instanceRoot) {
-  if (wantsHelp(args2)) {
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
+  if (!json && wantsHelp(args2)) {
     console.log(`
 \x1B[1mopenacp doctor\x1B[0m \u2014 Run system diagnostics
 
@@ -27591,6 +28401,7 @@ async function cmdDoctor(args2, instanceRoot) {
 
 \x1B[1mOptions:\x1B[0m
   --dry-run       Check only, don't apply any fixes
+  --json          Output result as JSON
   -h, --help      Show this help message
 
 Checks your OpenACP installation for common issues including
@@ -27599,11 +28410,11 @@ Fixable issues can be auto-repaired when not using --dry-run.
 `);
     return;
   }
-  const knownFlags = ["--dry-run"];
+  const knownFlags = ["--dry-run", "--json"];
   const unknownFlags = args2.filter(
     (a) => a.startsWith("--") && !knownFlags.includes(a)
   );
-  if (unknownFlags.length > 0) {
+  if (!json && unknownFlags.length > 0) {
     const { suggestMatch: suggestMatch2 } = await Promise.resolve().then(() => (init_suggest(), suggest_exports));
     for (const flag of unknownFlags) {
       const suggestion = suggestMatch2(flag, knownFlags);
@@ -27612,11 +28423,24 @@ Fixable issues can be auto-repaired when not using --dry-run.
     }
     process.exit(1);
   }
-  const dryRun = args2.includes("--dry-run");
+  const dryRun = args2.includes("--dry-run") || json;
   const { DoctorEngine: DoctorEngine2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
   const engine = new DoctorEngine2({ dryRun, dataDir: instanceRoot });
-  console.log("\n\u{1FA7A} OpenACP Doctor\n");
+  if (!json) console.log("\n\u{1FA7A} OpenACP Doctor\n");
   const report = await engine.runAll();
+  if (json) {
+    jsonSuccess({
+      categories: report.categories.map((c3) => ({
+        name: c3.name,
+        results: c3.results.map((r) => ({ status: r.status, message: r.message }))
+      })),
+      summary: {
+        passed: report.summary.passed,
+        warnings: report.summary.warnings,
+        failed: report.summary.failed
+      }
+    });
+  }
   const icons = { pass: "\x1B[32m\u2705\x1B[0m", warn: "\x1B[33m\u26A0\uFE0F\x1B[0m", fail: "\x1B[31m\u274C\x1B[0m" };
   for (const category of report.categories) {
     console.log(`\x1B[1m\x1B[36m${category.name}\x1B[0m`);
@@ -27659,6 +28483,7 @@ Fixable issues can be auto-repaired when not using --dry-run.
 
 // src/cli/commands/agents.ts
 init_helpers();
+init_output();
 async function createCatalog(instanceRoot) {
   const { AgentCatalog: AgentCatalog2 } = await Promise.resolve().then(() => (init_agent_catalog(), agent_catalog_exports));
   if (instanceRoot) {
@@ -27684,6 +28509,7 @@ async function cmdAgents(args2, instanceRoot) {
   openacp agents refresh               Force-refresh agent list from registry
 
 \x1B[1mOptions:\x1B[0m
+  --json                                 Output result as JSON
   -h, --help                           Show this help message
 
 \x1B[1mExamples:\x1B[0m
@@ -27695,11 +28521,12 @@ async function cmdAgents(args2, instanceRoot) {
 `);
     return;
   }
+  const positional = args2.slice(1).find((a) => !a.startsWith("-"));
   switch (subcommand) {
     case "install":
-      return agentsInstall(args2[1], args2.includes("--force"), wantsHelp(args2), instanceRoot);
+      return agentsInstall(positional, args2.includes("--force"), wantsHelp(args2), instanceRoot, isJsonMode(args2));
     case "uninstall":
-      return agentsUninstall(args2[1], wantsHelp(args2), instanceRoot);
+      return agentsUninstall(positional, wantsHelp(args2), instanceRoot, isJsonMode(args2));
     case "refresh":
       if (wantsHelp(args2)) {
         console.log(`
@@ -27715,7 +28542,7 @@ bypassing the normal staleness check.
       }
       return agentsRefresh(instanceRoot);
     case "info":
-      return agentsInfo(args2[1], wantsHelp(args2), instanceRoot);
+      return agentsInfo(positional, wantsHelp(args2), instanceRoot, isJsonMode(args2));
     case "run":
       return agentsRun(args2[1], args2.slice(2), wantsHelp(args2), instanceRoot);
     case "list":
@@ -27734,22 +28561,24 @@ Run 'openacp agents' to see available agents.`);
   }
 }
 async function agentsList(instanceRoot, json = false) {
+  if (json) await muteForJson();
   const catalog = await createCatalog(instanceRoot);
   catalog.load();
   await catalog.refreshRegistryIfStale();
   const items = catalog.getAvailable();
   if (json) {
-    console.log(JSON.stringify(items.map((item) => ({
-      key: item.key,
-      name: item.name,
-      version: item.version,
-      distribution: item.distribution,
-      description: item.description ?? "",
-      installed: item.installed,
-      available: item.available ?? true,
-      missingDeps: item.missingDeps ?? []
-    }))));
-    return;
+    jsonSuccess({
+      agents: items.map((item) => ({
+        key: item.key,
+        name: item.name,
+        version: item.version,
+        distribution: item.distribution,
+        description: item.description ?? "",
+        installed: item.installed,
+        available: item.available ?? true,
+        missingDeps: item.missingDeps ?? []
+      }))
+    });
   }
   const installed = items.filter((i) => i.installed);
   const available = items.filter((i) => !i.installed);
@@ -27786,8 +28615,9 @@ async function agentsList(instanceRoot, json = false) {
   );
   console.log("");
 }
-async function agentsInstall(nameOrId, force, help = false, instanceRoot) {
-  if (help || !nameOrId) {
+async function agentsInstall(nameOrId, force, help = false, instanceRoot, json = false) {
+  if (json) await muteForJson();
+  if (!json && (help || !nameOrId)) {
     console.log(`
 \x1B[1mopenacp agents install\x1B[0m \u2014 Install an agent from the ACP Registry
 
@@ -27799,6 +28629,7 @@ async function agentsInstall(nameOrId, force, help = false, instanceRoot) {
 
 \x1B[1mOptions:\x1B[0m
   --force         Reinstall even if already installed
+  --json          Output result as JSON
   -h, --help      Show this help message
 
 \x1B[1mExamples:\x1B[0m
@@ -27809,10 +28640,25 @@ Run 'openacp agents' to see available agents.
 `);
     return;
   }
+  if (!nameOrId) {
+    if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Agent name is required");
+    return;
+  }
   const catalog = await createCatalog(instanceRoot);
   catalog.load();
   await catalog.refreshRegistryIfStale();
-  const progress = {
+  const progress = json ? {
+    onStart() {
+    },
+    onStep() {
+    },
+    onDownloadProgress() {
+    },
+    onSuccess() {
+    },
+    onError() {
+    }
+  } : {
     onStart(_id, name) {
       process.stdout.write(`
   \u23F3 Installing ${name}...
@@ -27842,6 +28688,7 @@ Run 'openacp agents' to see available agents.
   };
   const result = await catalog.install(nameOrId, progress, force);
   if (!result.ok) {
+    if (json) jsonError(ErrorCodes.INSTALL_FAILED, result.error ?? "Installation failed");
     if (result.error?.includes("not found")) {
       const { suggestMatch: suggestMatch2 } = await Promise.resolve().then(() => (init_suggest(), suggest_exports));
       const allKeys = catalog.getAvailable().map((a) => a.key);
@@ -27850,6 +28697,10 @@ Run 'openacp agents' to see available agents.
     }
     process.exit(1);
   }
+  if (json) {
+    const installed = catalog.getInstalledAgent(result.agentKey);
+    jsonSuccess({ key: result.agentKey, version: installed?.version ?? "unknown", installed: true });
+  }
   const { getAgentCapabilities: getAgentCapabilities2 } = await Promise.resolve().then(() => (init_agent_dependencies(), agent_dependencies_exports));
   const caps = getAgentCapabilities2(result.agentKey);
   if (caps.integration) {
@@ -27871,8 +28722,9 @@ Run 'openacp agents' to see available agents.
 `);
   }
 }
-async function agentsUninstall(name, help = false, instanceRoot) {
-  if (help || !name) {
+async function agentsUninstall(name, help = false, instanceRoot, json = false) {
+  if (json) await muteForJson();
+  if (!json && (help || !name)) {
     console.log(`
 \x1B[1mopenacp agents uninstall\x1B[0m \u2014 Remove an installed agent
 
@@ -27882,11 +28734,19 @@ async function agentsUninstall(name, help = false, instanceRoot) {
 \x1B[1mArguments:\x1B[0m
   <name>          Agent name to remove
 
+\x1B[1mOptions:\x1B[0m
+  --json          Output result as JSON
+  -h, --help      Show this help message
+
 \x1B[1mExamples:\x1B[0m
   openacp agents uninstall gemini
 `);
     return;
   }
+  if (!name) {
+    if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Agent name is required");
+    return;
+  }
   const catalog = await createCatalog(instanceRoot);
   catalog.load();
   const result = await catalog.uninstall(name);
@@ -27898,10 +28758,12 @@ async function agentsUninstall(name, help = false, instanceRoot) {
       await uninstallIntegration2(name, caps.integration);
       console.log(`  \x1B[32m\u2713\x1B[0m Handoff integration removed for ${name}`);
     }
+    if (json) jsonSuccess({ key: name, uninstalled: true });
     console.log(`
   \x1B[32m\u2713 ${name} removed.\x1B[0m
 `);
   } else {
+    if (json) jsonError(ErrorCodes.UNINSTALL_FAILED, result.error ?? "Uninstall failed");
     console.log(`
   \x1B[31m\u2717 ${result.error}\x1B[0m`);
     if (result.error?.includes("not installed")) {
@@ -27920,8 +28782,9 @@ async function agentsRefresh(instanceRoot) {
   await catalog.fetchRegistry();
   console.log("  \x1B[32m\u2713 Agent list updated.\x1B[0m\n");
 }
-async function agentsInfo(nameOrId, help = false, instanceRoot) {
-  if (help || !nameOrId) {
+async function agentsInfo(nameOrId, help = false, instanceRoot, json = false) {
+  if (json) await muteForJson();
+  if (!json && (help || !nameOrId)) {
     console.log(`
 \x1B[1mopenacp agents info\x1B[0m \u2014 Show agent details, dependencies & setup guide
 
@@ -27934,17 +28797,37 @@ async function agentsInfo(nameOrId, help = false, instanceRoot) {
 Shows version, distribution type, command, setup steps, and
 whether the agent is installed or available from the registry.
 
+\x1B[1mOptions:\x1B[0m
+  --json          Output result as JSON
+  -h, --help      Show this help message
+
 \x1B[1mExamples:\x1B[0m
   openacp agents info claude
   openacp agents info cursor
 `);
     return;
   }
+  if (!nameOrId) {
+    if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Agent name is required");
+    return;
+  }
   const catalog = await createCatalog(instanceRoot);
   catalog.load();
   const { getAgentSetup: getAgentSetup2 } = await Promise.resolve().then(() => (init_agent_dependencies(), agent_dependencies_exports));
   const installed = catalog.getInstalledAgent(nameOrId);
   if (installed) {
+    if (json) {
+      jsonSuccess({
+        key: installed.registryId ?? nameOrId,
+        name: installed.name,
+        version: installed.version,
+        distribution: installed.distribution,
+        installed: true,
+        command: installed.command,
+        binaryPath: installed.binaryPath ?? null,
+        registryId: installed.registryId ?? null
+      });
+    }
     console.log(`
   \x1B[1m${installed.name}\x1B[0m`);
     console.log(`  Version:      ${installed.version}`);
@@ -27967,6 +28850,15 @@ whether the agent is installed or available from the registry.
   }
   const regAgent = catalog.findRegistryAgent(nameOrId);
   if (regAgent) {
+    if (json) {
+      jsonSuccess({
+        key: regAgent.id,
+        name: regAgent.name,
+        version: regAgent.version,
+        description: regAgent.description ?? "",
+        installed: false
+      });
+    }
     const availability = catalog.checkAvailability(nameOrId);
     console.log(`
   \x1B[1m${regAgent.name}\x1B[0m \x1B[2m(not installed)\x1B[0m`);
@@ -27989,6 +28881,7 @@ whether the agent is installed or available from the registry.
 `);
     return;
   }
+  if (json) jsonError(ErrorCodes.AGENT_NOT_FOUND, `"${nameOrId}" not found.`);
   const { suggestMatch: suggestMatch2 } = await Promise.resolve().then(() => (init_suggest(), suggest_exports));
   const allKeys = catalog.getAvailable().map((a) => a.key);
   const suggestion = suggestMatch2(nameOrId, allKeys);
@@ -28070,10 +28963,14 @@ ACP-specific flags are automatically stripped.
 
 // src/cli/commands/tunnel.ts
 init_api_client();
+init_output();
 async function cmdTunnel(args2, instanceRoot) {
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
   const subCmd = args2[0];
   const port = readApiPort(void 0, instanceRoot);
   if (port === null) {
+    if (json) jsonError(ErrorCodes.DAEMON_NOT_RUNNING, "OpenACP is not running.");
     console.error("OpenACP is not running. Start with `openacp start`");
     process.exit(1);
   }
@@ -28082,6 +28979,7 @@ async function cmdTunnel(args2, instanceRoot) {
     if (subCmd === "add") {
       const tunnelPort = args2[1];
       if (!tunnelPort) {
+        if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Port is required");
         console.error("Usage: openacp tunnel add <port> [--label name] [--session id]");
         process.exit(1);
       }
@@ -28099,13 +28997,25 @@ async function cmdTunnel(args2, instanceRoot) {
       });
       const data = await res.json();
       if (!res.ok) {
+        if (json) jsonError(ErrorCodes.TUNNEL_ERROR, String(data.error));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess({ port: data.port, publicUrl: data.publicUrl });
       console.log(`Tunnel active: port ${data.port} \u2192 ${data.publicUrl}`);
     } else if (subCmd === "list") {
       const res = await call("/api/tunnel/list");
       const data = await res.json();
+      if (json) {
+        jsonSuccess({
+          tunnels: data.map((t) => ({
+            port: t.port,
+            label: t.label ?? null,
+            publicUrl: t.publicUrl ?? null,
+            status: t.status ?? "unknown"
+          }))
+        });
+      }
       if (data.length === 0) {
         console.log("No active tunnels.");
         return;
@@ -28120,23 +29030,28 @@ async function cmdTunnel(args2, instanceRoot) {
     } else if (subCmd === "stop") {
       const tunnelPort = args2[1];
       if (!tunnelPort) {
+        if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "Port is required");
         console.error("Usage: openacp tunnel stop <port>");
         process.exit(1);
       }
       const res = await call(`/api/tunnel/${tunnelPort}`, { method: "DELETE" });
       if (!res.ok) {
         const data = await res.json();
+        if (json) jsonError(ErrorCodes.TUNNEL_ERROR, String(data.error));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess({ port: parseInt(tunnelPort, 10), stopped: true });
       console.log(`Tunnel stopped: port ${tunnelPort}`);
     } else if (subCmd === "stop-all") {
       const res = await call("/api/tunnel", { method: "DELETE" });
       if (!res.ok) {
         const data = await res.json();
+        if (json) jsonError(ErrorCodes.TUNNEL_ERROR, String(data.error));
         console.error(`Error: ${data.error}`);
         process.exit(1);
       }
+      if (json) jsonSuccess({ stopped: true });
       console.log("All user tunnels stopped.");
     } else {
       console.log(`
@@ -28145,10 +29060,16 @@ Tunnel Management:
   openacp tunnel list
   openacp tunnel stop <port>
   openacp tunnel stop-all
+
+Options:
+  --json          Output result as JSON
 `);
     }
   } catch (err) {
-    console.error(`Failed to connect to daemon: ${err.message}`);
+    const msg = err.message;
+    if (msg?.startsWith("process.exit")) throw err;
+    if (json) jsonError(ErrorCodes.TUNNEL_ERROR, msg);
+    console.error(`Failed to connect to daemon: ${msg}`);
     process.exit(1);
   }
 }
@@ -28179,9 +29100,11 @@ async function cmdOnboard(instanceRoot) {
 // src/cli/commands/default.ts
 init_version();
 init_instance_context();
+init_instance_registry();
 init_instance_hint();
 import path58 from "path";
 import os27 from "os";
+import { randomUUID as randomUUID5 } from "crypto";
 async function cmdDefault(command2, instanceRoot) {
   const root = instanceRoot ?? path58.join(os27.homedir(), ".openacp");
   const pluginsDataDir = path58.join(root, "plugins", "data");
@@ -28251,8 +29174,11 @@ async function cmdDefault(command2, instanceRoot) {
   markRunning2(root);
   printInstanceHint(root);
   const { startServer: startServer2 } = await Promise.resolve().then(() => (init_main(), main_exports));
+  const reg = new InstanceRegistry(path58.join(getGlobalRoot(), "instances.json"));
+  reg.load();
+  const existingEntry = reg.getByRoot(root);
   const ctx = createInstanceContext({
-    id: "default",
+    id: existingEntry?.id ?? randomUUID5(),
     root,
     isGlobal: root === getGlobalRoot()
   });
@@ -28450,10 +29376,13 @@ Press Ctrl+C to detach.
 // src/cli/commands/remote.ts
 init_api_client();
 init_instance_registry();
+init_output();
 import path61 from "path";
 import os29 from "os";
 import qrcode from "qrcode-terminal";
 async function cmdRemote(args2, instanceRoot) {
+  const json = isJsonMode(args2);
+  if (json) await muteForJson();
   const role = extractFlag(args2, "--role") ?? "admin";
   const expire = extractFlag(args2, "--expire") ?? "24h";
   const scopesRaw = extractFlag(args2, "--scopes");
@@ -28469,6 +29398,7 @@ async function cmdRemote(args2, instanceRoot) {
     await registry.load();
     const entry = registry.get(instanceId);
     if (!entry) {
+      if (json) jsonError(ErrorCodes.INSTANCE_NOT_FOUND, `Workspace "${instanceId}" not found. Run "openacp status" to see workspaces.`);
       console.error(`Workspace "${instanceId}" not found. Run "openacp status" to see workspaces.`);
       process.exit(1);
     }
@@ -28476,21 +29406,26 @@ async function cmdRemote(args2, instanceRoot) {
   }
   const port = readApiPort(void 0, resolvedInstanceRoot2);
   if (port === null) {
+    if (json) jsonError(ErrorCodes.DAEMON_NOT_RUNNING, "OpenACP is not running. Start with `openacp start`");
     console.error("OpenACP is not running. Start with `openacp start`");
     process.exit(1);
   }
   try {
     const healthRes = await apiCall(port, "/api/v1/system/health", void 0, resolvedInstanceRoot2);
     if (!healthRes.ok) {
+      if (json) jsonError(ErrorCodes.API_ERROR, "API server is not responding. Try restarting with `openacp restart`");
       console.error("API server is not responding. Try restarting with `openacp restart`");
       process.exit(1);
     }
-  } catch {
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("process.exit")) throw err;
+    if (json) jsonError(ErrorCodes.API_ERROR, "Cannot connect to API server. Is OpenACP running?");
     console.error("Cannot connect to API server. Is OpenACP running?");
     process.exit(1);
   }
   const secret = readApiSecret(void 0, resolvedInstanceRoot2);
   if (!secret) {
+    if (json) jsonError(ErrorCodes.API_ERROR, "Cannot read API secret. Make sure OpenACP is running with the API server enabled.");
     console.error("Cannot read API secret. Make sure OpenACP is running with the API server enabled.");
     process.exit(1);
   }
@@ -28512,11 +29447,14 @@ async function cmdRemote(args2, instanceRoot) {
     }, resolvedInstanceRoot2);
     if (!res.ok) {
       const err = await res.json();
+      if (json) jsonError(ErrorCodes.API_ERROR, `Failed to generate code: ${err.error ?? err.message ?? "Unknown error"}`);
       console.error(`Failed to generate code: ${err.error ?? err.message ?? "Unknown error"}`);
       process.exit(1);
     }
     codeData = await res.json();
   } catch (err) {
+    if (err instanceof Error && err.message.startsWith("process.exit")) throw err;
+    if (json) jsonError(ErrorCodes.API_ERROR, `Failed to generate code: ${err.message}`);
     console.error(`Failed to generate code: ${err.message}`);
     process.exit(1);
   }
@@ -28538,6 +29476,19 @@ async function cmdRemote(args2, instanceRoot) {
   const tunnelLink = tunnelUrl ? `${tunnelUrl}?code=${code}` : null;
   const appLink = tunnelUrl ? `openacp://connect?host=${new URL(tunnelUrl).host}&code=${code}` : null;
   const expireDisplay = expiresAt;
+  if (json) {
+    jsonSuccess({
+      code,
+      name: tokenName,
+      role,
+      expiresAt,
+      urls: {
+        local: localUrl,
+        tunnel: tunnelLink ?? void 0,
+        app: appLink ?? void 0
+      }
+    });
+  }
   const W = 64;
   const line = "\u2500".repeat(W - 4);
   console.log("");
@@ -28578,6 +29529,7 @@ function extractFlag(args2, flag) {
 }
 
 // src/cli/commands/setup.ts
+init_output();
 import * as fs51 from "fs";
 import * as path62 from "path";
 function parseFlag(args2, flag) {
@@ -28588,29 +29540,21 @@ async function cmdSetup(args2, instanceRoot) {
   const workspace = parseFlag(args2, "--workspace");
   const agentRaw = parseFlag(args2, "--agent");
   const json = args2.includes("--json");
+  if (json) await muteForJson();
   if (!workspace) {
-    if (json) {
-      console.log(JSON.stringify({ success: false, error: "--workspace is required" }));
-    } else {
-      console.error("  Error: --workspace <path> is required");
-    }
+    if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "--workspace is required");
+    console.error("  Error: --workspace <path> is required");
     process.exit(1);
   }
   if (!agentRaw) {
-    if (json) {
-      console.log(JSON.stringify({ success: false, error: "--agent is required" }));
-    } else {
-      console.error("  Error: --agent <name> is required");
-    }
+    if (json) jsonError(ErrorCodes.MISSING_ARGUMENT, "--agent is required");
+    console.error("  Error: --agent <name> is required");
     process.exit(1);
   }
   const rawRunMode = parseFlag(args2, "--run-mode") ?? "daemon";
   if (rawRunMode !== "daemon" && rawRunMode !== "foreground") {
-    if (json) {
-      console.log(JSON.stringify({ success: false, error: `--run-mode must be 'daemon' or 'foreground'` }));
-    } else {
-      console.error(`  Error: --run-mode must be 'daemon' or 'foreground'`);
-    }
+    if (json) jsonError(ErrorCodes.CONFIG_INVALID, `--run-mode must be 'daemon' or 'foreground'`);
+    console.error(`  Error: --run-mode must be 'daemon' or 'foreground'`);
     process.exit(1);
   }
   const runMode = rawRunMode;
@@ -28639,7 +29583,7 @@ async function cmdSetup(args2, instanceRoot) {
   fs51.mkdirSync(instanceRoot, { recursive: true });
   fs51.writeFileSync(configPath, JSON.stringify(config, null, 2));
   if (json) {
-    console.log(JSON.stringify({ success: true, configPath }));
+    jsonSuccess({ configPath });
   } else {
     console.log(`
   \x1B[32m\u2713 Setup complete.\x1B[0m Config written to ${configPath}
@@ -28698,8 +29642,8 @@ resolvedInstanceRoot = resolveInstanceRoot({
 var noInstanceCommands = {
   "--help": async () => printHelp(),
   "-h": async () => printHelp(),
-  "--version": () => cmdVersion(),
-  "-v": () => cmdVersion(),
+  "--version": () => cmdVersion(args),
+  "-v": () => cmdVersion(args),
   "update": () => cmdUpdate(args),
   "adopt": () => cmdAdopt(args),
   "integrate": () => cmdIntegrate(args),
@@ -28725,7 +29669,8 @@ async function main() {
       const registry = new InstanceRegistry2(path64.join(getGlobal(), "instances.json"));
       await registry.load();
       const entry = registry.getByRoot(envRoot);
-      const id = entry?.id ?? "unknown";
+      const { randomUUID: randomUUID6 } = await import("crypto");
+      const id = entry?.id ?? randomUUID6();
       const ctx = createInstanceContext2({
         id,
         root: envRoot,