@openacp/cli 2026.408.4 → 2026.410.1

package/dist/index.js

@@ -245,6 +245,9 @@ var init_log = __esm({
 });
 
 // src/core/config/config-migrations.ts
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
 function applyMigrations(raw, migrationList = migrations, ctx) {
   let changed = false;
   for (const migration of migrationList) {
@@ -278,108 +281,34 @@ var init_config_migrations = __esm({
           log2.info("Removed legacy displayVerbosity key from config");
           return true;
         }
+      },
+      {
+        name: "add-instance-id",
+        apply(raw, ctx) {
+          if (raw.id) return false;
+          if (!ctx?.configDir) return false;
+          const instanceRoot = ctx.configDir;
+          try {
+            const registryPath = path2.join(os2.homedir(), ".openacp", "instances.json");
+            const data = JSON.parse(fs2.readFileSync(registryPath, "utf-8"));
+            const instances = data?.instances ?? {};
+            const entry = Object.values(instances).find(
+              (e) => e.root === instanceRoot
+            );
+            if (entry?.id) {
+              raw.id = entry.id;
+              log2.info({ instanceRoot }, "Migrated: added id to config from registry");
+              return true;
+            }
+          } catch {
+          }
+          return false;
+        }
       }
     ];
   }
 });
 
-// src/core/instance/instance-context.ts
-var instance_context_exports = {};
-__export(instance_context_exports, {
-  createInstanceContext: () => createInstanceContext,
-  generateSlug: () => generateSlug,
-  getGlobalRoot: () => getGlobalRoot,
-  resolveInstanceRoot: () => resolveInstanceRoot,
-  resolveRunningInstance: () => resolveRunningInstance
-});
-import path2 from "path";
-import fs2 from "fs";
-import os2 from "os";
-function createInstanceContext(opts) {
-  const { id, root, isGlobal } = opts;
-  return {
-    id,
-    root,
-    isGlobal,
-    paths: {
-      config: path2.join(root, "config.json"),
-      sessions: path2.join(root, "sessions.json"),
-      agents: path2.join(root, "agents.json"),
-      registryCache: path2.join(root, "registry-cache.json"),
-      plugins: path2.join(root, "plugins"),
-      pluginsData: path2.join(root, "plugins", "data"),
-      pluginRegistry: path2.join(root, "plugins.json"),
-      logs: path2.join(root, "logs"),
-      pid: path2.join(root, "openacp.pid"),
-      running: path2.join(root, "running"),
-      apiPort: path2.join(root, "api.port"),
-      apiSecret: path2.join(root, "api-secret"),
-      bin: path2.join(root, "bin"),
-      cache: path2.join(root, "cache"),
-      tunnels: path2.join(root, "tunnels.json"),
-      agentsDir: path2.join(root, "agents")
-    }
-  };
-}
-function generateSlug(name) {
-  const slug = name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-  return slug || "openacp";
-}
-function expandHome2(p) {
-  if (p.startsWith("~")) return path2.join(os2.homedir(), p.slice(1));
-  return p;
-}
-function resolveInstanceRoot(opts) {
-  const cwd = opts.cwd ?? process.cwd();
-  if (opts.dir) return path2.join(expandHome2(opts.dir), ".openacp");
-  if (opts.local) return path2.join(cwd, ".openacp");
-  if (opts.global) return path2.join(os2.homedir(), ".openacp");
-  const localRoot = path2.join(cwd, ".openacp");
-  if (fs2.existsSync(localRoot)) return localRoot;
-  if (process.env.OPENACP_INSTANCE_ROOT) return process.env.OPENACP_INSTANCE_ROOT;
-  return null;
-}
-function getGlobalRoot() {
-  return path2.join(os2.homedir(), ".openacp");
-}
-async function resolveRunningInstance(cwd) {
-  const globalRoot = getGlobalRoot();
-  let dir = path2.resolve(cwd);
-  while (true) {
-    const candidate = path2.join(dir, ".openacp");
-    if (candidate !== globalRoot && fs2.existsSync(candidate)) {
-      if (await isInstanceRunning(candidate)) return candidate;
-    }
-    const parent = path2.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  if (fs2.existsSync(globalRoot) && await isInstanceRunning(globalRoot)) return globalRoot;
-  return null;
-}
-async function isInstanceRunning(instanceRoot) {
-  const portFile = path2.join(instanceRoot, "api.port");
-  try {
-    const content = fs2.readFileSync(portFile, "utf-8").trim();
-    const port = parseInt(content, 10);
-    if (isNaN(port)) return false;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 2e3);
-    const res = await fetch(`http://127.0.0.1:${port}/api/v1/system/health`, {
-      signal: controller.signal
-    });
-    clearTimeout(timeout);
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-var init_instance_context = __esm({
-  "src/core/instance/instance-context.ts"() {
-    "use strict";
-  }
-});
-
 // src/core/config/config-registry.ts
 var config_registry_exports = {};
 __export(config_registry_exports, {
@@ -392,24 +321,22 @@ __export(config_registry_exports, {
   resolveOptions: () => resolveOptions,
   setFieldValueAsync: () => setFieldValueAsync
 });
-import * as fs3 from "fs";
-import * as path3 from "path";
-function getFieldDef(path34) {
-  return CONFIG_REGISTRY.find((f) => f.path === path34);
+function getFieldDef(path35) {
+  return CONFIG_REGISTRY.find((f) => f.path === path35);
 }
 function getSafeFields() {
   return CONFIG_REGISTRY.filter((f) => f.scope === "safe");
 }
-function isHotReloadable(path34) {
-  const def = getFieldDef(path34);
+function isHotReloadable(path35) {
+  const def = getFieldDef(path35);
   return def?.hotReload ?? false;
 }
 function resolveOptions(def, config) {
   if (!def.options) return void 0;
   return typeof def.options === "function" ? def.options(config) : def.options;
 }
-function getConfigValue(config, path34) {
-  const parts = path34.split(".");
+function getConfigValue(config, path35) {
+  const parts = path35.split(".");
   let current = config;
   for (const part of parts) {
     if (current && typeof current === "object" && part in current) {
@@ -454,7 +381,6 @@ var CONFIG_REGISTRY, ConfigValidationError;
 var init_config_registry = __esm({
   "src/core/config/config-registry.ts"() {
     "use strict";
-    init_instance_context();
     CONFIG_REGISTRY = [
       {
         path: "defaultAgent",
@@ -462,17 +388,8 @@ var init_config_registry = __esm({
         group: "agent",
         type: "select",
         options: (config) => {
-          const configAgents = Object.keys(config.agents ?? {});
-          if (configAgents.length > 0) return configAgents;
-          try {
-            const agentsPath = path3.join(getGlobalRoot(), "agents.json");
-            if (fs3.existsSync(agentsPath)) {
-              const data = JSON.parse(fs3.readFileSync(agentsPath, "utf-8"));
-              return Object.keys(data.installed ?? {});
-            }
-          } catch {
-          }
-          return [];
+          const current = config.defaultAgent;
+          return current ? [current] : [];
         },
         scope: "safe",
         hotReload: true
@@ -486,14 +403,6 @@ var init_config_registry = __esm({
         scope: "safe",
         hotReload: true
       },
-      {
-        path: "workspace.baseDir",
-        displayName: "Workspace Directory",
-        group: "workspace",
-        type: "string",
-        scope: "safe",
-        hotReload: true
-      },
       {
         path: "sessionStore.ttlDays",
         displayName: "Session Store TTL (days)",
@@ -522,14 +431,14 @@ var init_config_registry = __esm({
 
 // src/core/config/config.ts
 import { z } from "zod";
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 import * as os3 from "os";
 import { randomBytes } from "crypto";
 import { EventEmitter } from "events";
-function expandHome3(p) {
+function expandHome2(p) {
   if (p.startsWith("~")) {
-    return path4.join(os3.homedir(), p.slice(1));
+    return path3.join(os3.homedir(), p.slice(1));
   }
   return p;
 }
@@ -548,10 +457,11 @@ var init_config = __esm({
       sessionLogRetentionDays: z.number().default(30)
     }).default({});
     ConfigSchema = z.object({
+      id: z.string().optional(),
+      // instance UUID, written once at creation time
       instanceName: z.string().optional(),
       defaultAgent: z.string(),
       workspace: z.object({
-        baseDir: z.string().default("~/openacp-workspace"),
         allowExternalWorkspaces: z.boolean().default(true),
         security: z.object({
           allowedPaths: z.array(z.string()).default([]),
@@ -578,7 +488,6 @@ var init_config = __esm({
     });
     DEFAULT_CONFIG = {
       defaultAgent: "claude",
-      workspace: { baseDir: "~/openacp-workspace" },
       sessionStore: { ttlDays: 30 }
     };
     ConfigManager = class extends EventEmitter {
@@ -586,13 +495,13 @@ var init_config = __esm({
       configPath;
       constructor(configPath) {
         super();
-        this.configPath = process.env.OPENACP_CONFIG_PATH || configPath || expandHome3("~/.openacp/config.json");
+        this.configPath = process.env.OPENACP_CONFIG_PATH || configPath || expandHome2("~/.openacp/config.json");
       }
       async load() {
-        const dir = path4.dirname(this.configPath);
-        fs4.mkdirSync(dir, { recursive: true });
-        if (!fs4.existsSync(this.configPath)) {
-          fs4.writeFileSync(
+        const dir = path3.dirname(this.configPath);
+        fs3.mkdirSync(dir, { recursive: true });
+        if (!fs3.existsSync(this.configPath)) {
+          fs3.writeFileSync(
             this.configPath,
             JSON.stringify(DEFAULT_CONFIG, null, 2)
           );
@@ -602,10 +511,10 @@ var init_config = __esm({
           );
           process.exit(1);
         }
-        const raw = JSON.parse(fs4.readFileSync(this.configPath, "utf-8"));
-        const { changed: configUpdated } = applyMigrations(raw, void 0, { configDir: path4.dirname(this.configPath) });
+        const raw = JSON.parse(fs3.readFileSync(this.configPath, "utf-8"));
+        const { changed: configUpdated } = applyMigrations(raw, void 0, { configDir: path3.dirname(this.configPath) });
         if (configUpdated) {
-          fs4.writeFileSync(this.configPath, JSON.stringify(raw, null, 2));
+          fs3.writeFileSync(this.configPath, JSON.stringify(raw, null, 2));
         }
         this.applyEnvOverrides(raw);
         const result = ConfigSchema.safeParse(raw);
@@ -626,7 +535,7 @@ var init_config = __esm({
       }
       async save(updates, changePath) {
         const oldConfig = this.config ? structuredClone(this.config) : void 0;
-        const raw = JSON.parse(fs4.readFileSync(this.configPath, "utf-8"));
+        const raw = JSON.parse(fs3.readFileSync(this.configPath, "utf-8"));
         this.deepMerge(raw, updates);
         const result = ConfigSchema.safeParse(raw);
         if (!result.success) {
@@ -634,8 +543,8 @@ var init_config = __esm({
           return;
         }
         const tmpPath = this.configPath + `.tmp.${randomBytes(4).toString("hex")}`;
-        fs4.writeFileSync(tmpPath, JSON.stringify(raw, null, 2), "utf-8");
-        fs4.renameSync(tmpPath, this.configPath);
+        fs3.writeFileSync(tmpPath, JSON.stringify(raw, null, 2), "utf-8");
+        fs3.renameSync(tmpPath, this.configPath);
         this.config = result.data;
         if (changePath) {
           const { getConfigValue: getConfigValue2 } = await Promise.resolve().then(() => (init_config_registry(), config_registry_exports));
@@ -665,54 +574,49 @@ var init_config = __esm({
         await this.save(updates, dotPath);
       }
       resolveWorkspace(input2) {
+        const workspaceBase = path3.dirname(path3.dirname(this.configPath));
         if (!input2) {
-          const resolved2 = expandHome3(this.config.workspace.baseDir);
-          fs4.mkdirSync(resolved2, { recursive: true });
-          return resolved2;
-        }
-        if (input2.startsWith("/") || input2.startsWith("~")) {
-          const resolved2 = expandHome3(input2);
-          const base = expandHome3(this.config.workspace.baseDir);
-          const isInternal = resolved2 === base || resolved2.startsWith(base + path4.sep);
+          fs3.mkdirSync(workspaceBase, { recursive: true });
+          return workspaceBase;
+        }
+        const expanded = input2.startsWith("~") ? expandHome2(input2) : input2;
+        if (path3.isAbsolute(expanded)) {
+          const resolved = path3.resolve(expanded);
+          const base = path3.resolve(workspaceBase);
+          const isInternal = resolved === base || resolved.startsWith(base + path3.sep);
           if (!isInternal) {
             if (!this.config.workspace.allowExternalWorkspaces) {
               throw new Error(
-                `Workspace path "${input2}" is outside base directory "${this.config.workspace.baseDir}". Set allowExternalWorkspaces: true to allow this.`
+                `Workspace path "${input2}" is outside base directory "${workspaceBase}". Set allowExternalWorkspaces: true to allow this.`
               );
             }
-            if (!fs4.existsSync(resolved2)) {
-              throw new Error(
-                `Workspace path "${input2}" does not exist.`
-              );
+            if (!fs3.existsSync(resolved)) {
+              throw new Error(`Workspace path "${resolved}" does not exist.`);
             }
-            return resolved2;
+            return resolved;
           }
-          fs4.mkdirSync(resolved2, { recursive: true });
-          return resolved2;
+          fs3.mkdirSync(resolved, { recursive: true });
+          return resolved;
         }
-        const name = input2.replace(/[^a-zA-Z0-9_-]/g, "");
-        if (name !== input2) {
+        if (!/^[a-zA-Z0-9_-]+$/.test(input2)) {
           throw new Error(
             `Invalid workspace name: "${input2}". Only alphanumeric characters, hyphens, and underscores are allowed.`
           );
         }
-        const resolved = path4.join(
-          expandHome3(this.config.workspace.baseDir),
-          name.toLowerCase()
-        );
-        fs4.mkdirSync(resolved, { recursive: true });
-        return resolved;
+        const namedPath = path3.join(workspaceBase, input2.toLowerCase());
+        fs3.mkdirSync(namedPath, { recursive: true });
+        return namedPath;
       }
       async exists() {
-        return fs4.existsSync(this.configPath);
+        return fs3.existsSync(this.configPath);
       }
       getConfigPath() {
         return this.configPath;
       }
       async writeNew(config) {
-        const dir = path4.dirname(this.configPath);
-        fs4.mkdirSync(dir, { recursive: true });
-        fs4.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+        const dir = path3.dirname(this.configPath);
+        fs3.mkdirSync(dir, { recursive: true });
+        fs3.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
       }
       async applyEnvToPluginSettings(settingsManager) {
         const pluginOverrides = [
@@ -795,9 +699,9 @@ var read_text_file_exports = {};
 __export(read_text_file_exports, {
   readTextFileWithRange: () => readTextFileWithRange
 });
-import fs6 from "fs";
+import fs5 from "fs";
 async function readTextFileWithRange(filePath, options) {
-  const content = await fs6.promises.readFile(filePath, "utf-8");
+  const content = await fs5.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);
@@ -954,8 +858,8 @@ __export(agent_dependencies_exports, {
   listAgentsWithIntegration: () => listAgentsWithIntegration
 });
 import { execFileSync as execFileSync2 } from "child_process";
-import * as fs11 from "fs";
-import * as path10 from "path";
+import * as fs10 from "fs";
+import * as path9 from "path";
 function getAgentSetup(registryId) {
   return AGENT_SETUP[registryId];
 }
@@ -979,9 +883,9 @@ function commandExists(cmd) {
   }
   let dir = process.cwd();
   while (true) {
-    const binPath = path10.join(dir, "node_modules", ".bin", cmd);
-    if (fs11.existsSync(binPath)) return true;
-    const parent = path10.dirname(dir);
+    const binPath = path9.join(dir, "node_modules", ".bin", cmd);
+    if (fs10.existsSync(binPath)) return true;
+    const parent = path9.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -1254,9 +1158,9 @@ var init_agent_registry = __esm({
 });
 
 // src/core/agents/agent-installer.ts
-import * as fs13 from "fs";
-import * as path12 from "path";
-import * as os5 from "os";
+import * as fs11 from "fs";
+import * as path10 from "path";
+import * as os4 from "os";
 import crypto from "crypto";
 function validateArchiveContents(entries, destDir) {
   for (const entry of entries) {
@@ -1270,9 +1174,9 @@ function validateArchiveContents(entries, destDir) {
   }
 }
 function validateUninstallPath(binaryPath, agentsDir) {
-  const realPath = path12.resolve(binaryPath);
-  const realAgentsDir = path12.resolve(agentsDir);
-  if (!realPath.startsWith(realAgentsDir + path12.sep) && realPath !== realAgentsDir) {
+  const realPath = path10.resolve(binaryPath);
+  const realAgentsDir = path10.resolve(agentsDir);
+  if (!realPath.startsWith(realAgentsDir + path10.sep) && realPath !== realAgentsDir) {
     throw new Error(`Refusing to delete path outside agents directory: ${realPath}`);
   }
 }
@@ -1326,7 +1230,7 @@ function buildInstalledAgent(registryId, name, version, dist, binaryPath) {
       binaryPath: null
     };
   }
-  const absCmd = path12.resolve(binaryPath, dist.cmd);
+  const absCmd = path10.resolve(binaryPath, dist.cmd);
   return {
     registryId,
     name,
@@ -1392,10 +1296,10 @@ Install it with: pip install uv`;
   return { ok: true, agentKey, setupSteps: setupSteps.length > 0 ? setupSteps : void 0 };
 }
 async function downloadAndExtract(agentId, archiveUrl, progress, agentsDir) {
-  const destDir = path12.join(agentsDir ?? DEFAULT_AGENTS_DIR, agentId);
-  fs13.mkdirSync(destDir, { recursive: true });
+  const destDir = path10.join(agentsDir ?? DEFAULT_AGENTS_DIR, agentId);
+  fs11.mkdirSync(destDir, { recursive: true });
   await progress?.onStep("Downloading...");
-  log11.info({ agentId, url: archiveUrl }, "Downloading agent binary");
+  log10.info({ agentId, url: archiveUrl }, "Downloading agent binary");
   const response = await fetch(archiveUrl);
   if (!response.ok) {
     throw new Error(`Download failed: ${response.status} ${response.statusText}`);
@@ -1434,70 +1338,70 @@ async function readResponseWithProgress(response, contentLength, progress) {
   return Buffer.concat(chunks);
 }
 function validateExtractedPaths(destDir) {
-  const realDest = fs13.realpathSync(destDir);
-  const entries = fs13.readdirSync(destDir, { recursive: true, withFileTypes: true });
+  const realDest = fs11.realpathSync(destDir);
+  const entries = fs11.readdirSync(destDir, { recursive: true, withFileTypes: true });
   for (const entry of entries) {
     const dirent = entry;
     const parentPath = dirent.parentPath ?? dirent.path ?? destDir;
-    const fullPath = path12.join(parentPath, entry.name);
+    const fullPath = path10.join(parentPath, entry.name);
     let realPath;
     try {
-      realPath = fs13.realpathSync(fullPath);
+      realPath = fs11.realpathSync(fullPath);
     } catch {
-      const linkTarget = fs13.readlinkSync(fullPath);
-      realPath = path12.resolve(path12.dirname(fullPath), linkTarget);
+      const linkTarget = fs11.readlinkSync(fullPath);
+      realPath = path10.resolve(path10.dirname(fullPath), linkTarget);
     }
-    if (!realPath.startsWith(realDest + path12.sep) && realPath !== realDest) {
-      fs13.rmSync(destDir, { recursive: true, force: true });
+    if (!realPath.startsWith(realDest + path10.sep) && realPath !== realDest) {
+      fs11.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 = path12.join(destDir, "_archive.tar.gz");
-  fs13.writeFileSync(tmpFile, buffer);
+  const tmpFile = path10.join(destDir, "_archive.tar.gz");
+  fs11.writeFileSync(tmpFile, buffer);
   try {
     const listing = execFileSync8("tar", ["tf", tmpFile], { stdio: "pipe" }).toString().trim().split("\n").filter(Boolean);
     validateArchiveContents(listing, destDir);
     execFileSync8("tar", ["xzf", tmpFile, "-C", destDir], { stdio: "pipe" });
   } finally {
-    fs13.unlinkSync(tmpFile);
+    fs11.unlinkSync(tmpFile);
   }
   validateExtractedPaths(destDir);
 }
 async function extractZip(buffer, destDir) {
   const { execFileSync: execFileSync8 } = await import("child_process");
-  const tmpFile = path12.join(destDir, "_archive.zip");
-  fs13.writeFileSync(tmpFile, buffer);
+  const tmpFile = path10.join(destDir, "_archive.zip");
+  fs11.writeFileSync(tmpFile, buffer);
   try {
     const listing = execFileSync8("unzip", ["-l", tmpFile], { stdio: "pipe" }).toString().trim().split("\n").filter(Boolean);
     const entries = listing.slice(3, -2).map((line) => line.trim().split(/\s+/).slice(3).join(" ")).filter(Boolean);
     validateArchiveContents(entries, destDir);
     execFileSync8("unzip", ["-o", tmpFile, "-d", destDir], { stdio: "pipe" });
   } finally {
-    fs13.unlinkSync(tmpFile);
+    fs11.unlinkSync(tmpFile);
   }
   validateExtractedPaths(destDir);
 }
 async function uninstallAgent(agentKey, store, agentsDir) {
   const agent = store.getAgent(agentKey);
   if (!agent) return;
-  if (agent.binaryPath && fs13.existsSync(agent.binaryPath)) {
+  if (agent.binaryPath && fs11.existsSync(agent.binaryPath)) {
     validateUninstallPath(agent.binaryPath, agentsDir ?? DEFAULT_AGENTS_DIR);
-    fs13.rmSync(agent.binaryPath, { recursive: true, force: true });
-    log11.info({ agentKey, binaryPath: agent.binaryPath }, "Deleted agent binary");
+    fs11.rmSync(agent.binaryPath, { recursive: true, force: true });
+    log10.info({ agentKey, binaryPath: agent.binaryPath }, "Deleted agent binary");
   }
   store.removeAgent(agentKey);
 }
-var log11, DEFAULT_AGENTS_DIR, MAX_DOWNLOAD_SIZE, validateTarContents, ARCH_MAP, PLATFORM_MAP;
+var log10, DEFAULT_AGENTS_DIR, MAX_DOWNLOAD_SIZE, validateTarContents, ARCH_MAP, PLATFORM_MAP;
 var init_agent_installer = __esm({
   "src/core/agents/agent-installer.ts"() {
     "use strict";
     init_log();
     init_agent_dependencies();
-    log11 = createChildLogger({ module: "agent-installer" });
-    DEFAULT_AGENTS_DIR = path12.join(os5.homedir(), ".openacp", "agents");
+    log10 = createChildLogger({ module: "agent-installer" });
+    DEFAULT_AGENTS_DIR = path10.join(os4.homedir(), ".openacp", "agents");
     MAX_DOWNLOAD_SIZE = 500 * 1024 * 1024;
     validateTarContents = validateArchiveContents;
     ARCH_MAP = {
@@ -1513,7 +1417,7 @@ var init_agent_installer = __esm({
 });
 
 // src/core/doctor/checks/config.ts
-import * as fs16 from "fs";
+import * as fs15 from "fs";
 var configCheck;
 var init_config2 = __esm({
   "src/core/doctor/checks/config.ts"() {
@@ -1525,14 +1429,14 @@ var init_config2 = __esm({
       order: 1,
       async run(ctx) {
         const results = [];
-        if (!fs16.existsSync(ctx.configPath)) {
+        if (!fs15.existsSync(ctx.configPath)) {
           results.push({ status: "fail", message: "Config file not found" });
           return results;
         }
         results.push({ status: "pass", message: "Config file exists" });
         let raw;
         try {
-          raw = JSON.parse(fs16.readFileSync(ctx.configPath, "utf-8"));
+          raw = JSON.parse(fs15.readFileSync(ctx.configPath, "utf-8"));
         } catch (err) {
           results.push({
             status: "fail",
@@ -1551,7 +1455,7 @@ var init_config2 = __esm({
             fixRisk: "safe",
             fix: async () => {
               applyMigrations(raw);
-              fs16.writeFileSync(ctx.configPath, JSON.stringify(raw, null, 2));
+              fs15.writeFileSync(ctx.configPath, JSON.stringify(raw, null, 2));
               return { success: true, message: "applied migrations" };
             }
           });
@@ -1575,8 +1479,8 @@ var init_config2 = __esm({
 
 // src/core/doctor/checks/agents.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs17 from "fs";
-import * as path17 from "path";
+import * as fs16 from "fs";
+import * as path15 from "path";
 function commandExists2(cmd) {
   try {
     execFileSync3("which", [cmd], { stdio: "pipe" });
@@ -1585,9 +1489,9 @@ function commandExists2(cmd) {
   }
   let dir = process.cwd();
   while (true) {
-    const binPath = path17.join(dir, "node_modules", ".bin", cmd);
-    if (fs17.existsSync(binPath)) return true;
-    const parent = path17.dirname(dir);
+    const binPath = path15.join(dir, "node_modules", ".bin", cmd);
+    if (fs16.existsSync(binPath)) return true;
+    const parent = path15.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -1609,9 +1513,9 @@ var init_agents = __esm({
         const defaultAgent = ctx.config.defaultAgent;
         let agents = {};
         try {
-          const agentsPath = path17.join(ctx.dataDir, "agents.json");
-          if (fs17.existsSync(agentsPath)) {
-            const data = JSON.parse(fs17.readFileSync(agentsPath, "utf-8"));
+          const agentsPath = path15.join(ctx.dataDir, "agents.json");
+          if (fs16.existsSync(agentsPath)) {
+            const data = JSON.parse(fs16.readFileSync(agentsPath, "utf-8"));
             agents = data.installed ?? {};
           }
         } catch {
@@ -1649,8 +1553,8 @@ var settings_manager_exports = {};
 __export(settings_manager_exports, {
   SettingsManager: () => SettingsManager
 });
-import fs18 from "fs";
-import path18 from "path";
+import fs17 from "fs";
+import path16 from "path";
 var SettingsManager, SettingsAPIImpl;
 var init_settings_manager = __esm({
   "src/core/plugin/settings-manager.ts"() {
@@ -1669,7 +1573,7 @@ var init_settings_manager = __esm({
       async loadSettings(pluginName) {
         const settingsPath = this.getSettingsPath(pluginName);
         try {
-          const content = fs18.readFileSync(settingsPath, "utf-8");
+          const content = fs17.readFileSync(settingsPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return {};
@@ -1687,7 +1591,7 @@ var init_settings_manager = __esm({
         };
       }
       getSettingsPath(pluginName) {
-        return path18.join(this.basePath, pluginName, "settings.json");
+        return path16.join(this.basePath, pluginName, "settings.json");
       }
       async getPluginSettings(pluginName) {
         return this.loadSettings(pluginName);
@@ -1706,7 +1610,7 @@ var init_settings_manager = __esm({
       readFile() {
         if (this.cache !== null) return this.cache;
         try {
-          const content = fs18.readFileSync(this.settingsPath, "utf-8");
+          const content = fs17.readFileSync(this.settingsPath, "utf-8");
           this.cache = JSON.parse(content);
           return this.cache;
         } catch {
@@ -1715,9 +1619,9 @@ var init_settings_manager = __esm({
         }
       }
       writeFile(data) {
-        const dir = path18.dirname(this.settingsPath);
-        fs18.mkdirSync(dir, { recursive: true });
-        fs18.writeFileSync(this.settingsPath, JSON.stringify(data, null, 2));
+        const dir = path16.dirname(this.settingsPath);
+        fs17.mkdirSync(dir, { recursive: true });
+        fs17.writeFileSync(this.settingsPath, JSON.stringify(data, null, 2));
         this.cache = data;
       }
       async get(key) {
@@ -1752,7 +1656,7 @@ var init_settings_manager = __esm({
 });
 
 // src/core/doctor/checks/telegram.ts
-import * as path19 from "path";
+import * as path17 from "path";
 var BOT_TOKEN_REGEX, telegramCheck;
 var init_telegram = __esm({
   "src/core/doctor/checks/telegram.ts"() {
@@ -1768,7 +1672,7 @@ var init_telegram = __esm({
           return results;
         }
         const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
-        const sm = new SettingsManager2(path19.join(ctx.pluginsDir, "data"));
+        const sm = new SettingsManager2(path17.join(ctx.pluginsDir, "data"));
         const ps = await sm.loadSettings("@openacp/telegram");
         const botToken = ps.botToken;
         const chatId = ps.chatId;
@@ -1851,7 +1755,7 @@ var init_telegram = __esm({
 });
 
 // src/core/doctor/checks/storage.ts
-import * as fs19 from "fs";
+import * as fs18 from "fs";
 var storageCheck;
 var init_storage = __esm({
   "src/core/doctor/checks/storage.ts"() {
@@ -1861,28 +1765,28 @@ var init_storage = __esm({
       order: 4,
       async run(ctx) {
         const results = [];
-        if (!fs19.existsSync(ctx.dataDir)) {
+        if (!fs18.existsSync(ctx.dataDir)) {
           results.push({
             status: "fail",
             message: "Data directory ~/.openacp does not exist",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs19.mkdirSync(ctx.dataDir, { recursive: true });
+              fs18.mkdirSync(ctx.dataDir, { recursive: true });
               return { success: true, message: "created directory" };
             }
           });
         } else {
           try {
-            fs19.accessSync(ctx.dataDir, fs19.constants.W_OK);
+            fs18.accessSync(ctx.dataDir, fs18.constants.W_OK);
             results.push({ status: "pass", message: "Data directory exists and writable" });
           } catch {
             results.push({ status: "fail", message: "Data directory not writable" });
           }
         }
-        if (fs19.existsSync(ctx.sessionsPath)) {
+        if (fs18.existsSync(ctx.sessionsPath)) {
           try {
-            const content = fs19.readFileSync(ctx.sessionsPath, "utf-8");
+            const content = fs18.readFileSync(ctx.sessionsPath, "utf-8");
             const data = JSON.parse(content);
             if (typeof data === "object" && data !== null && "sessions" in data) {
               results.push({ status: "pass", message: "Sessions file valid" });
@@ -1893,7 +1797,7 @@ var init_storage = __esm({
                 fixable: true,
                 fixRisk: "risky",
                 fix: async () => {
-                  fs19.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
+                  fs18.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
                   return { success: true, message: "reset sessions file" };
                 }
               });
@@ -1905,7 +1809,7 @@ var init_storage = __esm({
               fixable: true,
               fixRisk: "risky",
               fix: async () => {
-                fs19.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
+                fs18.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
                 return { success: true, message: "reset sessions file" };
               }
             });
@@ -1913,20 +1817,20 @@ var init_storage = __esm({
         } else {
           results.push({ status: "pass", message: "Sessions file not present yet (created on first session)" });
         }
-        if (!fs19.existsSync(ctx.logsDir)) {
+        if (!fs18.existsSync(ctx.logsDir)) {
           results.push({
             status: "warn",
             message: "Log directory does not exist",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs19.mkdirSync(ctx.logsDir, { recursive: true });
+              fs18.mkdirSync(ctx.logsDir, { recursive: true });
               return { success: true, message: "created log directory" };
             }
           });
         } else {
           try {
-            fs19.accessSync(ctx.logsDir, fs19.constants.W_OK);
+            fs18.accessSync(ctx.logsDir, fs18.constants.W_OK);
             results.push({ status: "pass", message: "Log directory exists and writable" });
           } catch {
             results.push({ status: "fail", message: "Log directory not writable" });
@@ -1939,39 +1843,35 @@ var init_storage = __esm({
 });
 
 // src/core/doctor/checks/workspace.ts
-import * as fs20 from "fs";
+import * as fs19 from "fs";
+import * as path18 from "path";
 var workspaceCheck;
 var init_workspace = __esm({
   "src/core/doctor/checks/workspace.ts"() {
     "use strict";
-    init_config();
     workspaceCheck = {
       name: "Workspace",
       order: 5,
       async run(ctx) {
         const results = [];
-        if (!ctx.config) {
-          results.push({ status: "fail", message: "Cannot check workspace \u2014 config not loaded" });
-          return results;
-        }
-        const baseDir = expandHome3(ctx.config.workspace.baseDir);
-        if (!fs20.existsSync(baseDir)) {
+        const workspace = path18.dirname(ctx.dataDir);
+        if (!fs19.existsSync(workspace)) {
           results.push({
             status: "warn",
-            message: `Workspace directory does not exist: ${baseDir}`,
+            message: `Workspace directory does not exist: ${workspace}`,
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs20.mkdirSync(baseDir, { recursive: true });
+              fs19.mkdirSync(workspace, { recursive: true });
               return { success: true, message: "created directory" };
             }
           });
         } else {
           try {
-            fs20.accessSync(baseDir, fs20.constants.W_OK);
-            results.push({ status: "pass", message: `Workspace directory exists: ${baseDir}` });
+            fs19.accessSync(workspace, fs19.constants.W_OK);
+            results.push({ status: "pass", message: `Workspace directory exists: ${workspace}` });
           } catch {
-            results.push({ status: "fail", message: `Workspace directory not writable: ${baseDir}` });
+            results.push({ status: "fail", message: `Workspace directory not writable: ${workspace}` });
           }
         }
         return results;
@@ -1981,8 +1881,8 @@ var init_workspace = __esm({
 });
 
 // src/core/doctor/checks/plugins.ts
-import * as fs21 from "fs";
-import * as path20 from "path";
+import * as fs20 from "fs";
+import * as path19 from "path";
 var pluginsCheck;
 var init_plugins = __esm({
   "src/core/doctor/checks/plugins.ts"() {
@@ -1992,16 +1892,16 @@ var init_plugins = __esm({
       order: 6,
       async run(ctx) {
         const results = [];
-        if (!fs21.existsSync(ctx.pluginsDir)) {
+        if (!fs20.existsSync(ctx.pluginsDir)) {
           results.push({
             status: "warn",
             message: "Plugins directory does not exist",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs21.mkdirSync(ctx.pluginsDir, { recursive: true });
-              fs21.writeFileSync(
-                path20.join(ctx.pluginsDir, "package.json"),
+              fs20.mkdirSync(ctx.pluginsDir, { recursive: true });
+              fs20.writeFileSync(
+                path19.join(ctx.pluginsDir, "package.json"),
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
               return { success: true, message: "initialized plugins directory" };
@@ -2010,15 +1910,15 @@ var init_plugins = __esm({
           return results;
         }
         results.push({ status: "pass", message: "Plugins directory exists" });
-        const pkgPath = path20.join(ctx.pluginsDir, "package.json");
-        if (!fs21.existsSync(pkgPath)) {
+        const pkgPath = path19.join(ctx.pluginsDir, "package.json");
+        if (!fs20.existsSync(pkgPath)) {
           results.push({
             status: "warn",
             message: "Plugins package.json missing",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs21.writeFileSync(
+              fs20.writeFileSync(
                 pkgPath,
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
@@ -2028,7 +1928,7 @@ var init_plugins = __esm({
           return results;
         }
         try {
-          const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
+          const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf-8"));
           const deps = pkg.dependencies || {};
           const count = Object.keys(deps).length;
           results.push({ status: "pass", message: `Plugins package.json valid (${count} plugins)` });
@@ -2039,7 +1939,7 @@ var init_plugins = __esm({
             fixable: true,
             fixRisk: "risky",
             fix: async () => {
-              fs21.writeFileSync(
+              fs20.writeFileSync(
                 pkgPath,
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
@@ -2054,7 +1954,7 @@ var init_plugins = __esm({
 });
 
 // src/core/doctor/checks/daemon.ts
-import * as fs22 from "fs";
+import * as fs21 from "fs";
 import * as net from "net";
 function isProcessAlive(pid) {
   try {
@@ -2084,8 +1984,8 @@ var init_daemon = __esm({
       order: 7,
       async run(ctx) {
         const results = [];
-        if (fs22.existsSync(ctx.pidPath)) {
-          const content = fs22.readFileSync(ctx.pidPath, "utf-8").trim();
+        if (fs21.existsSync(ctx.pidPath)) {
+          const content = fs21.readFileSync(ctx.pidPath, "utf-8").trim();
           const pid = parseInt(content, 10);
           if (isNaN(pid)) {
             results.push({
@@ -2094,7 +1994,7 @@ var init_daemon = __esm({
               fixable: true,
               fixRisk: "safe",
               fix: async () => {
-                fs22.unlinkSync(ctx.pidPath);
+                fs21.unlinkSync(ctx.pidPath);
                 return { success: true, message: "removed invalid PID file" };
               }
             });
@@ -2105,7 +2005,7 @@ var init_daemon = __esm({
               fixable: true,
               fixRisk: "safe",
               fix: async () => {
-                fs22.unlinkSync(ctx.pidPath);
+                fs21.unlinkSync(ctx.pidPath);
                 return { success: true, message: "removed stale PID file" };
               }
             });
@@ -2113,8 +2013,8 @@ var init_daemon = __esm({
             results.push({ status: "pass", message: `Daemon running (PID ${pid})` });
           }
         }
-        if (fs22.existsSync(ctx.portFilePath)) {
-          const content = fs22.readFileSync(ctx.portFilePath, "utf-8").trim();
+        if (fs21.existsSync(ctx.portFilePath)) {
+          const content = fs21.readFileSync(ctx.portFilePath, "utf-8").trim();
           const port = parseInt(content, 10);
           if (isNaN(port)) {
             results.push({
@@ -2123,7 +2023,7 @@ var init_daemon = __esm({
               fixable: true,
               fixRisk: "safe",
               fix: async () => {
-                fs22.unlinkSync(ctx.portFilePath);
+                fs21.unlinkSync(ctx.portFilePath);
                 return { success: true, message: "removed invalid port file" };
               }
             });
@@ -2135,8 +2035,8 @@ var init_daemon = __esm({
           const apiPort = 21420;
           const inUse = await checkPortInUse(apiPort);
           if (inUse) {
-            if (fs22.existsSync(ctx.pidPath)) {
-              const pid = parseInt(fs22.readFileSync(ctx.pidPath, "utf-8").trim(), 10);
+            if (fs21.existsSync(ctx.pidPath)) {
+              const pid = parseInt(fs21.readFileSync(ctx.pidPath, "utf-8").trim(), 10);
               if (!isNaN(pid) && isProcessAlive(pid)) {
                 results.push({ status: "pass", message: `API port ${apiPort} in use by OpenACP daemon` });
               } else {
@@ -2156,17 +2056,17 @@ var init_daemon = __esm({
 });
 
 // src/core/utils/install-binary.ts
-import fs23 from "fs";
-import path21 from "path";
+import fs22 from "fs";
+import path20 from "path";
 import https from "https";
-import os9 from "os";
+import os5 from "os";
 import { execFileSync as execFileSync4 } from "child_process";
 function downloadFile(url, dest, maxRedirects = 10) {
   return new Promise((resolve7, reject) => {
-    const file = fs23.createWriteStream(dest);
+    const file = fs22.createWriteStream(dest);
     const cleanup = () => {
       try {
-        if (fs23.existsSync(dest)) fs23.unlinkSync(dest);
+        if (fs22.existsSync(dest)) fs22.unlinkSync(dest);
       } catch {
       }
     };
@@ -2221,8 +2121,8 @@ function downloadFile(url, dest, maxRedirects = 10) {
   });
 }
 function getDownloadUrl(spec) {
-  const platform2 = os9.platform();
-  const arch = os9.arch();
+  const platform2 = os5.platform();
+  const arch = os5.arch();
   const mapping = spec.platforms[platform2];
   if (!mapping) throw new Error(`${spec.name}: unsupported platform ${platform2}`);
   const binary = mapping[arch];
@@ -2232,36 +2132,36 @@ function getDownloadUrl(spec) {
 async function ensureBinary(spec, binDir) {
   const resolvedBinDir = binDir ?? DEFAULT_BIN_DIR;
   const binName = IS_WINDOWS ? `${spec.name}.exe` : spec.name;
-  const binPath = path21.join(resolvedBinDir, binName);
+  const binPath = path20.join(resolvedBinDir, binName);
   if (commandExists(spec.name)) {
     log17.debug({ name: spec.name }, "Found in PATH");
     return spec.name;
   }
-  if (fs23.existsSync(binPath)) {
-    if (!IS_WINDOWS) fs23.chmodSync(binPath, "755");
+  if (fs22.existsSync(binPath)) {
+    if (!IS_WINDOWS) fs22.chmodSync(binPath, "755");
     log17.debug({ name: spec.name, path: binPath }, "Found in ~/.openacp/bin");
     return binPath;
   }
   log17.info({ name: spec.name }, "Not found, downloading from GitHub...");
-  fs23.mkdirSync(resolvedBinDir, { recursive: true });
+  fs22.mkdirSync(resolvedBinDir, { recursive: true });
   const url = getDownloadUrl(spec);
   const isArchive = spec.isArchive?.(url) ?? false;
-  const downloadDest = isArchive ? path21.join(resolvedBinDir, `${spec.name}.tgz`) : binPath;
+  const downloadDest = isArchive ? path20.join(resolvedBinDir, `${spec.name}.tgz`) : binPath;
   await downloadFile(url, downloadDest);
   if (isArchive) {
     const listing = execFileSync4("tar", ["-tf", downloadDest], { stdio: "pipe" }).toString().trim().split("\n").filter(Boolean);
     validateTarContents(listing, resolvedBinDir);
     execFileSync4("tar", ["-xzf", downloadDest, "-C", resolvedBinDir], { stdio: "pipe" });
     try {
-      fs23.unlinkSync(downloadDest);
+      fs22.unlinkSync(downloadDest);
     } catch {
     }
   }
-  if (!fs23.existsSync(binPath)) {
+  if (!fs22.existsSync(binPath)) {
     throw new Error(`${spec.name}: binary not found at ${binPath} after download/extraction. The archive structure may have changed.`);
   }
   if (!IS_WINDOWS) {
-    fs23.chmodSync(binPath, "755");
+    fs22.chmodSync(binPath, "755");
   }
   log17.info({ name: spec.name, path: binPath }, "Installed successfully");
   return binPath;
@@ -2274,8 +2174,8 @@ var init_install_binary = __esm({
     init_agent_dependencies();
     init_agent_installer();
     log17 = createChildLogger({ module: "binary-installer" });
-    DEFAULT_BIN_DIR = path21.join(os9.homedir(), ".openacp", "bin");
-    IS_WINDOWS = os9.platform() === "win32";
+    DEFAULT_BIN_DIR = path20.join(os5.homedir(), ".openacp", "bin");
+    IS_WINDOWS = os5.platform() === "win32";
   }
 });
 
@@ -2315,9 +2215,9 @@ var init_install_cloudflared = __esm({
 });
 
 // src/core/doctor/checks/tunnel.ts
-import * as fs24 from "fs";
-import * as path22 from "path";
-import * as os10 from "os";
+import * as fs23 from "fs";
+import * as path21 from "path";
+import * as os6 from "os";
 import { execFileSync as execFileSync5 } from "child_process";
 var tunnelCheck;
 var init_tunnel = __esm({
@@ -2333,7 +2233,7 @@ var init_tunnel = __esm({
           return results;
         }
         const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
-        const sm = new SettingsManager2(path22.join(ctx.pluginsDir, "data"));
+        const sm = new SettingsManager2(path21.join(ctx.pluginsDir, "data"));
         const tunnelSettings = await sm.loadSettings("@openacp/tunnel");
         const tunnelEnabled = tunnelSettings.enabled ?? false;
         const provider = tunnelSettings.provider ?? "cloudflare";
@@ -2344,10 +2244,10 @@ var init_tunnel = __esm({
         }
         results.push({ status: "pass", message: `Tunnel provider: ${provider}` });
         if (provider === "cloudflare") {
-          const binName = os10.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
-          const binPath = path22.join(ctx.dataDir, "bin", binName);
+          const binName = os6.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
+          const binPath = path21.join(ctx.dataDir, "bin", binName);
           let found = false;
-          if (fs24.existsSync(binPath)) {
+          if (fs23.existsSync(binPath)) {
             found = true;
           } else {
             try {
@@ -2388,14 +2288,13 @@ var init_tunnel = __esm({
 });
 
 // src/core/doctor/index.ts
-import * as fs25 from "fs";
-import * as path23 from "path";
+import * as fs24 from "fs";
+import * as path22 from "path";
 var ALL_CHECKS, CHECK_TIMEOUT_MS, DoctorEngine;
 var init_doctor = __esm({
   "src/core/doctor/index.ts"() {
     "use strict";
     init_config();
-    init_instance_context();
     init_config2();
     init_agents();
     init_telegram();
@@ -2420,7 +2319,7 @@ var init_doctor = __esm({
       dataDir;
       constructor(options) {
         this.dryRun = options?.dryRun ?? false;
-        this.dataDir = options?.dataDir ?? getGlobalRoot();
+        this.dataDir = options.dataDir;
       }
       async runAll() {
         const ctx = await this.buildContext();
@@ -2471,27 +2370,27 @@ var init_doctor = __esm({
       }
       async buildContext() {
         const dataDir = this.dataDir;
-        const configPath = process.env.OPENACP_CONFIG_PATH || path23.join(dataDir, "config.json");
+        const configPath = process.env.OPENACP_CONFIG_PATH || path22.join(dataDir, "config.json");
         let config = null;
         let rawConfig = null;
         try {
-          const content = fs25.readFileSync(configPath, "utf-8");
+          const content = fs24.readFileSync(configPath, "utf-8");
           rawConfig = JSON.parse(content);
           const cm = new ConfigManager(configPath);
           await cm.load();
           config = cm.get();
         } catch {
         }
-        const logsDir = config ? expandHome3(config.logging.logDir) : path23.join(dataDir, "logs");
+        const logsDir = config ? expandHome2(config.logging.logDir) : path22.join(dataDir, "logs");
         return {
           config,
           rawConfig,
           configPath,
           dataDir,
-          sessionsPath: path23.join(dataDir, "sessions.json"),
-          pidPath: path23.join(dataDir, "openacp.pid"),
-          portFilePath: path23.join(dataDir, "api.port"),
-          pluginsDir: path23.join(dataDir, "plugins"),
+          sessionsPath: path22.join(dataDir, "sessions.json"),
+          pidPath: path22.join(dataDir, "openacp.pid"),
+          portFilePath: path22.join(dataDir, "api.port"),
+          pluginsDir: path22.join(dataDir, "plugins"),
           logsDir
         };
       }
@@ -2499,6 +2398,123 @@ var init_doctor = __esm({
   }
 });
 
+// src/core/instance/instance-context.ts
+import path24 from "path";
+import fs26 from "fs";
+import os8 from "os";
+function getGlobalRoot() {
+  return path24.join(os8.homedir(), ".openacp");
+}
+var init_instance_context = __esm({
+  "src/core/instance/instance-context.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/instance/instance-registry.ts
+import fs27 from "fs";
+import path25 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+function readIdFromConfig(instanceRoot) {
+  try {
+    const raw = JSON.parse(fs27.readFileSync(path25.join(instanceRoot, "config.json"), "utf-8"));
+    return typeof raw.id === "string" && raw.id ? raw.id : null;
+  } catch {
+    return null;
+  }
+}
+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 = fs27.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 = path25.dirname(this.registryPath);
+        fs27.mkdirSync(dir, { recursive: true });
+        fs27.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}`;
+      }
+      /**
+       * Resolve the authoritative id for an instance root.
+       *
+       * config.json is the source of truth. If the registry entry disagrees with
+       * config.json, the registry is updated to match. If neither exists, a fresh
+       * UUID is generated and registered (but NOT written to config.json — the
+       * caller must call initInstanceFiles to persist it).
+       *
+       * Returns the resolved id and whether the registry was mutated (so callers
+       * can decide whether to persist with save()).
+       */
+      resolveId(instanceRoot) {
+        const configId = readIdFromConfig(instanceRoot);
+        const entry = this.getByRoot(instanceRoot);
+        if (entry && configId && entry.id !== configId) {
+          this.remove(entry.id);
+          this.register(configId, instanceRoot);
+          return { id: configId, registryUpdated: true };
+        }
+        const id = configId ?? entry?.id ?? randomUUID2();
+        if (!this.getByRoot(instanceRoot)) {
+          this.register(id, instanceRoot);
+          return { id, registryUpdated: true };
+        }
+        return { id, registryUpdated: false };
+      }
+    };
+  }
+});
+
 // src/core/plugin/plugin-installer.ts
 var plugin_installer_exports = {};
 __export(plugin_installer_exports, {
@@ -2507,16 +2523,15 @@ __export(plugin_installer_exports, {
 });
 import { execFile } from "child_process";
 import { promisify } from "util";
-import * as fs27 from "fs/promises";
-import * as os12 from "os";
-import * as path25 from "path";
+import * as fs29 from "fs/promises";
+import * as path27 from "path";
 import { pathToFileURL } from "url";
 async function importFromDir(packageName, dir) {
-  const pkgDir = path25.join(dir, "node_modules", ...packageName.split("/"));
-  const pkgJsonPath = path25.join(pkgDir, "package.json");
+  const pkgDir = path27.join(dir, "node_modules", ...packageName.split("/"));
+  const pkgJsonPath = path27.join(pkgDir, "package.json");
   let pkgJson;
   try {
-    pkgJson = JSON.parse(await fs27.readFile(pkgJsonPath, "utf-8"));
+    pkgJson = JSON.parse(await fs29.readFile(pkgJsonPath, "utf-8"));
   } catch (err) {
     throw new Error(`Cannot read package.json for "${packageName}" at ${pkgJsonPath}: ${err.message}`);
   }
@@ -2529,9 +2544,9 @@ async function importFromDir(packageName, dir) {
   } else {
     entry = pkgJson.main ?? "index.js";
   }
-  const entryPath = path25.join(pkgDir, entry);
+  const entryPath = path27.join(pkgDir, entry);
   try {
-    await fs27.access(entryPath);
+    await fs29.access(entryPath);
   } catch {
     throw new Error(`Entry point "${entry}" not found for "${packageName}" at ${entryPath}`);
   }
@@ -2541,7 +2556,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 ?? path25.join(os12.homedir(), ".openacp", "plugins");
+  const dir = pluginsDir;
   try {
     return await importFromDir(packageName, dir);
   } catch {
@@ -2623,10 +2638,10 @@ var install_context_exports = {};
 __export(install_context_exports, {
   createInstallContext: () => createInstallContext
 });
-import path26 from "path";
+import path28 from "path";
 function createInstallContext(opts) {
   const { pluginName, settingsManager, basePath, instanceRoot } = opts;
-  const dataDir = path26.join(basePath, pluginName, "data");
+  const dataDir = path28.join(basePath, pluginName, "data");
   return {
     pluginName,
     terminal: createTerminalIO(),
@@ -2650,21 +2665,31 @@ __export(api_client_exports, {
   apiCall: () => apiCall,
   readApiPort: () => readApiPort,
   readApiSecret: () => readApiSecret,
-  removeStalePortFile: () => removeStalePortFile
+  removeStalePortFile: () => removeStalePortFile,
+  waitForPortFile: () => waitForPortFile
 });
-import * as fs28 from "fs";
-import * as path27 from "path";
-import * as os13 from "os";
+import * as fs30 from "fs";
+import * as path29 from "path";
+import { setTimeout as sleep } from "timers/promises";
 function defaultPortFile(root) {
-  return path27.join(root ?? DEFAULT_ROOT, "api.port");
+  return path29.join(root, "api.port");
 }
 function defaultSecretFile(root) {
-  return path27.join(root ?? DEFAULT_ROOT, "api-secret");
+  return path29.join(root, "api-secret");
+}
+async function waitForPortFile(portFilePath, timeoutMs = 5e3, intervalMs = 100) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const port = readApiPort(portFilePath);
+    if (port !== null) return port;
+    await sleep(intervalMs);
+  }
+  return readApiPort(portFilePath);
 }
 function readApiPort(portFilePath, instanceRoot) {
   const filePath = portFilePath ?? defaultPortFile(instanceRoot);
   try {
-    const content = fs28.readFileSync(filePath, "utf-8").trim();
+    const content = fs30.readFileSync(filePath, "utf-8").trim();
     const port = parseInt(content, 10);
     return isNaN(port) ? null : port;
   } catch {
@@ -2674,7 +2699,7 @@ function readApiPort(portFilePath, instanceRoot) {
 function readApiSecret(secretFilePath, instanceRoot) {
   const filePath = secretFilePath ?? defaultSecretFile(instanceRoot);
   try {
-    const content = fs28.readFileSync(filePath, "utf-8").trim();
+    const content = fs30.readFileSync(filePath, "utf-8").trim();
     return content || null;
   } catch {
     return null;
@@ -2683,7 +2708,7 @@ function readApiSecret(secretFilePath, instanceRoot) {
 function removeStalePortFile(portFilePath, instanceRoot) {
   const filePath = portFilePath ?? defaultPortFile(instanceRoot);
   try {
-    fs28.unlinkSync(filePath);
+    fs30.unlinkSync(filePath);
   } catch {
   }
 }
@@ -2695,11 +2720,9 @@ async function apiCall(port, urlPath, options, instanceRoot) {
   }
   return fetch(`http://127.0.0.1:${port}${urlPath}`, { ...options, headers });
 }
-var DEFAULT_ROOT;
 var init_api_client = __esm({
   "src/cli/api-client.ts"() {
     "use strict";
-    DEFAULT_ROOT = path27.join(os13.homedir(), ".openacp");
   }
 });
 
@@ -2733,8 +2756,8 @@ var init_notification = __esm({
 });
 
 // src/plugins/file-service/file-service.ts
-import fs30 from "fs";
-import path30 from "path";
+import fs32 from "fs";
+import path32 from "path";
 import { OggOpusDecoder } from "ogg-opus-decoder";
 import wav from "node-wav";
 function classifyMime(mimeType) {
@@ -2790,14 +2813,14 @@ var init_file_service = __esm({
         const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
         let removed = 0;
         try {
-          const entries = await fs30.promises.readdir(this.baseDir, { withFileTypes: true });
+          const entries = await fs32.promises.readdir(this.baseDir, { withFileTypes: true });
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
-            const dirPath = path30.join(this.baseDir, entry.name);
+            const dirPath = path32.join(this.baseDir, entry.name);
             try {
-              const stat = await fs30.promises.stat(dirPath);
+              const stat = await fs32.promises.stat(dirPath);
               if (stat.mtimeMs < cutoff) {
-                await fs30.promises.rm(dirPath, { recursive: true, force: true });
+                await fs32.promises.rm(dirPath, { recursive: true, force: true });
                 removed++;
               }
             } catch {
@@ -2808,11 +2831,11 @@ var init_file_service = __esm({
         return removed;
       }
       async saveFile(sessionId, fileName, data, mimeType) {
-        const sessionDir = path30.join(this.baseDir, sessionId);
-        await fs30.promises.mkdir(sessionDir, { recursive: true });
+        const sessionDir = path32.join(this.baseDir, sessionId);
+        await fs32.promises.mkdir(sessionDir, { recursive: true });
         const safeName = `${Date.now()}-${fileName.replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-        const filePath = path30.join(sessionDir, safeName);
-        await fs30.promises.writeFile(filePath, data);
+        const filePath = path32.join(sessionDir, safeName);
+        await fs32.promises.writeFile(filePath, data);
         return {
           type: classifyMime(mimeType),
           filePath,
@@ -2823,14 +2846,14 @@ var init_file_service = __esm({
       }
       async resolveFile(filePath) {
         try {
-          const stat = await fs30.promises.stat(filePath);
+          const stat = await fs32.promises.stat(filePath);
           if (!stat.isFile()) return null;
-          const ext = path30.extname(filePath).toLowerCase();
+          const ext = path32.extname(filePath).toLowerCase();
           const mimeType = EXT_TO_MIME[ext] || "application/octet-stream";
           return {
             type: classifyMime(mimeType),
             filePath,
-            fileName: path30.basename(filePath),
+            fileName: path32.basename(filePath),
             mimeType,
             size: stat.size
           };
@@ -3065,7 +3088,7 @@ function createAuthPreHandler(getSecret, getJwtSecret, tokenStore) {
     const queryToken = request.query?.token;
     const token = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : queryToken;
     if (queryToken && !authHeader) {
-      log20.warn(
+      log21.warn(
         { url: request.url.replace(/([?&]token=)[^&]+/, "$1[REDACTED]") },
         "Token passed via URL query param \u2014 use Authorization: Bearer header to avoid token leakage in tunnel/proxy logs"
       );
@@ -3119,7 +3142,7 @@ function requireRole(role) {
     }
   };
 }
-var log20;
+var log21;
 var init_auth = __esm({
   "src/plugins/api-server/middleware/auth.ts"() {
     "use strict";
@@ -3127,7 +3150,7 @@ var init_auth = __esm({
     init_jwt();
     init_roles();
     init_log();
-    log20 = createChildLogger({ module: "api-auth" });
+    log21 = createChildLogger({ module: "api-auth" });
   }
 });
 
@@ -3396,8 +3419,8 @@ data: ${JSON.stringify(data)}
 });
 
 // src/plugins/api-server/static-server.ts
-import * as fs31 from "fs";
-import * as path31 from "path";
+import * as fs33 from "fs";
+import * as path33 from "path";
 import { fileURLToPath } from "url";
 var MIME_TYPES, StaticServer;
 var init_static_server = __esm({
@@ -3421,16 +3444,16 @@ var init_static_server = __esm({
         this.uiDir = uiDir;
         if (!this.uiDir) {
           const __filename = fileURLToPath(import.meta.url);
-          const candidate = path31.resolve(path31.dirname(__filename), "../../ui/dist");
-          if (fs31.existsSync(path31.join(candidate, "index.html"))) {
+          const candidate = path33.resolve(path33.dirname(__filename), "../../ui/dist");
+          if (fs33.existsSync(path33.join(candidate, "index.html"))) {
             this.uiDir = candidate;
           }
           if (!this.uiDir) {
-            const publishCandidate = path31.resolve(
-              path31.dirname(__filename),
+            const publishCandidate = path33.resolve(
+              path33.dirname(__filename),
               "../ui"
             );
-            if (fs31.existsSync(path31.join(publishCandidate, "index.html"))) {
+            if (fs33.existsSync(path33.join(publishCandidate, "index.html"))) {
               this.uiDir = publishCandidate;
             }
           }
@@ -3442,23 +3465,23 @@ var init_static_server = __esm({
       serve(req, res) {
         if (!this.uiDir) return false;
         const urlPath = (req.url || "/").split("?")[0];
-        const safePath = path31.normalize(urlPath);
-        const filePath = path31.join(this.uiDir, safePath);
-        if (!filePath.startsWith(this.uiDir + path31.sep) && filePath !== this.uiDir)
+        const safePath = path33.normalize(urlPath);
+        const filePath = path33.join(this.uiDir, safePath);
+        if (!filePath.startsWith(this.uiDir + path33.sep) && filePath !== this.uiDir)
           return false;
         let realFilePath;
         try {
-          realFilePath = fs31.realpathSync(filePath);
+          realFilePath = fs33.realpathSync(filePath);
         } catch {
           realFilePath = null;
         }
         if (realFilePath !== null) {
-          const realUiDir = fs31.realpathSync(this.uiDir);
-          if (!realFilePath.startsWith(realUiDir + path31.sep) && realFilePath !== realUiDir)
+          const realUiDir = fs33.realpathSync(this.uiDir);
+          if (!realFilePath.startsWith(realUiDir + path33.sep) && realFilePath !== realUiDir)
             return false;
         }
-        if (realFilePath !== null && fs31.existsSync(realFilePath) && fs31.statSync(realFilePath).isFile()) {
-          const ext = path31.extname(filePath);
+        if (realFilePath !== null && fs33.existsSync(realFilePath) && fs33.statSync(realFilePath).isFile()) {
+          const ext = path33.extname(filePath);
           const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
           const isHashed = /\.[a-zA-Z0-9]{8,}\.(js|css)$/.test(filePath);
           const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "no-cache";
@@ -3466,16 +3489,16 @@ var init_static_server = __esm({
             "Content-Type": contentType,
             "Cache-Control": cacheControl
           });
-          fs31.createReadStream(realFilePath).pipe(res);
+          fs33.createReadStream(realFilePath).pipe(res);
           return true;
         }
-        const indexPath = path31.join(this.uiDir, "index.html");
-        if (fs31.existsSync(indexPath)) {
+        const indexPath = path33.join(this.uiDir, "index.html");
+        if (fs33.existsSync(indexPath)) {
           res.writeHead(200, {
             "Content-Type": "text/html; charset=utf-8",
             "Cache-Control": "no-cache"
           });
-          fs31.createReadStream(indexPath).pipe(res);
+          fs33.createReadStream(indexPath).pipe(res);
           return true;
         }
         return false;
@@ -3630,8 +3653,8 @@ var init_exports = __esm({
 });
 
 // src/plugins/context/context-cache.ts
-import * as fs32 from "fs";
-import * as path32 from "path";
+import * as fs34 from "fs";
+import * as path34 from "path";
 import * as crypto2 from "crypto";
 var DEFAULT_TTL_MS, ContextCache;
 var init_context_cache = __esm({
@@ -3642,37 +3665,35 @@ var init_context_cache = __esm({
       constructor(cacheDir, ttlMs = DEFAULT_TTL_MS) {
         this.cacheDir = cacheDir;
         this.ttlMs = ttlMs;
-        fs32.mkdirSync(cacheDir, { recursive: true });
+        fs34.mkdirSync(cacheDir, { recursive: true });
       }
       keyHash(repoPath, queryKey) {
         return crypto2.createHash("sha256").update(`${repoPath}:${queryKey}`).digest("hex").slice(0, 16);
       }
       filePath(repoPath, queryKey) {
-        return path32.join(this.cacheDir, `${this.keyHash(repoPath, queryKey)}.json`);
+        return path34.join(this.cacheDir, `${this.keyHash(repoPath, queryKey)}.json`);
       }
       get(repoPath, queryKey) {
         const fp = this.filePath(repoPath, queryKey);
         try {
-          const stat = fs32.statSync(fp);
+          const stat = fs34.statSync(fp);
           if (Date.now() - stat.mtimeMs > this.ttlMs) {
-            fs32.unlinkSync(fp);
+            fs34.unlinkSync(fp);
             return null;
           }
-          return JSON.parse(fs32.readFileSync(fp, "utf-8"));
+          return JSON.parse(fs34.readFileSync(fp, "utf-8"));
         } catch {
           return null;
         }
       }
       set(repoPath, queryKey, result) {
-        fs32.writeFileSync(this.filePath(repoPath, queryKey), JSON.stringify(result));
+        fs34.writeFileSync(this.filePath(repoPath, queryKey), JSON.stringify(result));
       }
     };
   }
 });
 
 // src/plugins/context/context-manager.ts
-import * as os15 from "os";
-import * as path33 from "path";
 var ContextManager;
 var init_context_manager = __esm({
   "src/plugins/context/context-manager.ts"() {
@@ -3684,7 +3705,7 @@ var init_context_manager = __esm({
       historyStore;
       sessionFlusher;
       constructor(cachePath) {
-        this.cache = new ContextCache(cachePath ?? path33.join(os15.homedir(), ".openacp", "cache", "entire"));
+        this.cache = new ContextCache(cachePath);
       }
       setHistoryStore(store) {
         this.historyStore = store;
@@ -4601,8 +4622,8 @@ function formatToolSummary(name, rawInput, displaySummary) {
   }
   if (lowerName === "grep") {
     const pattern = args.pattern ?? "";
-    const path34 = args.path ?? "";
-    return pattern ? `\u{1F50D} Grep "${pattern}"${path34 ? ` in ${path34}` : ""}` : `\u{1F527} ${name}`;
+    const path35 = args.path ?? "";
+    return pattern ? `\u{1F50D} Grep "${pattern}"${path35 ? ` in ${path35}` : ""}` : `\u{1F527} ${name}`;
   }
   if (lowerName === "glob") {
     const pattern = args.pattern ?? "";
@@ -4638,8 +4659,8 @@ function formatToolTitle(name, rawInput, displayTitle) {
   }
   if (lowerName === "grep") {
     const pattern = args.pattern ?? "";
-    const path34 = args.path ?? "";
-    return pattern ? `"${pattern}"${path34 ? ` in ${path34}` : ""}` : name;
+    const path35 = args.path ?? "";
+    return pattern ? `"${pattern}"${path35 ? ` in ${path35}` : ""}` : name;
   }
   if (lowerName === "glob") {
     return String(args.pattern ?? name);
@@ -5842,13 +5863,13 @@ __export(version_exports, {
   runUpdate: () => runUpdate
 });
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname10, join as join20, resolve as resolve6 } from "path";
-import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname12, join as join16, resolve as resolve6 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
 function findPackageJson() {
-  let dir = dirname10(fileURLToPath2(import.meta.url));
+  let dir = dirname12(fileURLToPath2(import.meta.url));
   for (let i = 0; i < 5; i++) {
-    const candidate = join20(dir, "package.json");
-    if (existsSync17(candidate)) return candidate;
+    const candidate = join16(dir, "package.json");
+    if (existsSync16(candidate)) return candidate;
     const parent = resolve6(dir, "..");
     if (parent === dir) break;
     dir = parent;
@@ -5859,7 +5880,7 @@ function getCurrentVersion() {
   try {
     const pkgPath = findPackageJson();
     if (!pkgPath) return "0.0.0-dev";
-    const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "0.0.0-dev";
@@ -5965,7 +5986,7 @@ function setupDangerousModeCallbacks(bot, core) {
         }).catch(() => {
         });
       }
-      log22.info({ sessionId, wantOn }, "Bypass permissions toggled via button");
+      log23.info({ sessionId, wantOn }, "Bypass permissions toggled via button");
       try {
         await ctx.editMessageText(buildSessionStatusText(session), {
           parse_mode: "HTML",
@@ -5988,7 +6009,7 @@ function setupDangerousModeCallbacks(bot, core) {
     const newDangerousMode = !(record.clientOverrides?.bypassPermissions ?? record.dangerousMode ?? false);
     core.sessionManager.patchRecord(sessionId, { clientOverrides: { bypassPermissions: newDangerousMode } }).catch(() => {
     });
-    log22.info(
+    log23.info(
       { sessionId, dangerousMode: newDangerousMode },
       "Bypass permissions toggled via button (store-only, session not in memory)"
     );
@@ -6173,14 +6194,14 @@ async function handleRestart(ctx, core) {
   await new Promise((r) => setTimeout(r, 500));
   await core.requestRestart();
 }
-var log22, OUTPUT_MODE_LABELS;
+var log23, OUTPUT_MODE_LABELS;
 var init_admin = __esm({
   "src/plugins/telegram/commands/admin.ts"() {
     "use strict";
     init_bypass_detection();
     init_formatting();
     init_log();
-    log22 = createChildLogger({ module: "telegram-cmd-admin" });
+    log23 = createChildLogger({ module: "telegram-cmd-admin" });
     OUTPUT_MODE_LABELS = {
       low: "\u{1F507} Low",
       medium: "\u{1F4CA} Medium",
@@ -6195,7 +6216,7 @@ function botFromCtx(ctx) {
   return { api: ctx.api };
 }
 async function createSessionDirect(ctx, core, chatId, agentName, workspace, onControlMessage) {
-  log23.info({ userId: ctx.from?.id, agentName, workspace }, "New session command (direct)");
+  log24.info({ userId: ctx.from?.id, agentName, workspace }, "New session command (direct)");
   let threadId;
   try {
     const topicName = `\u{1F504} New Session`;
@@ -6222,7 +6243,7 @@ async function createSessionDirect(ctx, core, chatId, agentName, workspace, onCo
     onControlMessage?.(session.id, controlMsg.message_id);
     return threadId ?? null;
   } catch (err) {
-    log23.error({ err }, "Session creation failed");
+    log24.error({ err }, "Session creation failed");
     if (threadId) {
       try {
         await ctx.api.deleteForumTopic(chatId, threadId);
@@ -6329,10 +6350,8 @@ async function showAgentPicker(ctx, core, chatId) {
 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 resolvedBaseDir = core.configManager.resolveWorkspace();
+  const hasBaseDir = recentWorkspaces.some((ws) => ws === resolvedBaseDir);
   const workspaces = hasBaseDir ? recentWorkspaces : [resolvedBaseDir, ...recentWorkspaces].slice(0, 5);
   const kb = new InlineKeyboard2();
   for (const ws of workspaces) {
@@ -6457,7 +6476,7 @@ Agent: <code>${escapeHtml(agentKey)}</code>
     await _sendCustomPathPrompt(ctx, chatId, agentKey);
   });
 }
-var log23, WS_CACHE_MAX, workspaceCache, nextWsId, _forceReplyMap;
+var log24, WS_CACHE_MAX, workspaceCache, nextWsId, _forceReplyMap;
 var init_new_session = __esm({
   "src/plugins/telegram/commands/new-session.ts"() {
     "use strict";
@@ -6465,7 +6484,7 @@ var init_new_session = __esm({
     init_topics();
     init_log();
     init_admin();
-    log23 = createChildLogger({ module: "telegram-cmd-new-session" });
+    log24 = createChildLogger({ module: "telegram-cmd-new-session" });
     WS_CACHE_MAX = 50;
     workspaceCache = /* @__PURE__ */ new Map();
     nextWsId = 0;
@@ -6530,7 +6549,7 @@ ${lines.join("\n")}${truncated}`,
       { parse_mode: "HTML", reply_markup: keyboard }
     );
   } catch (err) {
-    log24.error({ err }, "handleTopics error");
+    log25.error({ err }, "handleTopics error");
     await ctx.reply("\u274C Failed to list sessions.", { parse_mode: "HTML" }).catch(() => {
     });
   }
@@ -6551,13 +6570,13 @@ async function handleCleanup(ctx, core, chatId, statuses) {
         try {
           await ctx.api.deleteForumTopic(chatId, topicId);
         } catch (err) {
-          log24.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
+          log25.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
         }
       }
       await core.sessionManager.removeRecord(record.sessionId);
       deleted++;
     } catch (err) {
-      log24.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
+      log25.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
       failed++;
     }
   }
@@ -6628,7 +6647,7 @@ async function handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicId
         try {
           await core.sessionManager.cancelSession(record.sessionId);
         } catch (err) {
-          log24.warn({ err, sessionId: record.sessionId }, "Failed to cancel session during cleanup");
+          log25.warn({ err, sessionId: record.sessionId }, "Failed to cancel session during cleanup");
         }
       }
       const topicId = record.platform?.topicId;
@@ -6636,13 +6655,13 @@ async function handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicId
         try {
           await ctx.api.deleteForumTopic(chatId, topicId);
         } catch (err) {
-          log24.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
+          log25.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
         }
       }
       await core.sessionManager.removeRecord(record.sessionId);
       deleted++;
     } catch (err) {
-      log24.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
+      log25.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
       failed++;
     }
   }
@@ -6710,13 +6729,13 @@ async function handleArchiveConfirm(ctx, core, chatId) {
     }
   }
 }
-var log24;
+var log25;
 var init_session = __esm({
   "src/plugins/telegram/commands/session.ts"() {
     "use strict";
     init_formatting();
     init_log();
-    log24 = createChildLogger({ module: "telegram-cmd-session" });
+    log25 = createChildLogger({ module: "telegram-cmd-session" });
   }
 });
 
@@ -6728,14 +6747,14 @@ __export(integrate_exports, {
   listIntegrations: () => listIntegrations,
   uninstallIntegration: () => uninstallIntegration
 });
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync16, writeFileSync as writeFileSync11, unlinkSync as unlinkSync7, chmodSync, rmdirSync } from "fs";
-import { join as join21, dirname as dirname11 } from "path";
-import { homedir as homedir10 } from "os";
+import { existsSync as existsSync17, mkdirSync as mkdirSync11, readFileSync as readFileSync15, writeFileSync as writeFileSync11, unlinkSync as unlinkSync7, chmodSync, rmdirSync } from "fs";
+import { join as join17, dirname as dirname13 } from "path";
+import { homedir as homedir4 } from "os";
 function isHooksIntegrationSpec(spec) {
   return spec.strategy === "hooks";
 }
 function expandPath(p) {
-  return p.replace(/^~/, homedir10());
+  return p.replace(/^~/, homedir4());
 }
 function generateInjectScript(_agentKey, spec) {
   const sidVar = spec.sessionIdVar ?? "SESSION_ID";
@@ -6890,8 +6909,8 @@ function generateOpencodePlugin(spec) {
 function mergeSettingsJson(settingsPath, hookEvent, hookScriptPath) {
   const fullPath = expandPath(settingsPath);
   let settings = {};
-  if (existsSync18(fullPath)) {
-    const raw = readFileSync16(fullPath, "utf-8");
+  if (existsSync17(fullPath)) {
+    const raw = readFileSync15(fullPath, "utf-8");
     writeFileSync11(`${fullPath}.bak`, raw);
     settings = JSON.parse(raw);
   }
@@ -6907,14 +6926,14 @@ function mergeSettingsJson(settingsPath, hookEvent, hookScriptPath) {
       hooks: [{ type: "command", command: hookScriptPath }]
     });
   }
-  mkdirSync11(dirname11(fullPath), { recursive: true });
+  mkdirSync11(dirname13(fullPath), { recursive: true });
   writeFileSync11(fullPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function mergeHooksJson(settingsPath, hookEvent, hookScriptPath) {
   const fullPath = expandPath(settingsPath);
   let config = { version: 1 };
-  if (existsSync18(fullPath)) {
-    const raw = readFileSync16(fullPath, "utf-8");
+  if (existsSync17(fullPath)) {
+    const raw = readFileSync15(fullPath, "utf-8");
     writeFileSync11(`${fullPath}.bak`, raw);
     config = JSON.parse(raw);
   }
@@ -6926,13 +6945,13 @@ function mergeHooksJson(settingsPath, hookEvent, hookScriptPath) {
   if (!alreadyInstalled) {
     eventHooks.push({ command: hookScriptPath });
   }
-  mkdirSync11(dirname11(fullPath), { recursive: true });
+  mkdirSync11(dirname13(fullPath), { recursive: true });
   writeFileSync11(fullPath, JSON.stringify(config, null, 2) + "\n");
 }
 function removeFromSettingsJson(settingsPath, hookEvent) {
   const fullPath = expandPath(settingsPath);
-  if (!existsSync18(fullPath)) return;
-  const raw = readFileSync16(fullPath, "utf-8");
+  if (!existsSync17(fullPath)) return;
+  const raw = readFileSync15(fullPath, "utf-8");
   const settings = JSON.parse(raw);
   const hooks = settings.hooks;
   if (!hooks?.[hookEvent]) return;
@@ -6946,8 +6965,8 @@ function removeFromSettingsJson(settingsPath, hookEvent) {
 }
 function removeFromHooksJson(settingsPath, hookEvent) {
   const fullPath = expandPath(settingsPath);
-  if (!existsSync18(fullPath)) return;
-  const raw = readFileSync16(fullPath, "utf-8");
+  if (!existsSync17(fullPath)) return;
+  const raw = readFileSync15(fullPath, "utf-8");
   const config = JSON.parse(raw);
   const hooks = config.hooks;
   if (!hooks?.[hookEvent]) return;
@@ -6970,30 +6989,30 @@ async function installHooksIntegration(agentKey, spec) {
     }
     const hooksDir = expandPath(spec.hooksDirPath);
     mkdirSync11(hooksDir, { recursive: true });
-    const injectPath = join21(hooksDir, "openacp-inject-session.sh");
+    const injectPath = join17(hooksDir, "openacp-inject-session.sh");
     writeFileSync11(injectPath, generateInjectScript(agentKey, spec));
     chmodSync(injectPath, 493);
     logs.push(`Created ${injectPath}`);
-    const handoffPath = join21(hooksDir, "openacp-handoff.sh");
+    const handoffPath = join17(hooksDir, "openacp-handoff.sh");
     writeFileSync11(handoffPath, generateHandoffScript(agentKey));
     chmodSync(handoffPath, 493);
     logs.push(`Created ${handoffPath}`);
     if (spec.commandsPath && spec.handoffCommandName) {
       if (spec.commandFormat === "skill") {
-        const skillDir = expandPath(join21(spec.commandsPath, spec.handoffCommandName));
+        const skillDir = expandPath(join17(spec.commandsPath, spec.handoffCommandName));
         mkdirSync11(skillDir, { recursive: true });
-        const skillPath = join21(skillDir, "SKILL.md");
+        const skillPath = join17(skillDir, "SKILL.md");
         writeFileSync11(skillPath, generateHandoffCommand(agentKey, spec));
         logs.push(`Created ${skillPath}`);
       } else {
         const cmdsDir = expandPath(spec.commandsPath);
         mkdirSync11(cmdsDir, { recursive: true });
-        const cmdPath = join21(cmdsDir, `${spec.handoffCommandName}.md`);
+        const cmdPath = join17(cmdsDir, `${spec.handoffCommandName}.md`);
         writeFileSync11(cmdPath, generateHandoffCommand(agentKey, spec));
         logs.push(`Created ${cmdPath}`);
       }
     }
-    const injectFullPath = join21(hooksDir, "openacp-inject-session.sh");
+    const injectFullPath = join17(hooksDir, "openacp-inject-session.sh");
     if (spec.settingsFormat === "hooks_json") {
       mergeHooksJson(spec.settingsPath, spec.hookEvent, injectFullPath);
     } else {
@@ -7011,17 +7030,17 @@ async function uninstallHooksIntegration(agentKey, spec) {
   try {
     const hooksDir = expandPath(spec.hooksDirPath);
     for (const filename of ["openacp-inject-session.sh", "openacp-handoff.sh"]) {
-      const filePath = join21(hooksDir, filename);
-      if (existsSync18(filePath)) {
+      const filePath = join17(hooksDir, filename);
+      if (existsSync17(filePath)) {
         unlinkSync7(filePath);
         logs.push(`Removed ${filePath}`);
       }
     }
     if (spec.commandsPath && spec.handoffCommandName) {
       if (spec.commandFormat === "skill") {
-        const skillDir = expandPath(join21(spec.commandsPath, spec.handoffCommandName));
-        const skillPath = join21(skillDir, "SKILL.md");
-        if (existsSync18(skillPath)) {
+        const skillDir = expandPath(join17(spec.commandsPath, spec.handoffCommandName));
+        const skillPath = join17(skillDir, "SKILL.md");
+        if (existsSync17(skillPath)) {
           unlinkSync7(skillPath);
           try {
             rmdirSync(skillDir);
@@ -7030,8 +7049,8 @@ async function uninstallHooksIntegration(agentKey, spec) {
           logs.push(`Removed ${skillPath}`);
         }
       } else {
-        const cmdPath = expandPath(join21(spec.commandsPath, `${spec.handoffCommandName}.md`));
-        if (existsSync18(cmdPath)) {
+        const cmdPath = expandPath(join17(spec.commandsPath, `${spec.handoffCommandName}.md`));
+        if (existsSync17(cmdPath)) {
           unlinkSync7(cmdPath);
           logs.push(`Removed ${cmdPath}`);
         }
@@ -7054,15 +7073,15 @@ async function installPluginIntegration(_agentKey, spec) {
   try {
     const commandsDir = expandPath(spec.commandsPath);
     mkdirSync11(commandsDir, { recursive: true });
-    const commandPath = join21(commandsDir, spec.handoffCommandFile);
+    const commandPath = join17(commandsDir, spec.handoffCommandFile);
     const pluginsDir = expandPath(spec.pluginsPath);
     mkdirSync11(pluginsDir, { recursive: true });
-    const pluginPath = join21(pluginsDir, spec.pluginFileName);
-    if (existsSync18(commandPath) && existsSync18(pluginPath)) {
+    const pluginPath = join17(pluginsDir, spec.pluginFileName);
+    if (existsSync17(commandPath) && existsSync17(pluginPath)) {
       logs.push("Already installed, skipping.");
       return { success: true, logs };
     }
-    if (existsSync18(commandPath) || existsSync18(pluginPath)) {
+    if (existsSync17(commandPath) || existsSync17(pluginPath)) {
       logs.push("Overwriting existing files.");
     }
     writeFileSync11(commandPath, generateOpencodeHandoffCommand(spec));
@@ -7078,15 +7097,15 @@ async function installPluginIntegration(_agentKey, spec) {
 async function uninstallPluginIntegration(_agentKey, spec) {
   const logs = [];
   try {
-    const commandPath = join21(expandPath(spec.commandsPath), spec.handoffCommandFile);
+    const commandPath = join17(expandPath(spec.commandsPath), spec.handoffCommandFile);
     let removedCount = 0;
-    if (existsSync18(commandPath)) {
+    if (existsSync17(commandPath)) {
       unlinkSync7(commandPath);
       logs.push(`Removed ${commandPath}`);
       removedCount += 1;
     }
-    const pluginPath = join21(expandPath(spec.pluginsPath), spec.pluginFileName);
-    if (existsSync18(pluginPath)) {
+    const pluginPath = join17(expandPath(spec.pluginsPath), spec.pluginFileName);
+    if (existsSync17(pluginPath)) {
       unlinkSync7(pluginPath);
       logs.push(`Removed ${pluginPath}`);
       removedCount += 1;
@@ -7120,11 +7139,11 @@ function buildHandoffItem(agentKey, spec) {
     isInstalled() {
       if (isHooksIntegrationSpec(spec)) {
         const hooksDir = expandPath(spec.hooksDirPath);
-        return existsSync18(join21(hooksDir, "openacp-inject-session.sh")) && existsSync18(join21(hooksDir, "openacp-handoff.sh"));
+        return existsSync17(join17(hooksDir, "openacp-inject-session.sh")) && existsSync17(join17(hooksDir, "openacp-handoff.sh"));
       }
-      const commandPath = join21(expandPath(spec.commandsPath), spec.handoffCommandFile);
-      const pluginPath = join21(expandPath(spec.pluginsPath), spec.pluginFileName);
-      return existsSync18(commandPath) && existsSync18(pluginPath);
+      const commandPath = join17(expandPath(spec.commandsPath), spec.handoffCommandFile);
+      const pluginPath = join17(expandPath(spec.pluginsPath), spec.pluginFileName);
+      return existsSync17(commandPath) && existsSync17(pluginPath);
     },
     install: () => installIntegration(agentKey, spec),
     uninstall: () => uninstallIntegration(agentKey, spec)
@@ -7139,20 +7158,20 @@ function buildTunnelItem(spec) {
   if (!isHooksIntegrationSpec(spec) || !spec.commandsPath) return null;
   const hooksSpec = spec;
   function getTunnelPath() {
-    return join21(getSkillBasePath(hooksSpec), "openacp-tunnel", "SKILL.md");
+    return join17(getSkillBasePath(hooksSpec), "openacp-tunnel", "SKILL.md");
   }
   return {
     id: "tunnel",
     name: "Tunnel",
     description: "Expose local ports to the internet via OpenACP tunnel",
     isInstalled() {
-      return existsSync18(getTunnelPath());
+      return existsSync17(getTunnelPath());
     },
     async install() {
       const logs = [];
       try {
         const skillPath = getTunnelPath();
-        mkdirSync11(dirname11(skillPath), { recursive: true });
+        mkdirSync11(dirname13(skillPath), { recursive: true });
         writeFileSync11(skillPath, generateTunnelCommand());
         logs.push(`Created ${skillPath}`);
         return { success: true, logs };
@@ -7165,10 +7184,10 @@ function buildTunnelItem(spec) {
       const logs = [];
       try {
         const skillPath = getTunnelPath();
-        if (existsSync18(skillPath)) {
+        if (existsSync17(skillPath)) {
           unlinkSync7(skillPath);
           try {
-            rmdirSync(dirname11(skillPath));
+            rmdirSync(dirname13(skillPath));
           } catch {
           }
           logs.push(`Removed ${skillPath}`);
@@ -7467,7 +7486,7 @@ var init_agents2 = __esm({
 // src/plugins/telegram/commands/resume.ts
 function setupResumeCallbacks(_bot, _core, _chatId, _onControlMessage) {
 }
-var log25;
+var log26;
 var init_resume = __esm({
   "src/plugins/telegram/commands/resume.ts"() {
     "use strict";
@@ -7477,7 +7496,7 @@ var init_resume = __esm({
     init_topics();
     init_admin();
     init_log();
-    log25 = createChildLogger({ module: "telegram-cmd-resume" });
+    log26 = createChildLogger({ module: "telegram-cmd-resume" });
   }
 });
 
@@ -7640,7 +7659,7 @@ function setupSettingsCallbacks(bot, core, getAssistantSession) {
       } catch {
       }
     } catch (err) {
-      log26.error({ err, fieldPath }, "Failed to toggle config");
+      log27.error({ err, fieldPath }, "Failed to toggle config");
       try {
         await ctx.answerCallbackQuery({ text: "\u274C Failed to update" });
       } catch {
@@ -7721,7 +7740,7 @@ Tap to change:`, {
       } catch {
       }
     } catch (err) {
-      log26.error({ err, fieldPath }, "Failed to set config");
+      log27.error({ err, fieldPath }, "Failed to set config");
       try {
         await ctx.answerCallbackQuery({ text: "\u274C Failed to update" });
       } catch {
@@ -7779,13 +7798,13 @@ Tap to change:`, {
     }
   });
 }
-var log26;
+var log27;
 var init_settings = __esm({
   "src/plugins/telegram/commands/settings.ts"() {
     "use strict";
     init_config_registry();
     init_log();
-    log26 = createChildLogger({ module: "telegram-settings" });
+    log27 = createChildLogger({ module: "telegram-settings" });
   }
 });
 
@@ -7832,7 +7851,7 @@ async function handleDoctor(ctx) {
       reply_markup: keyboard
     });
   } catch (err) {
-    log27.error({ err }, "Doctor command failed");
+    log28.error({ err }, "Doctor command failed");
     await ctx.api.editMessageText(
       ctx.chat.id,
       statusMsg.message_id,
@@ -7881,7 +7900,7 @@ function setupDoctorCallbacks(bot) {
         }
       }
     } catch (err) {
-      log27.error({ err, index }, "Doctor fix callback failed");
+      log28.error({ err, index }, "Doctor fix callback failed");
     }
   });
   bot.callbackQuery("m:doctor", async (ctx) => {
@@ -7892,13 +7911,13 @@ function setupDoctorCallbacks(bot) {
     await handleDoctor(ctx);
   });
 }
-var log27, pendingFixesStore;
+var log28, pendingFixesStore;
 var init_doctor2 = __esm({
   "src/plugins/telegram/commands/doctor.ts"() {
     "use strict";
     init_doctor();
     init_log();
-    log27 = createChildLogger({ module: "telegram-cmd-doctor" });
+    log28 = createChildLogger({ module: "telegram-cmd-doctor" });
     pendingFixesStore = /* @__PURE__ */ new Map();
   }
 });
@@ -7957,13 +7976,13 @@ function setupTunnelCallbacks(bot, core) {
     }
   });
 }
-var log28;
+var log29;
 var init_tunnel2 = __esm({
   "src/plugins/telegram/commands/tunnel.ts"() {
     "use strict";
     init_formatting();
     init_log();
-    log28 = createChildLogger({ module: "telegram-cmd-tunnel" });
+    log29 = createChildLogger({ module: "telegram-cmd-tunnel" });
   }
 });
 
@@ -7977,10 +7996,10 @@ async function executeSwitchAgent(ctx, core, sessionId, agentName) {
       `Switched to <b>${escapeHtml(agentName)}</b> (${status})`,
       { parse_mode: "HTML" }
     );
-    log29.info({ sessionId, agentName, resumed }, "Agent switched via /switch");
+    log30.info({ sessionId, agentName, resumed }, "Agent switched via /switch");
   } catch (err) {
     await ctx.reply(`Failed to switch agent: ${escapeHtml(String(err.message || err))}`);
-    log29.warn({ sessionId, agentName, err: err.message }, "Agent switch failed");
+    log30.warn({ sessionId, agentName, err: err.message }, "Agent switch failed");
   }
 }
 function setupSwitchCallbacks(bot, core) {
@@ -8025,13 +8044,13 @@ Switch to <b>${escapeHtml(agentName)}</b> anyway?`,
     await executeSwitchAgent(ctx, core, session.id, data);
   });
 }
-var log29;
+var log30;
 var init_switch = __esm({
   "src/plugins/telegram/commands/switch.ts"() {
     "use strict";
     init_formatting();
     init_log();
-    log29 = createChildLogger({ module: "telegram-cmd-switch" });
+    log30 = createChildLogger({ module: "telegram-cmd-switch" });
   }
 });
 
@@ -8229,7 +8248,7 @@ function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSessio
       core,
       chatId,
       agentKey,
-      core.configManager.get().workspace.baseDir
+      core.configManager.resolveWorkspace()
     );
   });
   setupNewSessionCallbacks(bot, core, chatId);
@@ -8244,7 +8263,7 @@ function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSessio
     if (!menuRegistry) return;
     const item = menuRegistry.getItem(itemId);
     if (!item) {
-      log30.warn({ itemId }, "Menu item not found in registry");
+      log31.warn({ itemId }, "Menu item not found in registry");
       return;
     }
     const topicId = ctx.callbackQuery.message?.message_thread_id;
@@ -8330,7 +8349,7 @@ ${lines}`, { parse_mode: "HTML" }).catch(() => {
     }
   });
 }
-var log30, STATIC_COMMANDS;
+var log31, STATIC_COMMANDS;
 var init_commands = __esm({
   "src/plugins/telegram/commands/index.ts"() {
     "use strict";
@@ -8355,7 +8374,7 @@ var init_commands = __esm({
     init_settings();
     init_doctor2();
     init_resume();
-    log30 = createChildLogger({ module: "telegram-menu-callbacks" });
+    log31 = createChildLogger({ module: "telegram-menu-callbacks" });
     STATIC_COMMANDS = [
       { command: "new", description: "Create new session" },
       { command: "newchat", description: "New chat, same agent & workspace" },
@@ -8390,14 +8409,14 @@ var init_commands = __esm({
 // src/plugins/telegram/permissions.ts
 import { InlineKeyboard as InlineKeyboard11 } from "grammy";
 import { nanoid as nanoid4 } from "nanoid";
-var log31, PermissionHandler;
+var log32, PermissionHandler;
 var init_permissions = __esm({
   "src/plugins/telegram/permissions.ts"() {
     "use strict";
     init_formatting();
     init_topics();
     init_log();
-    log31 = createChildLogger({ module: "telegram-permissions" });
+    log32 = createChildLogger({ module: "telegram-permissions" });
     PermissionHandler = class {
       constructor(bot, chatId, getSession, sendNotification) {
         this.bot = bot;
@@ -8457,7 +8476,7 @@ ${escapeHtml(request.description)}`,
           }
           const session = this.getSession(pending.sessionId);
           const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
-          log31.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
+          log32.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
           if (session?.permissionGate.requestId === pending.requestId) {
             session.permissionGate.resolve(optionId);
           }
@@ -8477,7 +8496,7 @@ ${escapeHtml(request.description)}`,
 });
 
 // src/plugins/telegram/activity.ts
-var log32, THINKING_REFRESH_MS, THINKING_MAX_MS, ThinkingIndicator, ToolCard, ActivityTracker2;
+var log33, THINKING_REFRESH_MS, THINKING_MAX_MS, ThinkingIndicator, ToolCard, ActivityTracker2;
 var init_activity = __esm({
   "src/plugins/telegram/activity.ts"() {
     "use strict";
@@ -8487,7 +8506,7 @@ var init_activity = __esm({
     init_stream_accumulator();
     init_stream_accumulator();
     init_display_spec_builder();
-    log32 = createChildLogger({ module: "telegram:activity" });
+    log33 = createChildLogger({ module: "telegram:activity" });
     THINKING_REFRESH_MS = 15e3;
     THINKING_MAX_MS = 3 * 60 * 1e3;
     ThinkingIndicator = class {
@@ -8528,7 +8547,7 @@ var init_activity = __esm({
             }
           }
         } catch (err) {
-          log32.warn({ err }, "ThinkingIndicator.show() failed");
+          log33.warn({ err }, "ThinkingIndicator.show() failed");
         } finally {
           this.sending = false;
         }
@@ -8696,7 +8715,7 @@ var init_activity = __esm({
             this.tracer?.log("telegram", { action: "telegram:delete:overflow", sessionId: this.sessionId, msgId: staleId });
           }
         } catch (err) {
-          log32.warn({ err }, "[ToolCard] send/edit failed");
+          log33.warn({ err }, "[ToolCard] send/edit failed");
         }
       }
     };
@@ -8800,7 +8819,7 @@ var init_activity = __esm({
         const entry = this.toolStateMap.merge(id, status, rawInput, content, viewerLinks, diffStats);
         if (!existed || !entry) return;
         if (viewerLinks || entry.viewerLinks) {
-          log32.debug({ toolId: id, status, hasIncomingLinks: !!viewerLinks, hasEntryLinks: !!entry.viewerLinks, entryLinks: entry.viewerLinks }, "toolUpdate: viewer links trace");
+          log33.debug({ toolId: id, status, hasIncomingLinks: !!viewerLinks, hasEntryLinks: !!entry.viewerLinks, entryLinks: entry.viewerLinks }, "toolUpdate: viewer links trace");
         }
         const spec = this.specBuilder.buildToolSpec(entry, this._outputMode, this.sessionContext);
         this.toolCard.updateFromSpec(spec);
@@ -9119,13 +9138,13 @@ var init_draft_manager = __esm({
 });
 
 // src/plugins/telegram/skill-command-manager.ts
-var log33, SkillCommandManager;
+var log34, SkillCommandManager;
 var init_skill_command_manager = __esm({
   "src/plugins/telegram/skill-command-manager.ts"() {
     "use strict";
     init_commands();
     init_log();
-    log33 = createChildLogger({ module: "skill-commands" });
+    log34 = createChildLogger({ module: "skill-commands" });
     SkillCommandManager = class {
       // sessionId → pinned msgId
       constructor(bot, chatId, sendQueue, sessionManager) {
@@ -9191,7 +9210,7 @@ var init_skill_command_manager = __esm({
             disable_notification: true
           });
         } catch (err) {
-          log33.error({ err, sessionId }, "Failed to send skill commands");
+          log34.error({ err, sessionId }, "Failed to send skill commands");
         }
       }
       async cleanup(sessionId) {
@@ -9370,7 +9389,7 @@ async function validateBotAdmin(token, chatId) {
       };
     }
     const { status } = data.result;
-    log34.info(
+    log35.info(
       { status, can_manage_topics: data.result.can_manage_topics, raw_result: data.result },
       "validateBotAdmin: getChatMember raw result"
     );
@@ -9390,7 +9409,7 @@ async function validateBotAdmin(token, chatId) {
 }
 async function checkTopicsPrerequisites(token, chatId) {
   const issues = [];
-  log34.info({ chatId }, "checkTopicsPrerequisites: starting checks");
+  log35.info({ chatId }, "checkTopicsPrerequisites: starting checks");
   try {
     const res = await fetch(`https://api.telegram.org/bot${token}/getChat`, {
       method: "POST",
@@ -9398,7 +9417,7 @@ async function checkTopicsPrerequisites(token, chatId) {
       body: JSON.stringify({ chat_id: chatId })
     });
     const data = await res.json();
-    log34.info(
+    log35.info(
       { chatId, apiOk: data.ok, is_forum: data.result?.is_forum, type: data.result?.type, title: data.result?.title },
       "checkTopicsPrerequisites: getChat result"
     );
@@ -9408,11 +9427,11 @@ async function checkTopicsPrerequisites(token, chatId) {
       );
     }
   } catch (err) {
-    log34.warn({ err, chatId }, "checkTopicsPrerequisites: getChat failed (network error)");
+    log35.warn({ err, chatId }, "checkTopicsPrerequisites: getChat failed (network error)");
     issues.push("\u274C Could not check if Topics are enabled (network error).");
   }
   const adminResult = await validateBotAdmin(token, chatId);
-  log34.info(
+  log35.info(
     { chatId, adminOk: adminResult.ok, canManageTopics: adminResult.ok ? adminResult.canManageTopics : void 0, error: !adminResult.ok ? adminResult.error : void 0 },
     "checkTopicsPrerequisites: validateBotAdmin result"
   );
@@ -9426,16 +9445,16 @@ async function checkTopicsPrerequisites(token, chatId) {
       '\u274C Bot cannot manage topics.\n\u2192 In Admin settings, enable the "Manage Topics" permission'
     );
   }
-  log34.info({ chatId, issueCount: issues.length, ok: issues.length === 0 }, "checkTopicsPrerequisites: result");
+  log35.info({ chatId, issueCount: issues.length, ok: issues.length === 0 }, "checkTopicsPrerequisites: result");
   if (issues.length > 0) return { ok: false, issues };
   return { ok: true };
 }
-var log34;
+var log35;
 var init_validators = __esm({
   "src/plugins/telegram/validators.ts"() {
     "use strict";
     init_log();
-    log34 = createChildLogger({ module: "telegram-validators" });
+    log35 = createChildLogger({ module: "telegram-validators" });
   }
 });
 
@@ -9454,7 +9473,7 @@ function patchedFetch(input2, init) {
   }
   return fetch(input2, init);
 }
-var log35, TelegramAdapter;
+var log36, TelegramAdapter;
 var init_adapter = __esm({
   "src/plugins/telegram/adapter.ts"() {
     "use strict";
@@ -9474,7 +9493,7 @@ var init_adapter = __esm({
     init_messaging_adapter();
     init_renderer2();
     init_output_mode_resolver();
-    log35 = createChildLogger({ module: "telegram" });
+    log36 = createChildLogger({ module: "telegram" });
     TelegramAdapter = class extends MessagingAdapter {
       name = "telegram";
       renderer = new TelegramRenderer();
@@ -9601,7 +9620,7 @@ var init_adapter = __esm({
         );
         this.bot.catch((err) => {
           const rootCause = err.error instanceof Error ? err.error : err;
-          log35.error({ err: rootCause }, "Telegram bot error");
+          log36.error({ err: rootCause }, "Telegram bot error");
         });
         this.bot.api.config.use(async (prev, method, payload, signal) => {
           const maxRetries = 3;
@@ -9619,7 +9638,7 @@ var init_adapter = __esm({
             if (rateLimitedMethods.includes(method)) {
               this.sendQueue.onRateLimited();
             }
-            log35.warn(
+            log36.warn(
               { method, retryAfter, attempt: attempt + 1 },
               "Rate limited by Telegram, retrying"
             );
@@ -9807,9 +9826,9 @@ ${p}` : p;
         this.setupRoutes();
         this.bot.start({
           allowed_updates: ["message", "callback_query"],
-          onStart: () => log35.info({ chatId: this.telegramConfig.chatId }, "Telegram bot started")
+          onStart: () => log36.info({ chatId: this.telegramConfig.chatId }, "Telegram bot started")
         });
-        log35.info(
+        log36.info(
           {
             chatId: this.telegramConfig.chatId,
             notificationTopicId: this.telegramConfig.notificationTopicId,
@@ -9823,12 +9842,12 @@ ${p}` : p;
           this.telegramConfig.chatId
         );
         if (prereqResult.ok) {
-          log35.info("Telegram adapter: prerequisites OK, initializing topic-dependent features");
+          log36.info("Telegram adapter: prerequisites OK, initializing topic-dependent features");
           await this.initTopicDependentFeatures();
         } else {
-          log35.warn({ issues: prereqResult.issues }, "Telegram adapter: prerequisites NOT met, starting watcher");
+          log36.warn({ issues: prereqResult.issues }, "Telegram adapter: prerequisites NOT met, starting watcher");
           for (const issue of prereqResult.issues) {
-            log35.warn({ issue }, "Telegram prerequisite not met");
+            log36.warn({ issue }, "Telegram prerequisite not met");
           }
           this.startPrerequisiteWatcher(prereqResult.issues);
         }
@@ -9844,7 +9863,7 @@ ${p}` : p;
           } catch (err) {
             if (attempt === maxRetries) throw err;
             const delay = baseDelayMs * Math.pow(2, attempt - 1);
-            log35.warn(
+            log36.warn(
               { err, attempt, maxRetries, delayMs: delay, operation: label },
               `${label} failed, retrying in ${delay}ms`
             );
@@ -9864,12 +9883,12 @@ ${p}` : p;
           }),
           "setMyCommands"
         ).catch((err) => {
-          log35.warn({ err }, "Failed to register Telegram commands after retries (non-critical)");
+          log36.warn({ err }, "Failed to register Telegram commands after retries (non-critical)");
         });
       }
       async initTopicDependentFeatures() {
         if (this._topicsInitialized) return;
-        log35.info(
+        log36.info(
           { notificationTopicId: this.telegramConfig.notificationTopicId, assistantTopicId: this.telegramConfig.assistantTopicId },
           "initTopicDependentFeatures: starting (existing IDs in config)"
         );
@@ -9894,7 +9913,7 @@ ${p}` : p;
         this.assistantTopicId = topics.assistantTopicId;
         this._systemTopicIds.notificationTopicId = topics.notificationTopicId;
         this._systemTopicIds.assistantTopicId = topics.assistantTopicId;
-        log35.info(
+        log36.info(
           { notificationTopicId: this.notificationTopicId, assistantTopicId: this.assistantTopicId },
           "initTopicDependentFeatures: topics ready"
         );
@@ -9925,7 +9944,7 @@ ${p}` : p;
           ).then((msg) => {
             if (msg) this.storeControlMsgId(sessionId, msg.message_id);
           }).catch((err) => {
-            log35.warn({ err, sessionId }, "Failed to send initial messages for new session");
+            log36.warn({ err, sessionId }, "Failed to send initial messages for new session");
           });
         };
         this.core.eventBus.on(BusEvent.SESSION_THREAD_READY, this._threadReadyHandler);
@@ -9934,7 +9953,7 @@ ${p}` : p;
           });
         };
         this.core.eventBus.on("session:configChanged", this._configChangedHandler);
-        log35.info({ assistantTopicId: this.assistantTopicId }, "initTopicDependentFeatures: sending welcome message");
+        log36.info({ assistantTopicId: this.assistantTopicId }, "initTopicDependentFeatures: sending welcome message");
         try {
           const config = this.core.configManager.get();
           const agents = this.core.agentManager.getAvailableAgents();
@@ -9956,17 +9975,17 @@ ${p}` : p;
               this.core.lifecycleManager?.serviceRegistry?.get("menu-registry")
             )
           });
-          log35.info("initTopicDependentFeatures: welcome message sent");
+          log36.info("initTopicDependentFeatures: welcome message sent");
         } catch (err) {
-          log35.warn({ err }, "Failed to send welcome message");
+          log36.warn({ err }, "Failed to send welcome message");
         }
         try {
           await this.core.assistantManager.getOrSpawn("telegram", String(this.assistantTopicId));
         } catch (err) {
-          log35.error({ err }, "Failed to spawn assistant");
+          log36.error({ err }, "Failed to spawn assistant");
         }
         this._topicsInitialized = true;
-        log35.info("Telegram adapter fully initialized");
+        log36.info("Telegram adapter fully initialized");
       }
       startPrerequisiteWatcher(issues) {
         const setupMessage = `\u26A0\uFE0F <b>OpenACP needs setup before it can start.</b>
@@ -9977,7 +9996,7 @@ OpenACP will automatically retry until this is resolved.`;
         this.bot.api.sendMessage(this.telegramConfig.chatId, setupMessage, {
           parse_mode: "HTML"
         }).catch((err) => {
-          log35.warn({ err }, "Failed to send setup guidance to General topic");
+          log36.warn({ err }, "Failed to send setup guidance to General topic");
         });
         const schedule = [5e3, 1e4, 3e4];
         let attempt = 1;
@@ -9990,7 +10009,7 @@ OpenACP will automatically retry until this is resolved.`;
           );
           if (result.ok) {
             this._prerequisiteWatcher = null;
-            log35.info("Prerequisites met \u2014 completing Telegram adapter initialization");
+            log36.info("Prerequisites met \u2014 completing Telegram adapter initialization");
             try {
               await this.initTopicDependentFeatures();
               await this.bot.api.sendMessage(
@@ -9999,11 +10018,11 @@ OpenACP will automatically retry until this is resolved.`;
                 { parse_mode: "HTML" }
               );
             } catch (err) {
-              log35.error({ err }, "Failed to complete initialization after prerequisites met");
+              log36.error({ err }, "Failed to complete initialization after prerequisites met");
             }
             return;
           }
-          log35.debug({ issues: result.issues }, "Prerequisites not yet met, retrying");
+          log36.debug({ issues: result.issues }, "Prerequisites not yet met, retrying");
           const delay = schedule[Math.min(attempt, schedule.length - 1)];
           attempt++;
           this._prerequisiteWatcher = setTimeout(retry, delay);
@@ -10029,7 +10048,7 @@ OpenACP will automatically retry until this is resolved.`;
         }
         this.sendQueue.clear();
         await this.bot.stop();
-        log35.info("Telegram bot stopped");
+        log36.info("Telegram bot stopped");
       }
       // --- CommandRegistry response rendering ---
       async renderCommandResponse(response, chatId, topicId) {
@@ -10153,7 +10172,7 @@ ${lines.join("\n")}`;
             threadId: String(threadId),
             userId: String(ctx.from.id),
             text: forwardText
-          }).catch((err) => log35.error({ err }, "handleMessage error"));
+          }).catch((err) => log36.error({ err }, "handleMessage error"));
         });
         this.bot.on("message:photo", async (ctx) => {
           const threadId = ctx.message.message_thread_id;
@@ -10242,7 +10261,7 @@ ${lines.join("\n")}`;
         if (session.archiving) return;
         const threadId = Number(session.threadId);
         if (!threadId || isNaN(threadId)) {
-          log35.warn(
+          log36.warn(
             { sessionId, threadId: session.threadId },
             "Session has no valid threadId, skipping message"
           );
@@ -10258,7 +10277,7 @@ ${lines.join("\n")}`;
             this._sessionThreadIds.delete(sessionId);
           }
         }).catch((err) => {
-          log35.warn({ err, sessionId }, "Dispatch queue error");
+          log36.warn({ err, sessionId }, "Dispatch queue error");
         });
         this._dispatchQueues.set(sessionId, next);
         await next;
@@ -10380,7 +10399,7 @@ ${lines.join("\n")}`;
           );
           usageMsgId = result?.message_id;
         } catch (err) {
-          log35.warn({ err, sessionId }, "Failed to send usage message");
+          log36.warn({ err, sessionId }, "Failed to send usage message");
         }
         if (this.notificationTopicId && sessionId !== this.core.assistantManager?.get("telegram")?.id) {
           const sess = this.core.sessionManager.getSession(sessionId);
@@ -10408,7 +10427,7 @@ Task completed.
         if (!content.attachment) return;
         const { attachment } = content;
         if (attachment.size > 50 * 1024 * 1024) {
-          log35.warn(
+          log36.warn(
             {
               sessionId,
               fileName: attachment.fileName,
@@ -10452,7 +10471,7 @@ Task completed.
             );
           }
         } catch (err) {
-          log35.error(
+          log36.error(
             { err, sessionId, fileName: attachment.fileName },
             "Failed to send attachment"
           );
@@ -10551,7 +10570,7 @@ Task completed.
       }
       async sendPermissionRequest(sessionId, request) {
         this.getTracer(sessionId)?.log("telegram", { action: "permission:send", sessionId, requestId: request.id, description: request.description });
-        log35.info({ sessionId, requestId: request.id }, "Permission request sent");
+        log36.info({ sessionId, requestId: request.id }, "Permission request sent");
         const session = this.core.sessionManager.getSession(sessionId);
         if (!session) return;
         await this.sendQueue.enqueue(
@@ -10561,7 +10580,7 @@ Task completed.
       async sendNotification(notification) {
         this.getTracer(notification.sessionId)?.log("telegram", { action: "notification:send", sessionId: notification.sessionId, type: notification.type });
         if (notification.sessionId === this.core.assistantManager?.get("telegram")?.id) return;
-        log35.info(
+        log36.info(
           { sessionId: notification.sessionId, type: notification.type },
           "Notification sent"
         );
@@ -10600,7 +10619,7 @@ Task completed.
       }
       async createSessionThread(sessionId, name) {
         this.getTracer(sessionId)?.log("telegram", { action: "thread:create", sessionId, name });
-        log35.info({ sessionId, name }, "Session topic created");
+        log36.info({ sessionId, name }, "Session topic created");
         return String(
           await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
         );
@@ -10611,7 +10630,7 @@ Task completed.
         if (!session) return;
         const threadId = Number(session.threadId);
         if (!threadId) {
-          log35.debug({ sessionId, newName }, "Cannot rename thread \u2014 threadId not set yet");
+          log36.debug({ sessionId, newName }, "Cannot rename thread \u2014 threadId not set yet");
           return;
         }
         await renameSessionTopic(
@@ -10630,7 +10649,7 @@ Task completed.
         try {
           await this.bot.api.deleteForumTopic(this.telegramConfig.chatId, topicId);
         } catch (err) {
-          log35.warn(
+          log36.warn(
             { err, sessionId, topicId },
             "Failed to delete forum topic (may already be deleted)"
           );
@@ -10674,7 +10693,7 @@ Task completed.
           const buffer = Buffer.from(await response.arrayBuffer());
           return { buffer, filePath: file.file_path };
         } catch (err) {
-          log35.error({ err }, "Failed to download file from Telegram");
+          log36.error({ err }, "Failed to download file from Telegram");
           return null;
         }
       }
@@ -10695,7 +10714,7 @@ Task completed.
           try {
             buffer = await this.fileService.convertOggToWav(buffer);
           } catch (err) {
-            log35.warn({ err }, "OGG\u2192WAV conversion failed, saving original OGG");
+            log36.warn({ err }, "OGG\u2192WAV conversion failed, saving original OGG");
             fileName = "voice.ogg";
             mimeType = "audio/ogg";
             originalFilePath = void 0;
@@ -10727,7 +10746,7 @@ Task completed.
           userId: String(userId),
           text: text3,
           attachments: [att]
-        }).catch((err) => log35.error({ err }, "handleMessage error"));
+        }).catch((err) => log36.error({ err }, "handleMessage error"));
       }
       async cleanupSkillCommands(sessionId) {
         this._pendingSkillCommands.delete(sessionId);
@@ -10863,13 +10882,13 @@ init_config();
 // src/core/agents/agent-instance.ts
 import { spawn as spawn2, execFileSync } from "child_process";
 import { Transform } from "stream";
-import fs8 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path6 from "path";
 import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
 
 // src/core/security/path-guard.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import ignore from "ignore";
 var DEFAULT_DENY_PATTERNS = [
   ".env",
@@ -10889,15 +10908,15 @@ var PathGuard = class {
   ig;
   constructor(options) {
     try {
-      this.cwd = fs5.realpathSync(path5.resolve(options.cwd));
+      this.cwd = fs4.realpathSync(path4.resolve(options.cwd));
     } catch {
-      this.cwd = path5.resolve(options.cwd);
+      this.cwd = path4.resolve(options.cwd);
     }
     this.allowedPaths = options.allowedPaths.map((p) => {
       try {
-        return fs5.realpathSync(path5.resolve(p));
+        return fs4.realpathSync(path4.resolve(p));
       } catch {
-        return path5.resolve(p);
+        return path4.resolve(p);
       }
     });
     this.ig = ignore();
@@ -10907,19 +10926,19 @@ var PathGuard = class {
     }
   }
   validatePath(targetPath, operation) {
-    const resolved = path5.resolve(targetPath);
+    const resolved = path4.resolve(targetPath);
     let realPath;
     try {
-      realPath = fs5.realpathSync(resolved);
+      realPath = fs4.realpathSync(resolved);
     } catch {
       realPath = resolved;
     }
-    if (operation === "write" && path5.basename(realPath) === ".openacpignore") {
+    if (operation === "write" && path4.basename(realPath) === ".openacpignore") {
       return { allowed: false, reason: "Cannot write to .openacpignore" };
     }
-    const isWithinCwd = realPath === this.cwd || realPath.startsWith(this.cwd + path5.sep);
+    const isWithinCwd = realPath === this.cwd || realPath.startsWith(this.cwd + path4.sep);
     const isWithinAllowed = this.allowedPaths.some(
-      (ap) => realPath === ap || realPath.startsWith(ap + path5.sep)
+      (ap) => realPath === ap || realPath.startsWith(ap + path4.sep)
     );
     if (!isWithinCwd && !isWithinAllowed) {
       return {
@@ -10928,7 +10947,7 @@ var PathGuard = class {
       };
     }
     if (isWithinCwd && !isWithinAllowed) {
-      const relativePath = path5.relative(this.cwd, realPath);
+      const relativePath = path4.relative(this.cwd, realPath);
       if (relativePath === ".openacpignore") {
         return { allowed: true, reason: "" };
       }
@@ -10943,15 +10962,15 @@ var PathGuard = class {
   }
   addAllowedPath(p) {
     try {
-      this.allowedPaths.push(fs5.realpathSync(path5.resolve(p)));
+      this.allowedPaths.push(fs4.realpathSync(path4.resolve(p)));
     } catch {
-      this.allowedPaths.push(path5.resolve(p));
+      this.allowedPaths.push(path4.resolve(p));
     }
   }
   static loadIgnoreFile(cwd) {
-    const ignorePath = path5.join(cwd, ".openacpignore");
+    const ignorePath = path4.join(cwd, ".openacpignore");
     try {
-      const content = fs5.readFileSync(ignorePath, "utf-8");
+      const content = fs4.readFileSync(ignorePath, "utf-8");
       return content.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
     } catch {
       return [];
@@ -11292,24 +11311,24 @@ var McpManager = class {
 };
 
 // src/core/utils/debug-tracer.ts
-import fs7 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path5 from "path";
 var DEBUG_ENABLED = process.env.OPENACP_DEBUG === "true" || process.env.OPENACP_DEBUG === "1";
 var DebugTracer = class {
   constructor(sessionId, workingDirectory) {
     this.sessionId = sessionId;
     this.workingDirectory = workingDirectory;
-    this.logDir = path6.join(workingDirectory, ".log");
+    this.logDir = path5.join(workingDirectory, ".log");
   }
   dirCreated = false;
   logDir;
   log(layer, data) {
     try {
       if (!this.dirCreated) {
-        fs7.mkdirSync(this.logDir, { recursive: true });
+        fs6.mkdirSync(this.logDir, { recursive: true });
         this.dirCreated = true;
       }
-      const filePath = path6.join(this.logDir, `${this.sessionId}_${layer}.jsonl`);
+      const filePath = path5.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) {
@@ -11318,7 +11337,7 @@ var DebugTracer = class {
         }
         return value;
       }) + "\n";
-      fs7.appendFileSync(filePath, line);
+      fs6.appendFileSync(filePath, line);
     } catch {
     }
   }
@@ -11337,11 +11356,11 @@ init_events();
 var log4 = createChildLogger({ module: "agent-instance" });
 function findPackageRoot(startDir) {
   let dir = startDir;
-  while (dir !== path7.dirname(dir)) {
-    if (fs8.existsSync(path7.join(dir, "package.json"))) {
+  while (dir !== path6.dirname(dir)) {
+    if (fs7.existsSync(path6.join(dir, "package.json"))) {
       return dir;
     }
-    dir = path7.dirname(dir);
+    dir = path6.dirname(dir);
   }
   return startDir;
 }
@@ -11353,26 +11372,26 @@ function resolveAgentCommand(cmd) {
   }
   for (const root of searchRoots) {
     const packageDirs = [
-      path7.resolve(root, "node_modules", "@zed-industries", cmd, "dist", "index.js"),
-      path7.resolve(root, "node_modules", cmd, "dist", "index.js")
+      path6.resolve(root, "node_modules", "@zed-industries", cmd, "dist", "index.js"),
+      path6.resolve(root, "node_modules", cmd, "dist", "index.js")
     ];
     for (const jsPath of packageDirs) {
-      if (fs8.existsSync(jsPath)) {
+      if (fs7.existsSync(jsPath)) {
         return { command: process.execPath, args: [jsPath] };
       }
     }
   }
   for (const root of searchRoots) {
-    const localBin = path7.resolve(root, "node_modules", ".bin", cmd);
-    if (fs8.existsSync(localBin)) {
-      const content = fs8.readFileSync(localBin, "utf-8");
+    const localBin = path6.resolve(root, "node_modules", ".bin", cmd);
+    if (fs7.existsSync(localBin)) {
+      const content = fs7.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 = path7.resolve(path7.dirname(localBin), match[1]);
-        if (fs8.existsSync(target)) {
+        const target = path6.resolve(path6.dirname(localBin), match[1]);
+        if (fs7.existsSync(target)) {
           return { command: process.execPath, args: [target] };
         }
       }
@@ -11382,7 +11401,7 @@ function resolveAgentCommand(cmd) {
     const fullPath = execFileSync("which", [cmd], { encoding: "utf-8" }).trim();
     if (fullPath) {
       try {
-        const content = fs8.readFileSync(fullPath, "utf-8");
+        const content = fs7.readFileSync(fullPath, "utf-8");
         if (content.startsWith("#!/usr/bin/env node")) {
           return { command: process.execPath, args: [fullPath] };
         }
@@ -11401,16 +11420,16 @@ function resolveAgentCommand(cmd) {
         candidates.push(dir);
       }
     };
-    addCandidate(path7.dirname(process.execPath));
+    addCandidate(path6.dirname(process.execPath));
     try {
-      addCandidate(path7.dirname(fs8.realpathSync(process.execPath)));
+      addCandidate(path6.dirname(fs7.realpathSync(process.execPath)));
     } catch {
     }
     addCandidate("/opt/homebrew/bin");
     addCandidate("/usr/local/bin");
     for (const dir of candidates) {
-      const candidate = path7.join(dir, cmd);
-      if (fs8.existsSync(candidate)) {
+      const candidate = path6.join(dir, cmd);
+      if (fs7.existsSync(candidate)) {
         log4.info({ cmd, resolved: candidate }, "Resolved package runner from fallback search");
         return { command: candidate, args: [] };
       }
@@ -11577,10 +11596,11 @@ ${stderr}`
       allowedPaths
     );
     const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
-    const response = await instance.connection.newSession({
-      cwd: workingDirectory,
-      mcpServers: resolvedMcp
-    });
+    const response = await withAgentTimeout(
+      instance.connection.newSession({ cwd: workingDirectory, mcpServers: resolvedMcp }),
+      agentDef.name,
+      "newSession"
+    );
     log4.info(response, "newSession response");
     instance.sessionId = response.sessionId;
     instance.initialSessionResponse = response;
@@ -11608,11 +11628,11 @@ ${stderr}`
     const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
     try {
       if (instance.agentCapabilities?.loadSession) {
-        const response = await instance.connection.loadSession({
-          sessionId: agentSessionId,
-          cwd: workingDirectory,
-          mcpServers: resolvedMcp
-        });
+        const response = await withAgentTimeout(
+          instance.connection.loadSession({ sessionId: agentSessionId, cwd: workingDirectory, mcpServers: resolvedMcp }),
+          agentDef.name,
+          "loadSession"
+        );
         instance.sessionId = agentSessionId;
         instance.initialSessionResponse = response;
         instance.debugTracer = createDebugTracer(agentSessionId, workingDirectory);
@@ -11625,10 +11645,11 @@ ${stderr}`
           "Agent load complete"
         );
       } else {
-        const response = await instance.connection.unstable_resumeSession({
-          sessionId: agentSessionId,
-          cwd: workingDirectory
-        });
+        const response = await withAgentTimeout(
+          instance.connection.unstable_resumeSession({ sessionId: agentSessionId, cwd: workingDirectory }),
+          agentDef.name,
+          "resumeSession"
+        );
         instance.sessionId = response.sessionId;
         instance.initialSessionResponse = response;
         instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
@@ -11646,10 +11667,11 @@ ${stderr}`
         { err, agentSessionId },
         "Resume failed, falling back to new session"
       );
-      const response = await instance.connection.newSession({
-        cwd: workingDirectory,
-        mcpServers: resolvedMcp
-      });
+      const response = await withAgentTimeout(
+        instance.connection.newSession({ cwd: workingDirectory, mcpServers: resolvedMcp }),
+        agentDef.name,
+        "newSession (fallback)"
+      );
       instance.sessionId = response.sessionId;
       instance.initialSessionResponse = response;
       instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
@@ -11841,8 +11863,8 @@ ${stderr}`
           writePath = result.path;
           writeContent = result.content;
         }
-        await fs8.promises.mkdir(path7.dirname(writePath), { recursive: true });
-        await fs8.promises.writeFile(writePath, writeContent, "utf-8");
+        await fs7.promises.mkdir(path6.dirname(writePath), { recursive: true });
+        await fs7.promises.writeFile(writePath, writeContent, "utf-8");
         return {};
       },
       // ── Terminal operations (delegated to TerminalManager) ─────────────
@@ -11950,7 +11972,7 @@ ${skipNote}`;
 [Attachment access denied: ${attCheck.reason}]`;
           continue;
         }
-        const data = await fs8.promises.readFile(att.filePath);
+        const data = await fs7.promises.readFile(att.filePath);
         contentBlocks.push({ type: "image", data: data.toString("base64"), mimeType: att.mimeType });
       } else if (att.type === "audio" && capabilities.audio) {
         const attCheck = this.pathGuard.validatePath(att.filePath, "read");
@@ -11960,7 +11982,7 @@ ${skipNote}`;
 [Attachment access denied: ${attCheck.reason}]`;
           continue;
         }
-        const data = await fs8.promises.readFile(att.filePath);
+        const data = await fs7.promises.readFile(att.filePath);
         contentBlocks.push({ type: "audio", data: data.toString("base64"), mimeType: att.mimeType });
       } else {
         if (att.type === "image" || att.type === "audio") {
@@ -12003,6 +12025,26 @@ ${skipNote}`;
     });
   }
 };
+var AGENT_INIT_TIMEOUT_MS = 3e4;
+function withAgentTimeout(promise, agentName, op) {
+  return new Promise((resolve7, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(
+        `Agent "${agentName}" did not respond to ${op} within ${AGENT_INIT_TIMEOUT_MS / 1e3}s. The agent process may have hung during initialization.`
+      ));
+    }, AGENT_INIT_TIMEOUT_MS);
+    promise.then(
+      (val) => {
+        clearTimeout(timer);
+        resolve7(val);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
 
 // src/core/agents/agent-manager.ts
 var AgentManager = class {
@@ -12174,7 +12216,7 @@ var PermissionGate = class {
 
 // src/core/sessions/session.ts
 init_log();
-import * as fs9 from "fs";
+import * as fs8 from "fs";
 
 // src/core/sessions/turn-context.ts
 import { nanoid } from "nanoid";
@@ -12500,7 +12542,7 @@ ${text3}`;
       try {
         const audioPath = att.originalFilePath || att.filePath;
         const audioMime = att.originalFilePath ? "audio/ogg" : att.mimeType;
-        const audioBuffer = await fs9.promises.readFile(audioPath);
+        const audioBuffer = await fs8.promises.readFile(audioPath);
         const result = await this.speechService.transcribe(audioBuffer, audioMime);
         this.log.info({ provider: "stt", duration: result.duration }, "Voice transcribed");
         this.emit(SessionEv.AGENT_EVENT, {
@@ -12731,7 +12773,7 @@ ${result.text}` : result.text;
 };
 
 // src/core/message-transformer.ts
-import * as path8 from "path";
+import * as path7 from "path";
 
 // src/core/utils/extract-file-info.ts
 init_apply_patch_detection();
@@ -13185,7 +13227,7 @@ var MessageTransformer = class {
       );
       return;
     }
-    const fileExt = path8.extname(fileInfo.filePath).toLowerCase();
+    const fileExt = path7.extname(fileInfo.filePath).toLowerCase();
     if (BINARY_VIEWER_EXTENSIONS.has(fileExt)) {
       log5.debug({ kind, filePath: fileInfo.filePath }, "enrichWithViewerLinks: skipping binary file");
       return;
@@ -13694,12 +13736,12 @@ var SessionBridge = class {
         break;
       case "image_content": {
         if (this.deps.fileService) {
-          const fs33 = this.deps.fileService;
+          const fs35 = this.deps.fileService;
           const sid = this.session.id;
           const { data, mimeType } = event;
           const buffer = Buffer.from(data, "base64");
-          const ext = fs33.extensionFromMime(mimeType);
-          fs33.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
+          const ext = fs35.extensionFromMime(mimeType);
+          fs35.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
             this.sendMessage(sid, {
               type: "attachment",
               text: "",
@@ -13711,12 +13753,12 @@ var SessionBridge = class {
       }
       case "audio_content": {
         if (this.deps.fileService) {
-          const fs33 = this.deps.fileService;
+          const fs35 = this.deps.fileService;
           const sid = this.session.id;
           const { data, mimeType } = event;
           const buffer = Buffer.from(data, "base64");
-          const ext = fs33.extensionFromMime(mimeType);
-          fs33.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
+          const ext = fs35.extensionFromMime(mimeType);
+          fs35.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
             this.sendMessage(sid, {
               type: "attachment",
               text: "",
@@ -14268,14 +14310,13 @@ var SessionFactory = class {
 };
 
 // src/core/core.ts
-import path16 from "path";
-import os8 from "os";
+import path14 from "path";
 import { nanoid as nanoid3 } from "nanoid";
 
 // src/core/sessions/session-store.ts
 init_log();
-import fs10 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path8 from "path";
 var log8 = createChildLogger({ module: "session-store" });
 var DEBOUNCE_MS = 2e3;
 var JsonFileSessionStore = class {
@@ -14357,9 +14398,9 @@ var JsonFileSessionStore = class {
       version: 1,
       sessions: Object.fromEntries(this.records)
     };
-    const dir = path9.dirname(this.filePath);
-    if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
-    fs10.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+    const dir = path8.dirname(this.filePath);
+    if (!fs9.existsSync(dir)) fs9.mkdirSync(dir, { recursive: true });
+    fs9.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
   }
   destroy() {
     if (this.debounceTimer) clearTimeout(this.debounceTimer);
@@ -14372,10 +14413,10 @@ var JsonFileSessionStore = class {
     }
   }
   load() {
-    if (!fs10.existsSync(this.filePath)) return;
+    if (!fs9.existsSync(this.filePath)) return;
     try {
       const raw = JSON.parse(
-        fs10.readFileSync(this.filePath, "utf-8")
+        fs9.readFileSync(this.filePath, "utf-8")
       );
       if (raw.version !== 1) {
         log8.warn(
@@ -14391,7 +14432,7 @@ var JsonFileSessionStore = class {
     } catch (err) {
       log8.error({ err }, "Failed to load session store, backing up corrupt file");
       try {
-        fs10.renameSync(this.filePath, `${this.filePath}.bak`);
+        fs9.renameSync(this.filePath, `${this.filePath}.bak`);
       } catch {
       }
     }
@@ -14625,120 +14666,34 @@ var AgentSwitchHandler = class {
   }
 };
 
-// src/core/agents/agent-catalog.ts
-import * as fs14 from "fs";
-import * as path13 from "path";
-import * as os6 from "os";
-
-// src/core/agents/agent-store.ts
-init_log();
-import * as fs12 from "fs";
-import * as path11 from "path";
-import * as os4 from "os";
-import { z as z2 } from "zod";
-var log10 = createChildLogger({ module: "agent-store" });
-var InstalledAgentSchema = z2.object({
-  registryId: z2.string().nullable(),
-  name: z2.string(),
-  version: z2.string(),
-  distribution: z2.enum(["npx", "uvx", "binary", "custom"]),
-  command: z2.string(),
-  args: z2.array(z2.string()).default([]),
-  env: z2.record(z2.string(), z2.string()).default({}),
-  workingDirectory: z2.string().optional(),
-  installedAt: z2.string(),
-  binaryPath: z2.string().nullable().default(null)
-});
-var AgentStoreSchema = z2.object({
-  version: z2.number().default(1),
-  installed: z2.record(z2.string(), InstalledAgentSchema).default({})
-});
-var AgentStore = class {
-  data = { version: 1, installed: {} };
-  filePath;
-  constructor(filePath) {
-    this.filePath = filePath ?? path11.join(os4.homedir(), ".openacp", "agents.json");
-  }
-  load() {
-    if (!fs12.existsSync(this.filePath)) {
-      this.data = { version: 1, installed: {} };
-      return;
-    }
-    try {
-      const raw = JSON.parse(fs12.readFileSync(this.filePath, "utf-8"));
-      const result = AgentStoreSchema.safeParse(raw);
-      if (result.success) {
-        this.data = result.data;
-      } else {
-        log10.warn({ errors: result.error.issues }, "Invalid agents.json, starting fresh");
-        this.data = { version: 1, installed: {} };
-      }
-    } catch (err) {
-      log10.warn({ err }, "Failed to read agents.json, starting fresh");
-      this.data = { version: 1, installed: {} };
-    }
-  }
-  exists() {
-    return fs12.existsSync(this.filePath);
-  }
-  getInstalled() {
-    return this.data.installed;
-  }
-  getAgent(key) {
-    return this.data.installed[key];
-  }
-  addAgent(key, agent) {
-    this.data.installed[key] = agent;
-    this.save();
-  }
-  removeAgent(key) {
-    delete this.data.installed[key];
-    this.save();
-  }
-  hasAgent(key) {
-    return key in this.data.installed;
-  }
-  save() {
-    fs12.mkdirSync(path11.dirname(this.filePath), { recursive: true });
-    const tmpPath = this.filePath + ".tmp";
-    fs12.writeFileSync(tmpPath, JSON.stringify(this.data, null, 2), { mode: 384 });
-    fs12.renameSync(tmpPath, this.filePath);
-  }
-};
-
 // src/core/agents/agent-catalog.ts
 init_agent_installer();
 init_agent_dependencies();
 init_log();
-var log12 = createChildLogger({ module: "agent-catalog" });
+import * as fs12 from "fs";
+import * as path11 from "path";
+var log11 = createChildLogger({ module: "agent-catalog" });
 var REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
 var DEFAULT_TTL_HOURS = 24;
 var AgentCatalog = class {
   store;
-  globalStore = null;
   registryAgents = [];
   cachePath;
   agentsDir;
   constructor(store, cachePath, agentsDir) {
-    this.store = store ?? new AgentStore();
-    this.cachePath = cachePath ?? path13.join(os6.homedir(), ".openacp", "registry-cache.json");
+    this.store = store;
+    this.cachePath = cachePath;
     this.agentsDir = agentsDir;
-    const globalPath = path13.join(os6.homedir(), ".openacp", "agents.json");
-    const storePath = this.store.filePath;
-    if (path13.resolve(storePath) !== path13.resolve(globalPath)) {
-      this.globalStore = new AgentStore(globalPath);
-    }
   }
   load() {
     this.store.load();
-    this.globalStore?.load();
     this.loadRegistryFromCacheOrSnapshot();
     this.enrichInstalledFromRegistry();
   }
   // --- Registry ---
   async fetchRegistry() {
     try {
-      log12.info("Fetching agent registry from CDN...");
+      log11.info("Fetching agent registry from CDN...");
       const response = await fetch(REGISTRY_URL);
       if (!response.ok) throw new Error(`HTTP ${response.status}`);
       const data = await response.json();
@@ -14748,11 +14703,11 @@ var AgentCatalog = class {
         ttlHours: DEFAULT_TTL_HOURS,
         data
       };
-      fs14.mkdirSync(path13.dirname(this.cachePath), { recursive: true });
-      fs14.writeFileSync(this.cachePath, JSON.stringify(cache, null, 2), { mode: 384 });
-      log12.info({ count: this.registryAgents.length }, "Registry updated");
+      fs12.mkdirSync(path11.dirname(this.cachePath), { recursive: true });
+      fs12.writeFileSync(this.cachePath, JSON.stringify(cache, null, 2), { mode: 384 });
+      log11.info({ count: this.registryAgents.length }, "Registry updated");
     } catch (err) {
-      log12.warn({ err }, "Failed to fetch registry, using cached data");
+      log11.warn({ err }, "Failed to fetch registry, using cached data");
     }
   }
   async refreshRegistryIfStale() {
@@ -14771,16 +14726,15 @@ var AgentCatalog = class {
     if (byId) return byId;
     return this.registryAgents.find((a) => getAgentAlias(a.id) === keyOrId);
   }
-  // --- Installed (instance-first, global-fallback) ---
+  // --- Installed ---
   getInstalled() {
-    const merged = { ...this.globalStore?.getInstalled(), ...this.store.getInstalled() };
-    return Object.values(merged);
+    return Object.values(this.store.getInstalled());
   }
   getInstalledEntries() {
-    return { ...this.globalStore?.getInstalled(), ...this.store.getInstalled() };
+    return this.store.getInstalled();
   }
   getInstalledAgent(key) {
-    return this.store.getAgent(key) ?? this.globalStore?.getAgent(key);
+    return this.store.getAgent(key);
   }
   // --- Discovery ---
   getAvailable() {
@@ -14862,14 +14816,11 @@ var AgentCatalog = class {
       await uninstallAgent(key, this.store);
       return { ok: true };
     }
-    if (this.globalStore?.getAgent(key)) {
-      return { ok: false, error: `"${key}" is installed globally. Uninstall it from the global instance instead.` };
-    }
     return { ok: false, error: `"${key}" is not installed.` };
   }
   // --- Resolution (for AgentManager) ---
   resolve(key) {
-    const agent = this.store.getAgent(key) ?? this.globalStore?.getAgent(key);
+    const agent = this.store.getAgent(key);
     if (!agent) return void 0;
     return {
       name: key,
@@ -14908,7 +14859,15 @@ var AgentCatalog = class {
         const dist = resolveDistribution(regAgent);
         if (dist) {
           agent.distribution = dist.type;
-          updated = true;
+          if (dist.type === "npx") {
+            agent.command = "npx";
+            agent.args = [stripNpmVersion(dist.package), ...dist.args];
+            updated = true;
+          } else if (dist.type === "uvx") {
+            agent.command = "uvx";
+            agent.args = [stripPythonVersion(dist.package), ...dist.args];
+            updated = true;
+          }
         }
       }
       if (updated) {
@@ -14917,13 +14876,13 @@ var AgentCatalog = class {
       }
     }
     if (changed) {
-      log12.info("Enriched installed agents with registry data");
+      log11.info("Enriched installed agents with registry data");
     }
   }
   isCacheStale() {
-    if (!fs14.existsSync(this.cachePath)) return true;
+    if (!fs12.existsSync(this.cachePath)) return true;
     try {
-      const raw = JSON.parse(fs14.readFileSync(this.cachePath, "utf-8"));
+      const raw = JSON.parse(fs12.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;
@@ -14932,37 +14891,128 @@ var AgentCatalog = class {
     }
   }
   loadRegistryFromCacheOrSnapshot() {
-    if (fs14.existsSync(this.cachePath)) {
+    if (fs12.existsSync(this.cachePath)) {
       try {
-        const raw = JSON.parse(fs14.readFileSync(this.cachePath, "utf-8"));
+        const raw = JSON.parse(fs12.readFileSync(this.cachePath, "utf-8"));
         if (raw.data?.agents) {
           this.registryAgents = raw.data.agents;
-          log12.debug({ count: this.registryAgents.length }, "Loaded registry from cache");
+          log11.debug({ count: this.registryAgents.length }, "Loaded registry from cache");
           return;
         }
       } catch {
-        log12.warn("Failed to load registry cache");
+        log11.warn("Failed to load registry cache");
       }
     }
     try {
       const candidates = [
-        path13.join(import.meta.dirname, "data", "registry-snapshot.json"),
-        path13.join(import.meta.dirname, "..", "data", "registry-snapshot.json"),
-        path13.join(import.meta.dirname, "..", "..", "data", "registry-snapshot.json")
+        path11.join(import.meta.dirname, "data", "registry-snapshot.json"),
+        path11.join(import.meta.dirname, "..", "data", "registry-snapshot.json"),
+        path11.join(import.meta.dirname, "..", "..", "data", "registry-snapshot.json")
       ];
       for (const candidate of candidates) {
-        if (fs14.existsSync(candidate)) {
-          const raw = JSON.parse(fs14.readFileSync(candidate, "utf-8"));
+        if (fs12.existsSync(candidate)) {
+          const raw = JSON.parse(fs12.readFileSync(candidate, "utf-8"));
           this.registryAgents = raw.agents ?? [];
-          log12.debug({ count: this.registryAgents.length }, "Loaded registry from bundled snapshot");
+          log11.debug({ count: this.registryAgents.length }, "Loaded registry from bundled snapshot");
           return;
         }
       }
-      log12.warn("No registry data available (no cache, no snapshot)");
+      log11.warn("No registry data available (no cache, no snapshot)");
     } catch {
-      log12.warn("Failed to load bundled registry snapshot");
+      log11.warn("Failed to load bundled registry snapshot");
+    }
+  }
+};
+function stripNpmVersion(pkg) {
+  if (pkg.startsWith("@")) {
+    const slashIdx = pkg.indexOf("/");
+    if (slashIdx === -1) return pkg;
+    const versionAt = pkg.indexOf("@", slashIdx + 1);
+    return versionAt === -1 ? pkg : pkg.slice(0, versionAt);
+  }
+  const at = pkg.indexOf("@");
+  return at === -1 ? pkg : pkg.slice(0, at);
+}
+function stripPythonVersion(pkg) {
+  const pyMatch = pkg.match(/^([^=@><!]+)/);
+  if (pyMatch && pkg.includes("==")) return pyMatch[1];
+  const at = pkg.indexOf("@");
+  return at === -1 ? pkg : pkg.slice(0, at);
+}
+
+// src/core/agents/agent-store.ts
+init_log();
+import * as fs13 from "fs";
+import * as path12 from "path";
+import { z as z2 } from "zod";
+var log12 = createChildLogger({ module: "agent-store" });
+var InstalledAgentSchema = z2.object({
+  registryId: z2.string().nullable(),
+  name: z2.string(),
+  version: z2.string(),
+  distribution: z2.enum(["npx", "uvx", "binary", "custom"]),
+  command: z2.string(),
+  args: z2.array(z2.string()).default([]),
+  env: z2.record(z2.string(), z2.string()).default({}),
+  workingDirectory: z2.string().optional(),
+  installedAt: z2.string(),
+  binaryPath: z2.string().nullable().default(null)
+});
+var AgentStoreSchema = z2.object({
+  version: z2.number().default(1),
+  installed: z2.record(z2.string(), InstalledAgentSchema).default({})
+});
+var AgentStore = class {
+  data = { version: 1, installed: {} };
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  load() {
+    if (!fs13.existsSync(this.filePath)) {
+      this.data = { version: 1, installed: {} };
+      return;
+    }
+    try {
+      const raw = JSON.parse(fs13.readFileSync(this.filePath, "utf-8"));
+      const result = AgentStoreSchema.safeParse(raw);
+      if (result.success) {
+        this.data = result.data;
+      } else {
+        log12.warn({ errors: result.error.issues }, "Invalid agents.json, starting fresh");
+        this.data = { version: 1, installed: {} };
+      }
+    } catch (err) {
+      log12.warn({ err }, "Failed to read agents.json, starting fresh");
+      this.data = { version: 1, installed: {} };
     }
   }
+  exists() {
+    return fs13.existsSync(this.filePath);
+  }
+  getInstalled() {
+    return this.data.installed;
+  }
+  getAgent(key) {
+    return this.data.installed[key];
+  }
+  addAgent(key, agent) {
+    this.data.installed[key] = agent;
+    this.save();
+  }
+  removeAgent(key) {
+    delete this.data.installed[key];
+    this.save();
+  }
+  hasAgent(key) {
+    return key in this.data.installed;
+  }
+  save() {
+    fs13.mkdirSync(path12.dirname(this.filePath), { recursive: true });
+    const tmpPath = this.filePath + ".tmp";
+    fs13.writeFileSync(tmpPath, JSON.stringify(this.data, null, 2), { mode: 384 });
+    fs13.renameSync(tmpPath, this.filePath);
+  }
 };
 
 // src/core/event-bus.ts
@@ -14971,7 +15021,7 @@ var EventBus = class extends TypedEmitter {
 
 // src/core/plugin/plugin-loader.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 function resolveLoadOrder(plugins) {
   const overrideTargets = /* @__PURE__ */ new Set();
   for (const p of plugins) {
@@ -15212,32 +15262,28 @@ var ErrorTracker = class {
   }
 };
 
-// src/core/plugin/plugin-context.ts
-import path15 from "path";
-import os7 from "os";
-
 // src/core/plugin/plugin-storage.ts
-import fs15 from "fs";
-import path14 from "path";
+import fs14 from "fs";
+import path13 from "path";
 var PluginStorageImpl = class {
   kvPath;
   dataDir;
   writeChain = Promise.resolve();
   constructor(baseDir) {
-    this.dataDir = path14.join(baseDir, "data");
-    this.kvPath = path14.join(baseDir, "kv.json");
-    fs15.mkdirSync(baseDir, { recursive: true });
+    this.dataDir = path13.join(baseDir, "data");
+    this.kvPath = path13.join(baseDir, "kv.json");
+    fs14.mkdirSync(baseDir, { recursive: true });
   }
   readKv() {
     try {
-      const raw = fs15.readFileSync(this.kvPath, "utf-8");
+      const raw = fs14.readFileSync(this.kvPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return {};
     }
   }
   writeKv(data) {
-    fs15.writeFileSync(this.kvPath, JSON.stringify(data), "utf-8");
+    fs14.writeFileSync(this.kvPath, JSON.stringify(data), "utf-8");
   }
   async get(key) {
     const data = this.readKv();
@@ -15263,7 +15309,7 @@ var PluginStorageImpl = class {
     return Object.keys(this.readKv());
   }
   getDataDir() {
-    fs15.mkdirSync(this.dataDir, { recursive: true });
+    fs14.mkdirSync(this.dataDir, { recursive: true });
     return this.dataDir;
   }
 };
@@ -15287,7 +15333,7 @@ function createPluginContext(opts) {
     config,
     core
   } = opts;
-  const instanceRoot = opts.instanceRoot ?? path15.join(os7.homedir(), ".openacp");
+  const instanceRoot = opts.instanceRoot;
   const registeredListeners = [];
   const registeredCommands = [];
   const registeredMenuItemIds = [];
@@ -15310,7 +15356,7 @@ function createPluginContext(opts) {
     }
   };
   const baseLog = opts.log ?? noopLog;
-  const log36 = typeof baseLog.child === "function" ? baseLog.child({ plugin: pluginName }) : baseLog;
+  const log37 = typeof baseLog.child === "function" ? baseLog.child({ plugin: pluginName }) : baseLog;
   const storageImpl = new PluginStorageImpl(storagePath);
   const storage = {
     async get(key) {
@@ -15337,7 +15383,7 @@ function createPluginContext(opts) {
   const ctx = {
     pluginName,
     pluginConfig,
-    log: log36,
+    log: log37,
     storage,
     on(event, handler) {
       requirePermission(permissions, "events:read", "on()");
@@ -15372,7 +15418,7 @@ function createPluginContext(opts) {
       const registry = serviceRegistry.get("command-registry");
       if (registry && typeof registry.register === "function") {
         registry.register(def, pluginName);
-        log36.debug(`Command '/${def.name}' registered`);
+        log37.debug(`Command '/${def.name}' registered`);
       }
     },
     async sendMessage(_sessionId, _content) {
@@ -15415,7 +15461,7 @@ function createPluginContext(opts) {
       const registry = serviceRegistry.get("field-registry");
       if (registry && typeof registry.register === "function") {
         registry.register(pluginName, fields);
-        log36.debug(`Registered ${fields.length} editable field(s) for ${pluginName}`);
+        log37.debug(`Registered ${fields.length} editable field(s) for ${pluginName}`);
       }
     },
     get sessions() {
@@ -15798,7 +15844,7 @@ Examples:
 ${baseCmd} api status
 ${baseCmd} api new claude-code ~/my-project --channel <current_channel>
 ${baseCmd} api cancel <id>
-${baseCmd} config set workspace.baseDir ~/code
+${baseCmd} config set logging.level debug
 ${baseCmd} agents install gemini
 \`\`\`
 
@@ -15971,10 +16017,10 @@ function createConfigSection(core) {
     title: "Configuration",
     priority: 30,
     buildContext: () => {
-      const config = core.configManager.get();
+      const workspace = core.configManager.resolveWorkspace();
       const speechSvc = core.lifecycleManager?.serviceRegistry.get("speech");
       const sttActive = speechSvc ? speechSvc.isSTTAvailable() : false;
-      return `Workspace base: ${config.workspace.baseDir}
+      return `Workspace base: ${workspace}
 STT: ${sttActive ? "configured \u2705" : "Not configured"}`;
     },
     commands: [
@@ -16159,13 +16205,13 @@ var OpenACPCore = class {
     this.instanceContext = ctx;
     const config = configManager.get();
     this.agentCatalog = new AgentCatalog(
-      ctx ? new AgentStore(ctx.paths.agents) : void 0,
-      ctx?.paths.registryCache,
-      ctx?.paths.agentsDir
+      new AgentStore(ctx.paths.agents),
+      ctx.paths.registryCache,
+      ctx.paths.agentsDir
     );
     this.agentCatalog.load();
     this.agentManager = new AgentManager(this.agentCatalog);
-    const storePath = ctx?.paths.sessions ?? path16.join(os8.homedir(), ".openacp", "sessions.json");
+    const storePath = ctx.paths.sessions;
     this.sessionStore = new JsonFileSessionStore(
       storePath,
       config.sessionStore.ttlDays
@@ -16179,7 +16225,7 @@ var OpenACPCore = class {
       this.sessionManager,
       () => this.speechService,
       this.eventBus,
-      ctx?.root
+      ctx.root
     );
     this.lifecycleManager = new LifecycleManager({
       serviceRegistry: new ServiceRegistry(),
@@ -16189,8 +16235,8 @@ var OpenACPCore = class {
       sessions: this.sessionManager,
       config: this.configManager,
       core: this,
-      storagePath: ctx?.paths.pluginsData ?? path16.join(os8.homedir(), ".openacp", "plugins", "data"),
-      instanceRoot: ctx?.root,
+      storagePath: ctx.paths.pluginsData,
+      instanceRoot: ctx.root,
       log: createChildLogger({ module: "plugin" })
     });
     this.sessionFactory.middlewareChain = this.lifecycleManager.middlewareChain;
@@ -16254,9 +16300,7 @@ var OpenACPCore = class {
       }
     );
     registerCoreMenuItems(this.menuRegistry);
-    if (ctx?.root) {
-      this.assistantRegistry.setInstanceRoot(path16.dirname(ctx.root));
-    }
+    this.assistantRegistry.setInstanceRoot(path14.dirname(ctx.root));
     this.assistantRegistry.register(createSessionsSection(this));
     this.assistantRegistry.register(createAgentsSection(this));
     this.assistantRegistry.register(createConfigSection(this));
@@ -16555,8 +16599,8 @@ ${text3}`;
         message: `Agent '${agentName}' not found`
       };
     }
-    const { existsSync: existsSync19 } = await import("fs");
-    if (!existsSync19(cwd)) {
+    const { existsSync: existsSync18 } = await import("fs");
+    if (!existsSync18(cwd)) {
       return {
         ok: false,
         error: "invalid_cwd",
@@ -16902,19 +16946,30 @@ init_doctor();
 init_config_registry();
 
 // src/core/config/config-editor.ts
-import * as path28 from "path";
+import * as path30 from "path";
 import * as clack2 from "@clack/prompts";
 
 // src/cli/autostart.ts
 init_log();
 import { execFileSync as execFileSync6 } from "child_process";
-import * as fs26 from "fs";
-import * as path24 from "path";
-import * as os11 from "os";
+import * as fs25 from "fs";
+import * as path23 from "path";
+import * as os7 from "os";
 var log18 = createChildLogger({ module: "autostart" });
-var LAUNCHD_LABEL = "com.openacp.daemon";
-var LAUNCHD_PLIST_PATH = path24.join(os11.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-var SYSTEMD_SERVICE_PATH = path24.join(os11.homedir(), ".config", "systemd", "user", "openacp.service");
+var LEGACY_LAUNCHD_PLIST_PATH = path23.join(os7.homedir(), "Library", "LaunchAgents", "com.openacp.daemon.plist");
+var LEGACY_SYSTEMD_SERVICE_PATH = path23.join(os7.homedir(), ".config", "systemd", "user", "openacp.service");
+function getLaunchdLabel(instanceId) {
+  return `com.openacp.daemon.${instanceId}`;
+}
+function getLaunchdPlistPath(instanceId) {
+  return path23.join(os7.homedir(), "Library", "LaunchAgents", `${getLaunchdLabel(instanceId)}.plist`);
+}
+function getSystemdServiceName(instanceId) {
+  return `openacp-${instanceId}`;
+}
+function getSystemdServicePath(instanceId) {
+  return path23.join(os7.homedir(), ".config", "systemd", "user", `${getSystemdServiceName(instanceId)}.service`);
+}
 function isAutoStartSupported() {
   return process.platform === "darwin" || process.platform === "linux";
 }
@@ -16925,20 +16980,26 @@ function escapeSystemdValue(str) {
   const escaped = str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "$$$$").replace(/%/g, "%%");
   return `"${escaped}"`;
 }
-function generateLaunchdPlist(nodePath, cliPath, logDir2) {
-  const logFile = path24.join(logDir2, "openacp.log");
+function generateLaunchdPlist(nodePath, cliPath, logDir2, instanceRoot, instanceId) {
+  const label = getLaunchdLabel(instanceId);
+  const logFile = path23.join(logDir2, "openacp.log");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
   <key>Label</key>
-  <string>${LAUNCHD_LABEL}</string>
+  <string>${label}</string>
   <key>ProgramArguments</key>
   <array>
     <string>${escapeXml(nodePath)}</string>
     <string>${escapeXml(cliPath)}</string>
     <string>--daemon-child</string>
   </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>OPENACP_INSTANCE_ROOT</key>
+    <string>${escapeXml(instanceRoot)}</string>
+  </dict>
   <key>RunAtLoad</key>
   <true/>
   <key>KeepAlive</key>
@@ -16954,43 +17015,85 @@ function generateLaunchdPlist(nodePath, cliPath, logDir2) {
 </plist>
 `;
 }
-function generateSystemdUnit(nodePath, cliPath) {
+function generateSystemdUnit(nodePath, cliPath, instanceRoot, instanceId) {
+  const serviceName = getSystemdServiceName(instanceId);
   return `[Unit]
-Description=OpenACP Daemon
+Description=OpenACP Daemon (${instanceId})
 
 [Service]
 ExecStart=${escapeSystemdValue(nodePath)} ${escapeSystemdValue(cliPath)} --daemon-child
+Environment=OPENACP_INSTANCE_ROOT=${escapeSystemdValue(instanceRoot)}
 Restart=on-failure
 
 [Install]
 WantedBy=default.target
+# Service name: ${serviceName}
 `;
 }
-function installAutoStart(logDir2) {
+function migrateLegacy() {
+  if (process.platform === "darwin" && fs25.existsSync(LEGACY_LAUNCHD_PLIST_PATH)) {
+    try {
+      const uid = process.getuid();
+      execFileSync6("launchctl", ["bootout", `gui/${uid}`, "com.openacp.daemon"], { stdio: "pipe" });
+    } catch {
+    }
+    try {
+      fs25.unlinkSync(LEGACY_LAUNCHD_PLIST_PATH);
+    } catch {
+    }
+    log18.info("Removed legacy single-instance LaunchAgent");
+  }
+  if (process.platform === "linux" && fs25.existsSync(LEGACY_SYSTEMD_SERVICE_PATH)) {
+    try {
+      execFileSync6("systemctl", ["--user", "disable", "openacp"], { stdio: "pipe" });
+    } catch {
+    }
+    try {
+      fs25.unlinkSync(LEGACY_SYSTEMD_SERVICE_PATH);
+    } catch {
+    }
+    try {
+      execFileSync6("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
+    } catch {
+    }
+    log18.info("Removed legacy single-instance systemd service");
+  }
+}
+function installAutoStart(logDir2, instanceRoot, instanceId) {
   if (!isAutoStartSupported()) {
     return { success: false, error: "Auto-start not supported on this platform" };
   }
   const nodePath = process.execPath;
-  const cliPath = path24.resolve(process.argv[1]);
-  const resolvedLogDir = logDir2.startsWith("~") ? path24.join(os11.homedir(), logDir2.slice(1)) : logDir2;
+  const cliPath = path23.resolve(process.argv[1]);
+  const resolvedLogDir = logDir2.startsWith("~") ? path23.join(os7.homedir(), logDir2.slice(1)) : logDir2;
   try {
+    migrateLegacy();
     if (process.platform === "darwin") {
-      const plist = generateLaunchdPlist(nodePath, cliPath, resolvedLogDir);
-      const dir = path24.dirname(LAUNCHD_PLIST_PATH);
-      fs26.mkdirSync(dir, { recursive: true });
-      fs26.writeFileSync(LAUNCHD_PLIST_PATH, plist);
-      execFileSync6("launchctl", ["load", LAUNCHD_PLIST_PATH], { stdio: "pipe" });
-      log18.info("LaunchAgent installed");
+      const plistPath = getLaunchdPlistPath(instanceId);
+      const plist = generateLaunchdPlist(nodePath, cliPath, resolvedLogDir, instanceRoot, instanceId);
+      const dir = path23.dirname(plistPath);
+      fs25.mkdirSync(dir, { recursive: true });
+      fs25.writeFileSync(plistPath, plist);
+      const uid = process.getuid();
+      const domain = `gui/${uid}`;
+      try {
+        execFileSync6("launchctl", ["bootout", domain, plistPath], { stdio: "pipe" });
+      } catch {
+      }
+      execFileSync6("launchctl", ["bootstrap", domain, plistPath], { stdio: "pipe" });
+      log18.info({ instanceId }, "LaunchAgent installed");
       return { success: true };
     }
     if (process.platform === "linux") {
-      const unit = generateSystemdUnit(nodePath, cliPath);
-      const dir = path24.dirname(SYSTEMD_SERVICE_PATH);
-      fs26.mkdirSync(dir, { recursive: true });
-      fs26.writeFileSync(SYSTEMD_SERVICE_PATH, unit);
+      const servicePath = getSystemdServicePath(instanceId);
+      const serviceName = getSystemdServiceName(instanceId);
+      const unit = generateSystemdUnit(nodePath, cliPath, instanceRoot, instanceId);
+      const dir = path23.dirname(servicePath);
+      fs25.mkdirSync(dir, { recursive: true });
+      fs25.writeFileSync(servicePath, unit);
       execFileSync6("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
-      execFileSync6("systemctl", ["--user", "enable", "openacp"], { stdio: "pipe" });
-      log18.info("systemd user service installed");
+      execFileSync6("systemctl", ["--user", "enable", serviceName], { stdio: "pipe" });
+      log18.info({ instanceId }, "systemd user service installed");
       return { success: true };
     }
     return { success: false, error: "Unsupported platform" };
@@ -17000,31 +17103,35 @@ function installAutoStart(logDir2) {
     return { success: false, error: msg };
   }
 }
-function uninstallAutoStart() {
+function uninstallAutoStart(instanceId) {
   if (!isAutoStartSupported()) {
     return { success: false, error: "Auto-start not supported on this platform" };
   }
   try {
     if (process.platform === "darwin") {
-      if (fs26.existsSync(LAUNCHD_PLIST_PATH)) {
+      const plistPath = getLaunchdPlistPath(instanceId);
+      if (fs25.existsSync(plistPath)) {
+        const uid = process.getuid();
         try {
-          execFileSync6("launchctl", ["unload", LAUNCHD_PLIST_PATH], { stdio: "pipe" });
+          execFileSync6("launchctl", ["bootout", `gui/${uid}`, plistPath], { stdio: "pipe" });
         } catch {
         }
-        fs26.unlinkSync(LAUNCHD_PLIST_PATH);
-        log18.info("LaunchAgent removed");
+        fs25.unlinkSync(plistPath);
+        log18.info({ instanceId }, "LaunchAgent removed");
       }
       return { success: true };
     }
     if (process.platform === "linux") {
-      if (fs26.existsSync(SYSTEMD_SERVICE_PATH)) {
+      const servicePath = getSystemdServicePath(instanceId);
+      const serviceName = getSystemdServiceName(instanceId);
+      if (fs25.existsSync(servicePath)) {
         try {
-          execFileSync6("systemctl", ["--user", "disable", "openacp"], { stdio: "pipe" });
+          execFileSync6("systemctl", ["--user", "disable", serviceName], { stdio: "pipe" });
         } catch {
         }
-        fs26.unlinkSync(SYSTEMD_SERVICE_PATH);
+        fs25.unlinkSync(servicePath);
         execFileSync6("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
-        log18.info("systemd user service removed");
+        log18.info({ instanceId }, "systemd user service removed");
       }
       return { success: true };
     }
@@ -17035,16 +17142,41 @@ function uninstallAutoStart() {
     return { success: false, error: msg };
   }
 }
-function isAutoStartInstalled() {
+function isAutoStartInstalled(instanceId) {
   if (process.platform === "darwin") {
-    return fs26.existsSync(LAUNCHD_PLIST_PATH);
+    return fs25.existsSync(getLaunchdPlistPath(instanceId));
   }
   if (process.platform === "linux") {
-    return fs26.existsSync(SYSTEMD_SERVICE_PATH);
+    return fs25.existsSync(getSystemdServicePath(instanceId));
   }
   return false;
 }
 
+// src/cli/resolve-instance-id.ts
+init_instance_context();
+init_instance_registry();
+init_log();
+import fs28 from "fs";
+import path26 from "path";
+var log19 = createChildLogger({ module: "resolve-instance-id" });
+function resolveInstanceId(instanceRoot) {
+  try {
+    const configPath = path26.join(instanceRoot, "config.json");
+    const raw = JSON.parse(fs28.readFileSync(configPath, "utf-8"));
+    if (raw.id && typeof raw.id === "string") return raw.id;
+  } catch {
+  }
+  try {
+    const reg = new InstanceRegistry(path26.join(getGlobalRoot(), "instances.json"));
+    reg.load();
+    const entry = reg.getByRoot(instanceRoot);
+    if (entry?.id) return entry.id;
+  } catch (err) {
+    log19.debug({ err: err.message, instanceRoot }, "Could not read instance registry, using fallback id");
+  }
+  return path26.basename(path26.dirname(instanceRoot)).replace(/[^a-zA-Z0-9-]/g, "-") || "default";
+}
+
 // src/core/config/config-editor.ts
 init_config();
 async function select3(opts) {
@@ -17170,29 +17302,28 @@ async function ensureDiscordPlugin() {
     }
   }
 }
-async function editDiscord(_config, _updates) {
+async function editDiscord(_config, _updates, settingsManager, instanceRoot) {
   const pluginModule = await ensureDiscordPlugin();
   if (!pluginModule) return;
   const plugin = pluginModule.default;
   if (plugin?.configure) {
-    const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
+    if (!settingsManager || !instanceRoot) {
+      console.log(warn("Cannot configure Discord \u2014 instance context not available."));
+      return;
+    }
     const { createInstallContext: createInstallContext2 } = await Promise.resolve().then(() => (init_install_context(), install_context_exports));
-    const { getGlobalRoot: getGlobalRoot2 } = await Promise.resolve().then(() => (init_instance_context(), instance_context_exports));
-    const root = getGlobalRoot2();
-    const basePath = path28.join(root, "plugins", "data");
-    const settingsManager = new SettingsManager2(basePath);
     const ctx = createInstallContext2({
       pluginName: plugin.name,
       settingsManager,
-      basePath,
-      instanceRoot: root
+      basePath: settingsManager.getBasePath(),
+      instanceRoot
     });
     await plugin.configure(ctx);
   } else {
     console.log(warn("This plugin does not have a configure() method yet."));
   }
 }
-async function editChannels(config, updates, settingsManager) {
+async function editChannels(config, updates, settingsManager, instanceRoot) {
   let tgConfigured = false;
   let dcConfigured = false;
   if (settingsManager) {
@@ -17216,7 +17347,7 @@ async function editChannels(config, updates, settingsManager) {
     });
     if (choice === "back") break;
     if (choice === "telegram") await editTelegram(config, updates, settingsManager);
-    if (choice === "discord") await editDiscord(config, updates);
+    if (choice === "discord") await editDiscord(config, updates, settingsManager, instanceRoot);
   }
 }
 async function editAgent(config, updates) {
@@ -17249,19 +17380,6 @@ async function editAgent(config, updates) {
     }
   }
 }
-async function editWorkspace(config, updates) {
-  const currentDir = config.workspace?.baseDir ?? "~/openacp-workspace";
-  console.log(header("Workspace"));
-  console.log(`  Base directory : ${currentDir}`);
-  console.log("");
-  const newDir = await input({
-    message: "Workspace base directory:",
-    default: currentDir,
-    validate: (val) => val.trim().length > 0 || "Path cannot be empty"
-  });
-  updates.workspace = { baseDir: newDir.trim() };
-  console.log(ok(`Workspace set to ${newDir.trim()}`));
-}
 async function editSecurity(config, updates, settingsManager) {
   const ps = settingsManager ? await settingsManager.loadSettings("@openacp/security") : {};
   const sec = {
@@ -17360,10 +17478,11 @@ async function editLogging(config, updates) {
     }
   }
 }
-async function editRunMode(config, updates) {
+async function editRunMode(config, updates, instanceRoot) {
   const currentMode = config.runMode ?? "foreground";
   const currentAutoStart = config.autoStart ?? false;
-  const autoStartInstalled = isAutoStartInstalled();
+  const instanceId = instanceRoot ? resolveInstanceId(instanceRoot) : "default";
+  const autoStartInstalled = isAutoStartInstalled(instanceId);
   const autoStartSupported = isAutoStartSupported();
   console.log(header("Run Mode"));
   console.log(`  Current mode : ${c.bold}${currentMode}${c.reset}`);
@@ -17396,7 +17515,7 @@ async function editRunMode(config, updates) {
     if (choice === "daemon") {
       updates.runMode = "daemon";
       const logDir2 = config.logging?.logDir ?? "~/.openacp/logs";
-      const result = installAutoStart(expandHome3(logDir2));
+      const result = installAutoStart(expandHome2(logDir2), instanceRoot, instanceId);
       if (result.success) {
         updates.autoStart = true;
         console.log(ok("Switched to daemon mode with auto-start"));
@@ -17407,7 +17526,7 @@ async function editRunMode(config, updates) {
     if (choice === "foreground") {
       updates.runMode = "foreground";
       updates.autoStart = false;
-      uninstallAutoStart();
+      uninstallAutoStart(instanceId);
       console.log(ok("Switched to foreground mode"));
     }
     if (choice === "toggleAutoStart") {
@@ -17416,7 +17535,7 @@ async function editRunMode(config, updates) {
         return currentAutoStart;
       })();
       if (autoStartCurrent) {
-        const result = uninstallAutoStart();
+        const result = uninstallAutoStart(instanceId);
         updates.autoStart = false;
         if (result.success) {
           console.log(ok("Auto-start disabled"));
@@ -17425,7 +17544,7 @@ async function editRunMode(config, updates) {
         }
       } else {
         const logDir2 = config.logging?.logDir ?? "~/.openacp/logs";
-        const result = installAutoStart(expandHome3(logDir2));
+        const result = installAutoStart(expandHome2(logDir2), instanceRoot, instanceId);
         updates.autoStart = result.success;
         if (result.success) {
           console.log(ok("Auto-start enabled"));
@@ -17627,6 +17746,7 @@ async function runConfigEditor(configManager, mode = "file", apiPort, settingsMa
   await configManager.load();
   const config = configManager.get();
   const updates = {};
+  const instanceRoot = path30.dirname(configManager.getConfigPath());
   console.log(`
 ${c.cyan}${c.bold}OpenACP Config Editor${c.reset}`);
   console.log(dim(`Config: ${configManager.getConfigPath()}`));
@@ -17639,7 +17759,6 @@ ${c.cyan}${c.bold}OpenACP Config Editor${c.reset}`);
         choices: [
           { name: "Channels", value: "channels" },
           { name: "Agent", value: "agent" },
-          { name: "Workspace", value: "workspace" },
           { name: "Security", value: "security" },
           { name: "Logging", value: "logging" },
           { name: "Run Mode", value: "runMode" },
@@ -17658,12 +17777,11 @@ ${c.cyan}${c.bold}OpenACP Config Editor${c.reset}`);
         break;
       }
       const sectionUpdates = {};
-      if (choice === "channels") await editChannels(config, sectionUpdates, settingsManager);
+      if (choice === "channels") await editChannels(config, sectionUpdates, settingsManager, instanceRoot);
       else if (choice === "agent") await editAgent(config, sectionUpdates);
-      else if (choice === "workspace") await editWorkspace(config, sectionUpdates);
       else if (choice === "security") await editSecurity(config, sectionUpdates, settingsManager);
       else if (choice === "logging") await editLogging(config, sectionUpdates);
-      else if (choice === "runMode") await editRunMode(config, sectionUpdates);
+      else if (choice === "runMode") await editRunMode(config, sectionUpdates, instanceRoot);
       else if (choice === "api") await editApi(config, sectionUpdates, settingsManager);
       else if (choice === "tunnel") await editTunnel(config, sectionUpdates, settingsManager);
       if (mode === "api" && Object.keys(sectionUpdates).length > 0) {
@@ -17685,17 +17803,17 @@ ${c.cyan}${c.bold}OpenACP Config Editor${c.reset}`);
 async function sendConfigViaApi(port, updates) {
   const { apiCall: call } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
   const paths = flattenToPaths(updates);
-  for (const { path: path34, value } of paths) {
+  for (const { path: path35, value } of paths) {
     const res = await call(port, "/api/config", {
       method: "PATCH",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ path: path34, value })
+      body: JSON.stringify({ path: path35, value })
     });
     const data = await res.json();
     if (!res.ok) {
-      console.log(warn(`Failed to update ${path34}: ${data.error}`));
+      console.log(warn(`Failed to update ${path35}: ${data.error}`));
     } else if (data.needsRestart) {
-      console.log(warn(`${path34} updated \u2014 restart required`));
+      console.log(warn(`${path35} updated \u2014 restart required`));
     }
   }
 }
@@ -17715,30 +17833,25 @@ function flattenToPaths(obj, prefix = "") {
 // src/cli/daemon.ts
 init_config();
 import { spawn as spawn3 } from "child_process";
-import * as fs29 from "fs";
-import * as path29 from "path";
-import * as os14 from "os";
-var DEFAULT_ROOT2 = path29.join(os14.homedir(), ".openacp");
+import * as fs31 from "fs";
+import * as path31 from "path";
 function getPidPath(root) {
-  const base = root ?? DEFAULT_ROOT2;
-  return path29.join(base, "openacp.pid");
+  return path31.join(root, "openacp.pid");
 }
 function getLogDir(root) {
-  const base = root ?? DEFAULT_ROOT2;
-  return path29.join(base, "logs");
+  return path31.join(root, "logs");
 }
 function getRunningMarker(root) {
-  const base = root ?? DEFAULT_ROOT2;
-  return path29.join(base, "running");
+  return path31.join(root, "running");
 }
 function writePidFile(pidPath, pid) {
-  const dir = path29.dirname(pidPath);
-  fs29.mkdirSync(dir, { recursive: true });
-  fs29.writeFileSync(pidPath, String(pid));
+  const dir = path31.dirname(pidPath);
+  fs31.mkdirSync(dir, { recursive: true });
+  fs31.writeFileSync(pidPath, String(pid));
 }
 function readPidFile(pidPath) {
   try {
-    const content = fs29.readFileSync(pidPath, "utf-8").trim();
+    const content = fs31.readFileSync(pidPath, "utf-8").trim();
     const pid = parseInt(content, 10);
     return isNaN(pid) ? null : pid;
   } catch {
@@ -17747,7 +17860,7 @@ function readPidFile(pidPath) {
 }
 function removePidFile(pidPath) {
   try {
-    fs29.unlinkSync(pidPath);
+    fs31.unlinkSync(pidPath);
   } catch {
   }
 }
@@ -17762,7 +17875,7 @@ function isProcessRunning(pidPath) {
     return false;
   }
 }
-function getStatus(pidPath = getPidPath()) {
+function getStatus(pidPath) {
   const pid = readPidFile(pidPath);
   if (pid === null) return { running: false };
   try {
@@ -17773,19 +17886,19 @@ function getStatus(pidPath = getPidPath()) {
     return { running: false };
   }
 }
-function startDaemon(pidPath = getPidPath(), logDir2, instanceRoot) {
+function startDaemon(pidPath, logDir2, instanceRoot) {
   markRunning(instanceRoot);
   if (isProcessRunning(pidPath)) {
     const pid = readPidFile(pidPath);
     return { error: `Already running (PID ${pid})` };
   }
-  const resolvedLogDir = logDir2 ? expandHome3(logDir2) : getLogDir(instanceRoot);
-  fs29.mkdirSync(resolvedLogDir, { recursive: true });
-  const logFile = path29.join(resolvedLogDir, "openacp.log");
-  const cliPath = path29.resolve(process.argv[1]);
+  const resolvedLogDir = logDir2 ? expandHome2(logDir2) : getLogDir(instanceRoot);
+  fs31.mkdirSync(resolvedLogDir, { recursive: true });
+  const logFile = path31.join(resolvedLogDir, "openacp.log");
+  const cliPath = path31.resolve(process.argv[1]);
   const nodePath = process.execPath;
-  const out = fs29.openSync(logFile, "a");
-  const err = fs29.openSync(logFile, "a");
+  const out = fs31.openSync(logFile, "a");
+  const err = fs31.openSync(logFile, "a");
   const child = spawn3(nodePath, [cliPath, "--daemon-child"], {
     detached: true,
     stdio: ["ignore", out, err],
@@ -17794,8 +17907,8 @@ function startDaemon(pidPath = getPidPath(), logDir2, instanceRoot) {
       ...instanceRoot ? { OPENACP_INSTANCE_ROOT: instanceRoot } : {}
     }
   });
-  fs29.closeSync(out);
-  fs29.closeSync(err);
+  fs31.closeSync(out);
+  fs31.closeSync(err);
   if (!child.pid) {
     return { error: "Failed to spawn daemon process" };
   }
@@ -17803,7 +17916,7 @@ function startDaemon(pidPath = getPidPath(), logDir2, instanceRoot) {
   child.unref();
   return { pid: child.pid };
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 function isProcessAlive2(pid) {
@@ -17816,7 +17929,7 @@ function isProcessAlive2(pid) {
     return "dead";
   }
 }
-async function stopDaemon(pidPath = getPidPath(), instanceRoot) {
+async function stopDaemon(pidPath, instanceRoot) {
   const pid = readPidFile(pidPath);
   if (pid === null) return { stopped: false, error: "Not running (no PID file)" };
   const status = isProcessAlive2(pid);
@@ -17838,7 +17951,7 @@ async function stopDaemon(pidPath = getPidPath(), instanceRoot) {
   const TIMEOUT = 5e3;
   const start = Date.now();
   while (Date.now() - start < TIMEOUT) {
-    await sleep(POLL_INTERVAL);
+    await sleep2(POLL_INTERVAL);
     const s = isProcessAlive2(pid);
     if (s === "dead" || s === "eperm") {
       removePidFile(pidPath);
@@ -17855,7 +17968,7 @@ async function stopDaemon(pidPath = getPidPath(), instanceRoot) {
   }
   const killStart = Date.now();
   while (Date.now() - killStart < 1e3) {
-    await sleep(POLL_INTERVAL);
+    await sleep2(POLL_INTERVAL);
     const s = isProcessAlive2(pid);
     if (s === "dead" || s === "eperm") {
       removePidFile(pidPath);
@@ -17866,12 +17979,12 @@ async function stopDaemon(pidPath = getPidPath(), instanceRoot) {
 }
 function markRunning(root) {
   const marker = getRunningMarker(root);
-  fs29.mkdirSync(path29.dirname(marker), { recursive: true });
-  fs29.writeFileSync(marker, "");
+  fs31.mkdirSync(path31.dirname(marker), { recursive: true });
+  fs31.writeFileSync(marker, "");
 }
 function clearRunning(root) {
   try {
-    fs29.unlinkSync(getRunningMarker(root));
+    fs31.unlinkSync(getRunningMarker(root));
   } catch {
   }
 }
@@ -17887,7 +18000,7 @@ init_static_server();
 
 // src/plugins/telegram/topic-manager.ts
 init_log();
-var log21 = createChildLogger({ module: "topic-manager" });
+var log22 = createChildLogger({ module: "topic-manager" });
 var TopicManager = class {
   constructor(sessionManager, adapter, systemTopicIds) {
     this.sessionManager = sessionManager;
@@ -17926,7 +18039,7 @@ var TopicManager = class {
       try {
         await this.adapter.deleteSessionThread?.(sessionId);
       } catch (err) {
-        log21.warn({ err, sessionId, topicId }, "Failed to delete platform thread, removing record anyway");
+        log22.warn({ err, sessionId, topicId }, "Failed to delete platform thread, removing record anyway");
       }
     }
     await this.sessionManager.removeRecord(sessionId);
@@ -17949,7 +18062,7 @@ var TopicManager = class {
           try {
             await this.adapter.deleteSessionThread?.(record.sessionId);
           } catch (err) {
-            log21.warn({ err, sessionId: record.sessionId }, "Failed to delete platform thread during cleanup");
+            log22.warn({ err, sessionId: record.sessionId }, "Failed to delete platform thread during cleanup");
           }
         }
         await this.sessionManager.removeRecord(record.sessionId);
@@ -18571,7 +18684,7 @@ Config file: \`~/.openacp/config.json\`
 - Agent list is fetched from the ACP Registry CDN and cached locally (24h)
 
 ### Workspace
-- **workspace.baseDir** \u2014 Base directory for project folders (default: \`~/openacp-workspace\`)
+- Workspace directory is the parent of \`.openacp/\` (where you ran \`openacp\` setup)
 
 ### Security
 - **security.allowedUserIds** \u2014 Restrict who can use the bot (empty = everyone)
@@ -18727,7 +18840,7 @@ export {
   createChildLogger,
   createSessionLogger,
   createTurnContext,
-  expandHome3 as expandHome,
+  expandHome2 as expandHome,
   extractContentText,
   formatTokens,
   formatToolSummary,