@openacp/cli 0.4.10 → 0.5.0

package/dist/{chunk-KPI4HGJC.js → chunk-FWN3UIRT.js}

@@ -1,10 +1,29 @@
+import {
+  buildMenuKeyboard,
+  buildSkillMessages,
+  handleClear,
+  handleHelp,
+  handleMenu
+} from "./chunk-UG6X672R.js";
+import {
+  AgentCatalog
+} from "./chunk-S3DRLJPM.js";
 import {
   getAgentCapabilities
-} from "./chunk-VA2M52CM.js";
+} from "./chunk-XJJ7LPXP.js";
+import {
+  DoctorEngine
+} from "./chunk-IRGYTNLP.js";
+import {
+  getConfigValue,
+  getSafeFields,
+  isHotReloadable,
+  resolveOptions
+} from "./chunk-Z46LGZ7R.js";
 import {
   createChildLogger,
   createSessionLogger
-} from "./chunk-LYKCQTH5.js";
+} from "./chunk-ESOPMQAY.js";
 
 // src/core/streams.ts
 function nodeToWebWritable(nodeStream) {
@@ -49,7 +68,7 @@ var StderrCapture = class {
 };
 
 // src/core/agent-instance.ts
-import { spawn, execSync } from "child_process";
+import { spawn, execFileSync } from "child_process";
 import { Transform } from "stream";
 import fs from "fs";
 import path from "path";
@@ -100,7 +119,7 @@ function resolveAgentCommand(cmd) {
     }
   }
   try {
-    const fullPath = execSync(`which ${cmd}`, { encoding: "utf-8" }).trim();
+    const fullPath = execFileSync("which", [cmd], { encoding: "utf-8" }).trim();
     if (fullPath) {
       const content = fs.readFileSync(fullPath, "utf-8");
       if (content.startsWith("#!/usr/bin/env node")) {
@@ -478,31 +497,29 @@ ${stderr}`
 
 // src/core/agent-manager.ts
 var AgentManager = class {
-  constructor(config) {
-    this.config = config;
+  constructor(catalog) {
+    this.catalog = catalog;
   }
   getAvailableAgents() {
-    return Object.entries(this.config.agents).map(([name, cfg]) => ({
-      name,
-      command: cfg.command,
-      args: cfg.args,
-      workingDirectory: cfg.workingDirectory,
-      env: cfg.env
+    const installed = this.catalog.getInstalledEntries();
+    return Object.entries(installed).map(([key, agent]) => ({
+      name: key,
+      command: agent.command,
+      args: agent.args,
+      env: agent.env
     }));
   }
   getAgent(name) {
-    const cfg = this.config.agents[name];
-    if (!cfg) return void 0;
-    return { name, ...cfg };
+    return this.catalog.resolve(name);
   }
   async spawn(agentName, workingDirectory) {
     const agentDef = this.getAgent(agentName);
-    if (!agentDef) throw new Error(`Agent "${agentName}" not found in config`);
+    if (!agentDef) throw new Error(`Agent "${agentName}" is not installed. Run "openacp agents install ${agentName}" to add it.`);
     return AgentInstance.spawn(agentDef, workingDirectory);
   }
   async resume(agentName, workingDirectory, agentSessionId) {
     const agentDef = this.getAgent(agentName);
-    if (!agentDef) throw new Error(`Agent "${agentName}" not found in config`);
+    if (!agentDef) throw new Error(`Agent "${agentName}" is not installed. Run "openacp agents install ${agentName}" to add it.`);
     return AgentInstance.resume(agentDef, workingDirectory, agentSessionId);
   }
 };
@@ -629,28 +646,40 @@ var PromptQueue = class {
 };
 
 // src/core/permission-gate.ts
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
 var PermissionGate = class {
   request;
   resolveFn;
   rejectFn;
   settled = false;
+  timeoutTimer;
+  timeoutMs;
+  constructor(timeoutMs) {
+    this.timeoutMs = timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
   setPending(request) {
     this.request = request;
     this.settled = false;
+    this.clearTimeout();
     return new Promise((resolve2, reject) => {
       this.resolveFn = resolve2;
       this.rejectFn = reject;
+      this.timeoutTimer = setTimeout(() => {
+        this.reject("Permission request timed out (no response received)");
+      }, this.timeoutMs);
     });
   }
   resolve(optionId) {
     if (this.settled || !this.resolveFn) return;
     this.settled = true;
+    this.clearTimeout();
     this.resolveFn(optionId);
     this.cleanup();
   }
   reject(reason) {
     if (this.settled || !this.rejectFn) return;
     this.settled = true;
+    this.clearTimeout();
     this.rejectFn(new Error(reason ?? "Permission rejected"));
     this.cleanup();
   }
@@ -664,6 +693,12 @@ var PermissionGate = class {
   get requestId() {
     return this.request?.id;
   }
+  clearTimeout() {
+    if (this.timeoutTimer) {
+      clearTimeout(this.timeoutTimer);
+      this.timeoutTimer = void 0;
+    }
+  }
   cleanup() {
     this.request = void 0;
     this.resolveFn = void 0;
@@ -674,6 +709,13 @@ var PermissionGate = class {
 // src/core/session.ts
 import { nanoid } from "nanoid";
 var moduleLog = createChildLogger({ module: "session" });
+var VALID_TRANSITIONS = {
+  initializing: /* @__PURE__ */ new Set(["active", "error"]),
+  active: /* @__PURE__ */ new Set(["error", "finished", "cancelled"]),
+  error: /* @__PURE__ */ new Set(["active"]),
+  cancelled: /* @__PURE__ */ new Set(["active"]),
+  finished: /* @__PURE__ */ new Set()
+};
 var Session = class extends TypedEmitter {
   id;
   channelId;
@@ -682,11 +724,9 @@ var Session = class extends TypedEmitter {
   workingDirectory;
   agentInstance;
   agentSessionId = "";
-  status = "initializing";
+  _status = "initializing";
   name;
   createdAt = /* @__PURE__ */ new Date();
-  adapter;
-  // Set by wireSessionEvents for renaming
   dangerousMode = false;
   log;
   permissionGate = new PermissionGate();
@@ -703,21 +743,44 @@ var Session = class extends TypedEmitter {
     this.queue = new PromptQueue(
       (text) => this.processPrompt(text),
       (err) => {
-        this.status = "error";
+        this.fail("Prompt execution failed");
         this.log.error({ err }, "Prompt execution failed");
       }
     );
   }
-  // --- Backward-compatible properties ---
-  /** @deprecated Use permissionGate directly */
-  get pendingPermission() {
-    if (!this.permissionGate.isPending) return void 0;
-    return {
-      requestId: this.permissionGate.requestId,
-      resolve: (optionId) => this.permissionGate.resolve(optionId)
-    };
-  }
-  set pendingPermission(val) {
+  // --- State Machine ---
+  get status() {
+    return this._status;
+  }
+  /** Transition to active — from initializing, error, or cancelled */
+  activate() {
+    this.transition("active");
+  }
+  /** Transition to error — from initializing or active */
+  fail(reason) {
+    this.transition("error");
+    this.emit("error", new Error(reason));
+  }
+  /** Transition to finished — from active only. Emits session_end for backward compat. */
+  finish(reason) {
+    this.transition("finished");
+    this.emit("session_end", reason ?? "completed");
+  }
+  /** Transition to cancelled — from active only (terminal session cancel) */
+  markCancelled() {
+    this.transition("cancelled");
+  }
+  transition(to) {
+    const from = this._status;
+    const allowed = VALID_TRANSITIONS[from];
+    if (!allowed?.has(to)) {
+      throw new Error(
+        `Invalid session transition: ${from} \u2192 ${to}`
+      );
+    }
+    this._status = to;
+    this.log.debug({ from, to }, "Session status transition");
+    this.emit("status_change", from, to);
   }
   /** Number of prompts waiting in queue */
   get queueDepth() {
@@ -735,7 +798,9 @@ var Session = class extends TypedEmitter {
       await this.runWarmup();
       return;
     }
-    this.status = "active";
+    if (this._status === "initializing") {
+      this.activate();
+    }
     const promptStart = Date.now();
     this.log.debug("Prompt execution started");
     await this.agentInstance.prompt(text);
@@ -760,9 +825,7 @@ var Session = class extends TypedEmitter {
       );
       this.name = title.trim().slice(0, 50) || `Session ${this.id.slice(0, 6)}`;
       this.log.info({ name: this.name }, "Session auto-named");
-      if (this.adapter && this.name) {
-        await this.adapter.renameSessionThread(this.id, this.name);
-      }
+      this.emit("named", this.name);
     } catch {
       this.name = `Session ${this.id.slice(0, 6)}`;
     } finally {
@@ -781,7 +844,7 @@ var Session = class extends TypedEmitter {
     try {
       const start = Date.now();
       await this.agentInstance.prompt('Reply with only "ready".');
-      this.status = "active";
+      this.activate();
       this.log.info({ durationMs: Date.now() - start }, "Warm-up complete");
     } catch (err) {
       this.log.error({ err }, "Warm-up failed");
@@ -790,11 +853,11 @@ var Session = class extends TypedEmitter {
       this.resume();
     }
   }
-  async cancel() {
+  /** Cancel the current prompt and clear the queue. Stays in active state. */
+  async abortPrompt() {
     this.queue.clear();
-    this.log.info("Session cancelled");
+    this.log.info("Prompt aborted");
     await this.agentInstance.cancel();
-    this.status = "active";
   }
   async destroy() {
     this.log.info("Session destroyed");
@@ -867,42 +930,13 @@ var SessionManager = class {
   registerSession(session) {
     this.sessions.set(session.id, session);
   }
-  async updateSessionPlatform(sessionId, platform) {
-    if (!this.store) return;
-    const record = this.store.get(sessionId);
-    if (record) {
-      await this.store.save({ ...record, platform });
-    }
-  }
-  async updateSessionActivity(sessionId) {
-    if (!this.store) return;
-    const record = this.store.get(sessionId);
-    if (record) {
-      await this.store.save({
-        ...record,
-        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
-  }
-  async updateSessionStatus(sessionId, status) {
-    if (!this.store) return;
-    const record = this.store.get(sessionId);
-    if (record) {
-      await this.store.save({ ...record, status });
-    }
-  }
-  async updateSessionDangerousMode(sessionId, dangerousMode) {
-    if (!this.store) return;
-    const record = this.store.get(sessionId);
-    if (record) {
-      await this.store.save({ ...record, dangerousMode });
-    }
-  }
-  async updateSessionName(sessionId, name) {
+  async patchRecord(sessionId, patch) {
     if (!this.store) return;
     const record = this.store.get(sessionId);
     if (record) {
-      await this.store.save({ ...record, name });
+      await this.store.save({ ...record, ...patch });
+    } else if (patch.sessionId) {
+      await this.store.save(patch);
     }
   }
   getSessionRecord(sessionId) {
@@ -911,7 +945,8 @@ var SessionManager = class {
   async cancelSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (session) {
-      await session.cancel();
+      await session.abortPrompt();
+      session.markCancelled();
     }
     if (this.store) {
       const record = this.store.get(sessionId);
@@ -953,6 +988,133 @@ var SessionManager = class {
   }
 };
 
+// src/core/session-bridge.ts
+var log2 = createChildLogger({ module: "session-bridge" });
+var SessionBridge = class {
+  constructor(session, adapter, deps) {
+    this.session = session;
+    this.adapter = adapter;
+    this.deps = deps;
+  }
+  connected = false;
+  agentEventHandler;
+  statusChangeHandler;
+  namedHandler;
+  connect() {
+    if (this.connected) return;
+    this.connected = true;
+    this.wireAgentToSession();
+    this.wireSessionToAdapter();
+    this.wirePermissions();
+    this.wireLifecycle();
+  }
+  disconnect() {
+    if (!this.connected) return;
+    this.connected = false;
+    if (this.agentEventHandler) {
+      this.session.off("agent_event", this.agentEventHandler);
+    }
+    if (this.statusChangeHandler) {
+      this.session.off("status_change", this.statusChangeHandler);
+    }
+    if (this.namedHandler) {
+      this.session.off("named", this.namedHandler);
+    }
+    this.session.agentInstance.onSessionUpdate = () => {
+    };
+    this.session.agentInstance.onPermissionRequest = async () => "";
+  }
+  wireAgentToSession() {
+    this.session.agentInstance.onSessionUpdate = (event) => {
+      this.session.emit("agent_event", event);
+    };
+  }
+  wireSessionToAdapter() {
+    const session = this.session;
+    const ctx = {
+      get id() {
+        return session.id;
+      },
+      get workingDirectory() {
+        return session.workingDirectory;
+      }
+    };
+    this.agentEventHandler = (event) => {
+      switch (event.type) {
+        case "text":
+        case "thought":
+        case "tool_call":
+        case "tool_update":
+        case "plan":
+        case "usage":
+          this.adapter.sendMessage(
+            this.session.id,
+            this.deps.messageTransformer.transform(event, ctx)
+          );
+          break;
+        case "session_end":
+          this.session.finish(event.reason);
+          this.adapter.cleanupSkillCommands(this.session.id);
+          this.adapter.sendMessage(
+            this.session.id,
+            this.deps.messageTransformer.transform(event)
+          );
+          this.deps.notificationManager.notify(this.session.channelId, {
+            sessionId: this.session.id,
+            sessionName: this.session.name,
+            type: "completed",
+            summary: `Session "${this.session.name || this.session.id}" completed`
+          });
+          break;
+        case "error":
+          this.session.fail(event.message);
+          this.adapter.cleanupSkillCommands(this.session.id);
+          this.adapter.sendMessage(
+            this.session.id,
+            this.deps.messageTransformer.transform(event)
+          );
+          this.deps.notificationManager.notify(this.session.channelId, {
+            sessionId: this.session.id,
+            sessionName: this.session.name,
+            type: "error",
+            summary: event.message
+          });
+          break;
+        case "commands_update":
+          log2.debug({ commands: event.commands }, "Commands available");
+          this.adapter.sendSkillCommands(this.session.id, event.commands);
+          break;
+      }
+    };
+    this.session.on("agent_event", this.agentEventHandler);
+  }
+  wirePermissions() {
+    this.session.agentInstance.onPermissionRequest = async (request) => {
+      this.session.emit("permission_request", request);
+      const promise = this.session.permissionGate.setPending(request);
+      await this.adapter.sendPermissionRequest(this.session.id, request);
+      return promise;
+    };
+  }
+  wireLifecycle() {
+    this.statusChangeHandler = (from, to) => {
+      this.deps.sessionManager.patchRecord(this.session.id, {
+        status: to,
+        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (to === "finished" || to === "cancelled") {
+        queueMicrotask(() => this.disconnect());
+      }
+    };
+    this.session.on("status_change", this.statusChangeHandler);
+    this.namedHandler = (name) => {
+      this.deps.sessionManager.patchRecord(this.session.id, { name });
+      this.adapter.renameSessionThread(this.session.id, name);
+    };
+    this.session.on("named", this.namedHandler);
+  }
+};
+
 // src/core/notification.ts
 var NotificationManager = class {
   constructor(adapters) {
@@ -1062,7 +1224,7 @@ function parseContent(content) {
 }
 
 // src/core/message-transformer.ts
-var log2 = createChildLogger({ module: "message-transformer" });
+var log3 = createChildLogger({ module: "message-transformer" });
 var MessageTransformer = class {
   constructor(tunnelService) {
     this.tunnelService = tunnelService;
@@ -1124,7 +1286,7 @@ var MessageTransformer = class {
     if (!this.tunnelService || !sessionContext) return;
     const name = "name" in event ? event.name || "" : "";
     const kind = "kind" in event ? event.kind : void 0;
-    log2.debug(
+    log3.debug(
       { name, kind, status: event.status, hasContent: !!event.content },
       "enrichWithViewerLinks: inspecting event"
     );
@@ -1136,7 +1298,7 @@ var MessageTransformer = class {
       event.meta
     );
     if (!fileInfo) return;
-    log2.info(
+    log3.info(
       {
         name,
         kind,
@@ -1178,7 +1340,7 @@ import os from "os";
 // src/core/session-store.ts
 import fs2 from "fs";
 import path2 from "path";
-var log3 = createChildLogger({ module: "session-store" });
+var log4 = createChildLogger({ module: "session-store" });
 var DEBOUNCE_MS = 2e3;
 var JsonFileSessionStore = class {
   records = /* @__PURE__ */ new Map();
@@ -1260,7 +1422,7 @@ var JsonFileSessionStore = class {
         fs2.readFileSync(this.filePath, "utf-8")
       );
       if (raw.version !== 1) {
-        log3.warn(
+        log4.warn(
           { version: raw.version },
           "Unknown session store version, skipping load"
         );
@@ -1269,9 +1431,9 @@ var JsonFileSessionStore = class {
       for (const [id, record] of Object.entries(raw.sessions)) {
         this.records.set(id, record);
       }
-      log3.info({ count: this.records.size }, "Loaded session records");
+      log4.info({ count: this.records.size }, "Loaded session records");
     } catch (err) {
-      log3.error({ err }, "Failed to load session store");
+      log4.error({ err }, "Failed to load session store");
     }
   }
   cleanup() {
@@ -1287,7 +1449,7 @@ var JsonFileSessionStore = class {
       }
     }
     if (removed > 0) {
-      log3.info({ removed }, "Cleaned up expired session records");
+      log4.info({ removed }, "Cleaned up expired session records");
       this.scheduleDiskWrite();
     }
   }
@@ -1300,9 +1462,10 @@ var JsonFileSessionStore = class {
 };
 
 // src/core/core.ts
-var log4 = createChildLogger({ module: "core" });
+var log5 = createChildLogger({ module: "core" });
 var OpenACPCore = class {
   configManager;
+  agentCatalog;
   agentManager;
   sessionManager;
   notificationManager;
@@ -1316,7 +1479,9 @@ var OpenACPCore = class {
   constructor(configManager) {
     this.configManager = configManager;
     const config = configManager.get();
-    this.agentManager = new AgentManager(config);
+    this.agentCatalog = new AgentCatalog();
+    this.agentCatalog.load();
+    this.agentManager = new AgentManager(this.agentCatalog);
     const storePath = path3.join(os.homedir(), ".openacp", "sessions.json");
     this.sessionStore = new JsonFileSessionStore(
       storePath,
@@ -1325,6 +1490,13 @@ var OpenACPCore = class {
     this.sessionManager = new SessionManager(this.sessionStore);
     this.notificationManager = new NotificationManager(this.adapters);
     this.messageTransformer = new MessageTransformer();
+    this.configManager.on("config:changed", async ({ path: configPath, value }) => {
+      if (configPath === "logging.level" && typeof value === "string") {
+        const { setLogLevel: setLogLevel2 } = await import("./log-SPS2S6FO.js");
+        setLogLevel2(value);
+        log5.info({ level: value }, "Log level changed at runtime");
+      }
+    });
   }
   get tunnelService() {
     return this._tunnelService;
@@ -1337,6 +1509,9 @@ var OpenACPCore = class {
     this.adapters.set(name, adapter);
   }
   async start() {
+    this.agentCatalog.refreshRegistryIfStale().catch((err) => {
+      log5.warn({ err }, "Background registry refresh failed");
+    });
     for (const adapter of this.adapters.values()) {
       await adapter.start();
     }
@@ -1358,7 +1533,7 @@ var OpenACPCore = class {
   // --- Message Routing ---
   async handleMessage(message) {
     const config = this.configManager.get();
-    log4.debug(
+    log5.debug(
       {
         channelId: message.channelId,
         threadId: message.threadId,
@@ -1368,7 +1543,7 @@ var OpenACPCore = class {
     );
     if (config.security.allowedUserIds.length > 0) {
       if (!config.security.allowedUserIds.includes(message.userId)) {
-        log4.warn(
+        log5.warn(
           { userId: message.userId },
           "Rejected message from unauthorized user"
         );
@@ -1377,7 +1552,7 @@ var OpenACPCore = class {
     }
     const activeSessions = this.sessionManager.listSessions().filter((s) => s.status === "active" || s.status === "initializing");
     if (activeSessions.length >= config.security.maxConcurrentSessions) {
-      log4.warn(
+      log5.warn(
         {
           userId: message.userId,
           currentCount: activeSessions.length,
@@ -1401,28 +1576,88 @@ var OpenACPCore = class {
     if (!session) {
       session = await this.lazyResume(message) ?? void 0;
     }
-    if (!session) return;
-    this.sessionManager.updateSessionActivity(session.id);
+    if (!session) {
+      log5.warn(
+        { channelId: message.channelId, threadId: message.threadId },
+        "No session found for thread (in-memory miss + lazy resume returned null)"
+      );
+      return;
+    }
+    this.sessionManager.patchRecord(session.id, { lastActiveAt: (/* @__PURE__ */ new Date()).toISOString() });
     await session.enqueuePrompt(message.text);
   }
+  // --- Unified Session Creation Pipeline ---
+  async createSession(params) {
+    const agentInstance = params.resumeAgentSessionId ? await this.agentManager.resume(
+      params.agentName,
+      params.workingDirectory,
+      params.resumeAgentSessionId
+    ) : await this.agentManager.spawn(
+      params.agentName,
+      params.workingDirectory
+    );
+    const session = new Session({
+      id: params.existingSessionId,
+      channelId: params.channelId,
+      agentName: params.agentName,
+      workingDirectory: params.workingDirectory,
+      agentInstance
+    });
+    session.agentSessionId = agentInstance.sessionId;
+    if (params.initialName) {
+      session.name = params.initialName;
+    }
+    this.sessionManager.registerSession(session);
+    const adapter = this.adapters.get(params.channelId);
+    if (params.createThread && adapter) {
+      const threadId = await adapter.createSessionThread(
+        session.id,
+        params.initialName ?? `\u{1F504} ${params.agentName} \u2014 New Session`
+      );
+      session.threadId = threadId;
+    }
+    if (adapter) {
+      const bridge = this.createBridge(session, adapter);
+      bridge.connect();
+    }
+    const existingRecord = this.sessionStore?.get(session.id);
+    const platform = {
+      ...existingRecord?.platform ?? {}
+    };
+    if (session.threadId) {
+      platform.topicId = Number(session.threadId);
+    }
+    await this.sessionManager.patchRecord(session.id, {
+      sessionId: session.id,
+      agentSessionId: agentInstance.sessionId,
+      agentName: params.agentName,
+      workingDir: params.workingDirectory,
+      channelId: params.channelId,
+      status: session.status,
+      createdAt: session.createdAt.toISOString(),
+      lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+      name: session.name,
+      platform
+    });
+    log5.info(
+      { sessionId: session.id, agentName: params.agentName },
+      "Session created via pipeline"
+    );
+    return session;
+  }
   async handleNewSession(channelId, agentName, workspacePath) {
     const config = this.configManager.get();
     const resolvedAgent = agentName || config.defaultAgent;
-    log4.info({ channelId, agentName: resolvedAgent }, "New session request");
+    log5.info({ channelId, agentName: resolvedAgent }, "New session request");
+    const agentDef = this.agentCatalog.resolve(resolvedAgent);
     const resolvedWorkspace = this.configManager.resolveWorkspace(
-      workspacePath || config.agents[resolvedAgent]?.workingDirectory
+      workspacePath || agentDef?.workingDirectory
     );
-    const session = await this.sessionManager.createSession(
+    return this.createSession({
       channelId,
-      resolvedAgent,
-      resolvedWorkspace,
-      this.agentManager
-    );
-    const adapter = this.adapters.get(channelId);
-    if (adapter) {
-      this.wireSessionEvents(session, adapter);
-    }
-    return session;
+      agentName: resolvedAgent,
+      workingDirectory: resolvedWorkspace
+    });
   }
   async adoptSession(agentName, agentSessionId, cwd) {
     const caps = getAgentCapabilities(agentName);
@@ -1445,10 +1680,10 @@ var OpenACPCore = class {
     if (existingRecord) {
       const platform = existingRecord.platform;
       if (platform?.topicId) {
-        const adapter2 = this.adapters.values().next().value;
-        if (adapter2) {
+        const adapter = this.adapters.values().next().value;
+        if (adapter) {
           try {
-            await adapter2.sendMessage(existingRecord.sessionId, {
+            await adapter.sendMessage(existingRecord.sessionId, {
               type: "text",
               text: "Session resumed from CLI."
             });
@@ -1463,9 +1698,21 @@ var OpenACPCore = class {
         };
       }
     }
-    let agentInstance;
+    const firstEntry = this.adapters.entries().next().value;
+    if (!firstEntry) {
+      return { ok: false, error: "no_adapter", message: "No channel adapter registered" };
+    }
+    const [adapterChannelId] = firstEntry;
+    let session;
     try {
-      agentInstance = await this.agentManager.resume(agentName, cwd, agentSessionId);
+      session = await this.createSession({
+        channelId: adapterChannelId,
+        agentName,
+        workingDirectory: cwd,
+        resumeAgentSessionId: agentSessionId,
+        createThread: true,
+        initialName: "Adopted session"
+      });
     } catch (err) {
       return {
         ok: false,
@@ -1473,43 +1720,14 @@ var OpenACPCore = class {
         message: `Failed to resume session: ${err instanceof Error ? err.message : String(err)}`
       };
     }
-    const session = new Session({
-      channelId: "api",
-      agentName,
-      workingDirectory: cwd,
-      agentInstance
+    await this.sessionManager.patchRecord(session.id, {
+      originalAgentSessionId: agentSessionId,
+      platform: { topicId: Number(session.threadId) }
     });
-    session.agentSessionId = agentInstance.sessionId;
-    this.sessionManager.registerSession(session);
-    const firstEntry = this.adapters.entries().next().value;
-    if (!firstEntry) {
-      await session.destroy();
-      return { ok: false, error: "no_adapter", message: "No channel adapter registered" };
-    }
-    const [adapterChannelId, adapter] = firstEntry;
-    const threadId = await adapter.createSessionThread(session.id, session.name ?? "Adopted session");
-    session.channelId = adapterChannelId;
-    session.threadId = threadId;
-    this.wireSessionEvents(session, adapter);
-    if (this.sessionStore) {
-      await this.sessionStore.save({
-        sessionId: session.id,
-        agentSessionId: agentInstance.sessionId,
-        originalAgentSessionId: agentSessionId,
-        agentName,
-        workingDir: cwd,
-        channelId: adapterChannelId,
-        status: "active",
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
-        name: session.name,
-        platform: { topicId: Number(threadId) }
-      });
-    }
     return {
       ok: true,
       sessionId: session.id,
-      threadId,
+      threadId: session.threadId,
       status: "adopted"
     };
   }
@@ -1544,45 +1762,54 @@ var OpenACPCore = class {
       message.channelId,
       (p) => String(p.topicId) === message.threadId
     );
-    if (!record) return null;
-    if (record.status === "cancelled" || record.status === "error") return null;
+    if (!record) {
+      log5.debug(
+        { threadId: message.threadId, channelId: message.channelId },
+        "No session record found for thread"
+      );
+      return null;
+    }
+    if (record.status === "cancelled" || record.status === "error") {
+      log5.debug(
+        { threadId: message.threadId, sessionId: record.sessionId, status: record.status },
+        "Skipping resume of cancelled/error session"
+      );
+      return null;
+    }
+    log5.info(
+      { threadId: message.threadId, sessionId: record.sessionId, status: record.status },
+      "Lazy resume: found record, attempting resume"
+    );
     const resumePromise = (async () => {
       try {
-        const agentInstance = await this.agentManager.resume(
-          record.agentName,
-          record.workingDir,
-          record.agentSessionId
-        );
-        const session = new Session({
-          id: record.sessionId,
+        const session = await this.createSession({
           channelId: record.channelId,
           agentName: record.agentName,
           workingDirectory: record.workingDir,
-          agentInstance
+          resumeAgentSessionId: record.agentSessionId,
+          existingSessionId: record.sessionId,
+          initialName: record.name
         });
         session.threadId = message.threadId;
-        session.agentSessionId = agentInstance.sessionId;
-        session.status = "active";
-        session.name = record.name;
+        session.activate();
         session.dangerousMode = record.dangerousMode ?? false;
-        this.sessionManager.registerSession(session);
-        const adapter = this.adapters.get(message.channelId);
-        if (adapter) {
-          this.wireSessionEvents(session, adapter);
-        }
-        await store.save({
-          ...record,
-          agentSessionId: agentInstance.sessionId,
-          status: "active",
-          lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        log4.info(
+        log5.info(
           { sessionId: session.id, threadId: message.threadId },
           "Lazy resume successful"
         );
         return session;
       } catch (err) {
-        log4.error({ err, record }, "Lazy resume failed");
+        log5.error({ err, record }, "Lazy resume failed");
+        const adapter = this.adapters.get(message.channelId);
+        if (adapter) {
+          try {
+            await adapter.sendMessage(message.threadId, {
+              type: "error",
+              text: `\u26A0\uFE0F Failed to resume session: ${err instanceof Error ? err.message : String(err)}`
+            });
+          } catch {
+          }
+        }
         return null;
       } finally {
         this.resumeLocks.delete(lockKey);
@@ -1592,73 +1819,12 @@ var OpenACPCore = class {
     return resumePromise;
   }
   // --- Event Wiring ---
-  // Public — adapters call this for assistant session wiring
-  wireSessionEvents(session, adapter) {
-    session.adapter = adapter;
-    session.agentInstance.onSessionUpdate = (event) => {
-      session.emit("agent_event", event);
-    };
-    session.agentInstance.onPermissionRequest = async (request) => {
-      session.emit("permission_request", request);
-      const promise = session.permissionGate.setPending(request);
-      await adapter.sendPermissionRequest(session.id, request);
-      return promise;
-    };
-    const sessionContext = {
-      get id() {
-        return session.id;
-      },
-      get workingDirectory() {
-        return session.workingDirectory;
-      }
-    };
-    session.on("agent_event", (event) => {
-      switch (event.type) {
-        case "text":
-        case "thought":
-        case "tool_call":
-        case "tool_update":
-        case "plan":
-        case "usage":
-          adapter.sendMessage(
-            session.id,
-            this.messageTransformer.transform(event, sessionContext)
-          );
-          break;
-        case "session_end":
-          session.status = "finished";
-          this.sessionManager.updateSessionStatus(session.id, "finished");
-          adapter.cleanupSkillCommands(session.id);
-          adapter.sendMessage(
-            session.id,
-            this.messageTransformer.transform(event)
-          );
-          this.notificationManager.notify(session.channelId, {
-            sessionId: session.id,
-            sessionName: session.name,
-            type: "completed",
-            summary: `Session "${session.name || session.id}" completed`
-          });
-          break;
-        case "error":
-          this.sessionManager.updateSessionStatus(session.id, "error");
-          adapter.cleanupSkillCommands(session.id);
-          adapter.sendMessage(
-            session.id,
-            this.messageTransformer.transform(event)
-          );
-          this.notificationManager.notify(session.channelId, {
-            sessionId: session.id,
-            sessionName: session.name,
-            type: "error",
-            summary: event.message
-          });
-          break;
-        case "commands_update":
-          log4.debug({ commands: event.commands }, "Commands available");
-          adapter.sendSkillCommands(session.id, event.commands);
-          break;
-      }
+  /** Create a SessionBridge for the given session and adapter */
+  createBridge(session, adapter) {
+    return new SessionBridge(session, adapter, {
+      messageTransformer: this.messageTransformer,
+      notificationManager: this.notificationManager,
+      sessionManager: this.sessionManager
     });
   }
 };
@@ -1684,7 +1850,7 @@ import * as fs3 from "fs";
 import * as path4 from "path";
 import * as os2 from "os";
 import { fileURLToPath } from "url";
-var log5 = createChildLogger({ module: "api-server" });
+var log6 = createChildLogger({ module: "api-server" });
 var DEFAULT_PORT_FILE = path4.join(os2.homedir(), ".openacp", "api.port");
 var cachedVersion;
 function getVersion() {
@@ -1730,7 +1896,7 @@ var ApiServer = class {
     await new Promise((resolve2, reject) => {
       this.server.on("error", (err) => {
         if (err.code === "EADDRINUSE") {
-          log5.warn({ port: this.config.port }, "API port in use, continuing without API server");
+          log6.warn({ port: this.config.port }, "API port in use, continuing without API server");
           this.server = null;
           resolve2();
         } else {
@@ -1743,7 +1909,7 @@ var ApiServer = class {
           this.actualPort = addr.port;
         }
         this.writePortFile();
-        log5.info({ host: this.config.host, port: this.actualPort }, "API server listening");
+        log6.info({ host: this.config.host, port: this.actualPort }, "API server listening");
         resolve2();
       });
     });
@@ -1799,6 +1965,8 @@ var ApiServer = class {
         await this.handleHealth(res);
       } else if (method === "GET" && url === "/api/version") {
         await this.handleVersion(res);
+      } else if (method === "GET" && url === "/api/config/editable") {
+        await this.handleGetEditableConfig(res);
       } else if (method === "GET" && url === "/api/config") {
         await this.handleGetConfig(res);
       } else if (method === "PATCH" && url === "/api/config") {
@@ -1822,7 +1990,7 @@ var ApiServer = class {
         this.sendJson(res, 404, { error: "Not found" });
       }
     } catch (err) {
-      log5.error({ err }, "API request error");
+      log6.error({ err }, "API request error");
       this.sendJson(res, 500, { error: "Internal server error" });
     }
   }
@@ -1850,24 +2018,25 @@ var ApiServer = class {
     }
     const [adapterId, adapter] = this.core.adapters.entries().next().value ?? [null, null];
     const channelId = adapterId ?? "api";
-    const session = await this.core.handleNewSession(channelId, agent, workspace);
-    if (adapter) {
-      try {
-        const threadId = await adapter.createSessionThread(session.id, `\u{1F504} ${session.agentName} \u2014 New Session`);
-        session.threadId = threadId;
-        this.core.wireSessionEvents(session, adapter);
-      } catch (err) {
-        log5.warn({ err, sessionId: session.id }, "Failed to create session thread on adapter, running headless");
-      }
-    }
+    const resolvedAgent = agent || config.defaultAgent;
+    const resolvedWorkspace = this.core.configManager.resolveWorkspace(
+      workspace || config.agents[resolvedAgent]?.workingDirectory
+    );
+    const session = await this.core.createSession({
+      channelId,
+      agentName: resolvedAgent,
+      workingDirectory: resolvedWorkspace,
+      createThread: !!adapter,
+      initialName: `\u{1F504} ${resolvedAgent} \u2014 New Session`
+    });
     if (!adapter) {
       session.agentInstance.onPermissionRequest = async (request) => {
         const allowOption = request.options.find((o) => o.isAllow);
-        log5.debug({ sessionId: session.id, permissionId: request.id, option: allowOption?.id }, "Auto-approving permission for API session");
+        log6.debug({ sessionId: session.id, permissionId: request.id, option: allowOption?.id }, "Auto-approving permission for API session");
         return allowOption?.id ?? request.options[0]?.id ?? "";
       };
     }
-    session.warmup().catch((err) => log5.warn({ err, sessionId: session.id }, "API session warmup failed"));
+    session.warmup().catch((err) => log6.warn({ err, sessionId: session.id }, "API session warmup failed"));
     this.sendJson(res, 200, {
       sessionId: session.id,
       agent: session.agentName,
@@ -1949,7 +2118,7 @@ var ApiServer = class {
       return;
     }
     session.dangerousMode = enabled;
-    await this.core.sessionManager.updateSessionDangerousMode(sessionId, enabled);
+    await this.core.sessionManager.patchRecord(sessionId, { dangerousMode: enabled });
     this.sendJson(res, 200, { ok: true, dangerousMode: enabled });
   }
   async handleHealth(res) {
@@ -1977,6 +2146,21 @@ var ApiServer = class {
   async handleVersion(res) {
     this.sendJson(res, 200, { version: getVersion() });
   }
+  async handleGetEditableConfig(res) {
+    const { getSafeFields: getSafeFields2, resolveOptions: resolveOptions2, getConfigValue: getConfigValue2 } = await import("./config-registry-SNKA2EH2.js");
+    const config = this.core.configManager.get();
+    const safeFields = getSafeFields2();
+    const fields = safeFields.map((def) => ({
+      path: def.path,
+      displayName: def.displayName,
+      group: def.group,
+      type: def.type,
+      options: resolveOptions2(def, config),
+      value: getConfigValue2(config, def.path),
+      hotReload: def.hotReload
+    }));
+    this.sendJson(res, 200, { fields });
+  }
   async handleGetConfig(res) {
     const config = this.core.configManager.get();
     this.sendJson(res, 200, { config: redactConfig(config) });
@@ -2017,7 +2201,7 @@ var ApiServer = class {
       return;
     }
     target[lastKey] = value;
-    const { ConfigSchema } = await import("./config-H2DSEHNW.js");
+    const { ConfigSchema } = await import("./config-PCPIBPUA.js");
     const result = ConfigSchema.safeParse(cloned);
     if (!result.success) {
       this.sendJson(res, 400, {
@@ -2033,12 +2217,9 @@ var ApiServer = class {
       updateTarget = updateTarget[parts[i]];
     }
     updateTarget[lastKey] = value;
-    await this.core.configManager.save(updates);
-    const RESTART_PREFIXES = ["api.port", "api.host", "runMode", "channels.", "tunnel.", "agents."];
-    const needsRestart = RESTART_PREFIXES.some(
-      (prefix) => configPath.startsWith(prefix) || configPath === prefix.replace(/\.$/, "")
-      // exact match for non-wildcard
-    );
+    await this.core.configManager.save(updates, configPath);
+    const { isHotReloadable: isHotReloadable2 } = await import("./config-registry-SNKA2EH2.js");
+    const needsRestart = !isHotReloadable2(configPath);
     this.sendJson(res, 200, {
       ok: true,
       needsRestart,
@@ -2097,7 +2278,7 @@ var ApiServer = class {
       this.sendJson(res, 404, { error: `Session "${sessionId}" not found` });
       return;
     }
-    await session.cancel();
+    await session.abortPrompt();
     this.sendJson(res, 200, { ok: true });
   }
   async handleListSessions(res) {
@@ -2206,7 +2387,7 @@ var ApiServer = class {
 };
 
 // src/core/topic-manager.ts
-var log6 = createChildLogger({ module: "topic-manager" });
+var log7 = createChildLogger({ module: "topic-manager" });
 var TopicManager = class {
   constructor(sessionManager, adapter, systemTopicIds) {
     this.sessionManager = sessionManager;
@@ -2245,7 +2426,7 @@ var TopicManager = class {
       try {
         await this.adapter.deleteSessionThread(sessionId);
       } catch (err) {
-        log6.warn({ err, sessionId, topicId }, "Failed to delete platform thread, removing record anyway");
+        log7.warn({ err, sessionId, topicId }, "Failed to delete platform thread, removing record anyway");
       }
     }
     await this.sessionManager.removeRecord(sessionId);
@@ -2268,7 +2449,7 @@ var TopicManager = class {
           try {
             await this.adapter.deleteSessionThread(record.sessionId);
           } catch (err) {
-            log6.warn({ err, sessionId: record.sessionId }, "Failed to delete platform thread during cleanup");
+            log7.warn({ err, sessionId: record.sessionId }, "Failed to delete platform thread during cleanup");
           }
         }
         await this.sessionManager.removeRecord(record.sessionId);
@@ -2289,6 +2470,40 @@ var TopicManager = class {
 // src/adapters/telegram/adapter.ts
 import { Bot } from "grammy";
 
+// src/adapters/telegram/topics.ts
+async function ensureTopics(bot, chatId, config, saveConfig) {
+  let notificationTopicId = config.notificationTopicId;
+  let assistantTopicId = config.assistantTopicId;
+  if (notificationTopicId === null) {
+    const topic = await bot.api.createForumTopic(chatId, "\u{1F4CB} Notifications");
+    notificationTopicId = topic.message_thread_id;
+    await saveConfig({ notificationTopicId });
+  }
+  if (assistantTopicId === null) {
+    const topic = await bot.api.createForumTopic(chatId, "\u{1F916} Assistant");
+    assistantTopicId = topic.message_thread_id;
+    await saveConfig({ assistantTopicId });
+  }
+  return { notificationTopicId, assistantTopicId };
+}
+async function createSessionTopic(bot, chatId, name) {
+  const topic = await bot.api.createForumTopic(chatId, name);
+  return topic.message_thread_id;
+}
+async function renameSessionTopic(bot, chatId, threadId, name) {
+  try {
+    await bot.api.editForumTopic(chatId, threadId, { name });
+  } catch {
+  }
+}
+function buildDeepLink(chatId, messageId) {
+  const cleanId = String(chatId).replace("-100", "");
+  return `https://t.me/c/${cleanId}/${messageId}`;
+}
+
+// src/adapters/telegram/commands/new-session.ts
+import { InlineKeyboard as InlineKeyboard2 } from "grammy";
+
 // src/adapters/telegram/formatting.ts
 function escapeHtml(text) {
   if (!text) return "";
@@ -2452,224 +2667,9 @@ function splitMessage(text, maxLength = 3800) {
   return chunks;
 }
 
-// src/adapters/telegram/streaming.ts
-var FLUSH_INTERVAL = 5e3;
-var MessageDraft = class {
-  constructor(bot, chatId, threadId, sendQueue, sessionId) {
-    this.bot = bot;
-    this.chatId = chatId;
-    this.threadId = threadId;
-    this.sendQueue = sendQueue;
-    this.sessionId = sessionId;
-  }
-  buffer = "";
-  messageId;
-  firstFlushPending = false;
-  flushTimer;
-  flushPromise = Promise.resolve();
-  lastSentBuffer = "";
-  displayTruncated = false;
-  append(text) {
-    if (!text) return;
-    this.buffer += text;
-    this.scheduleFlush();
-  }
-  scheduleFlush() {
-    if (this.flushTimer) return;
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = void 0;
-      this.flushPromise = this.flushPromise.then(() => this.flush()).catch(() => {
-      });
-    }, FLUSH_INTERVAL);
-  }
-  async flush() {
-    if (!this.buffer) return;
-    if (this.firstFlushPending) return;
-    const snapshot = this.buffer;
-    let html = markdownToTelegramHtml(snapshot);
-    if (!html) return;
-    let truncated = false;
-    if (html.length > 4096) {
-      const ratio = 4e3 / html.length;
-      const targetLen = Math.floor(snapshot.length * ratio);
-      let cutAt = snapshot.lastIndexOf("\n", targetLen);
-      if (cutAt < targetLen * 0.5) cutAt = targetLen;
-      html = markdownToTelegramHtml(snapshot.slice(0, cutAt) + "\n\u2026");
-      truncated = true;
-      if (html.length > 4096) {
-        html = html.slice(0, 4090) + "\n\u2026";
-      }
-    }
-    if (!this.messageId) {
-      this.firstFlushPending = true;
-      try {
-        const result = await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(this.chatId, html, {
-            message_thread_id: this.threadId,
-            parse_mode: "HTML",
-            disable_notification: true
-          }),
-          { type: "other" }
-        );
-        if (result) {
-          this.messageId = result.message_id;
-          if (!truncated) {
-            this.lastSentBuffer = snapshot;
-            this.displayTruncated = false;
-          } else {
-            this.displayTruncated = true;
-          }
-        }
-      } catch {
-      } finally {
-        this.firstFlushPending = false;
-      }
-    } else {
-      try {
-        const result = await this.sendQueue.enqueue(
-          () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
-            parse_mode: "HTML"
-          }),
-          { type: "text", key: this.sessionId }
-        );
-        if (result !== void 0) {
-          if (!truncated) {
-            this.lastSentBuffer = snapshot;
-            this.displayTruncated = false;
-          } else {
-            this.displayTruncated = true;
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  async finalize() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
-    await this.flushPromise;
-    if (!this.buffer) return this.messageId;
-    if (this.messageId && this.buffer === this.lastSentBuffer && !this.displayTruncated) {
-      return this.messageId;
-    }
-    const fullHtml = markdownToTelegramHtml(this.buffer);
-    if (fullHtml.length <= 4096) {
-      try {
-        if (this.messageId) {
-          await this.sendQueue.enqueue(
-            () => this.bot.api.editMessageText(this.chatId, this.messageId, fullHtml, {
-              parse_mode: "HTML"
-            }),
-            { type: "other" }
-          );
-        } else {
-          const msg = await this.sendQueue.enqueue(
-            () => this.bot.api.sendMessage(this.chatId, fullHtml, {
-              message_thread_id: this.threadId,
-              parse_mode: "HTML",
-              disable_notification: true
-            }),
-            { type: "other" }
-          );
-          if (msg) this.messageId = msg.message_id;
-        }
-        return this.messageId;
-      } catch {
-      }
-    }
-    const mdChunks = splitMessage(this.buffer);
-    for (let i = 0; i < mdChunks.length; i++) {
-      const html = markdownToTelegramHtml(mdChunks[i]);
-      try {
-        if (i === 0 && this.messageId) {
-          await this.sendQueue.enqueue(
-            () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
-              parse_mode: "HTML"
-            }),
-            { type: "other" }
-          );
-        } else {
-          const msg = await this.sendQueue.enqueue(
-            () => this.bot.api.sendMessage(this.chatId, html, {
-              message_thread_id: this.threadId,
-              parse_mode: "HTML",
-              disable_notification: true
-            }),
-            { type: "other" }
-          );
-          if (msg) {
-            this.messageId = msg.message_id;
-          }
-        }
-      } catch {
-        try {
-          if (i === 0 && this.messageId) {
-            await this.sendQueue.enqueue(
-              () => this.bot.api.editMessageText(this.chatId, this.messageId, mdChunks[i].slice(0, 4096)),
-              { type: "other" }
-            );
-          } else {
-            const msg = await this.sendQueue.enqueue(
-              () => this.bot.api.sendMessage(this.chatId, mdChunks[i].slice(0, 4096), {
-                message_thread_id: this.threadId,
-                disable_notification: true
-              }),
-              { type: "other" }
-            );
-            if (msg) {
-              this.messageId = msg.message_id;
-            }
-          }
-        } catch {
-        }
-      }
-    }
-    return this.messageId;
-  }
-  getMessageId() {
-    return this.messageId;
-  }
-};
-
-// src/adapters/telegram/topics.ts
-async function ensureTopics(bot, chatId, config, saveConfig) {
-  let notificationTopicId = config.notificationTopicId;
-  let assistantTopicId = config.assistantTopicId;
-  if (notificationTopicId === null) {
-    const topic = await bot.api.createForumTopic(chatId, "\u{1F4CB} Notifications");
-    notificationTopicId = topic.message_thread_id;
-    await saveConfig({ notificationTopicId });
-  }
-  if (assistantTopicId === null) {
-    const topic = await bot.api.createForumTopic(chatId, "\u{1F916} Assistant");
-    assistantTopicId = topic.message_thread_id;
-    await saveConfig({ assistantTopicId });
-  }
-  return { notificationTopicId, assistantTopicId };
-}
-async function createSessionTopic(bot, chatId, name) {
-  const topic = await bot.api.createForumTopic(chatId, name);
-  return topic.message_thread_id;
-}
-async function renameSessionTopic(bot, chatId, threadId, name) {
-  try {
-    await bot.api.editForumTopic(chatId, threadId, { name });
-  } catch {
-  }
-}
-function buildDeepLink(chatId, messageId) {
-  const cleanId = String(chatId).replace("-100", "");
-  return `https://t.me/c/${cleanId}/${messageId}`;
-}
-
-// src/adapters/telegram/commands/new-session.ts
-import { InlineKeyboard as InlineKeyboard2 } from "grammy";
-
 // src/adapters/telegram/commands/admin.ts
 import { InlineKeyboard } from "grammy";
-var log8 = createChildLogger({ module: "telegram-cmd-admin" });
+var log9 = createChildLogger({ module: "telegram-cmd-admin" });
 function buildDangerousModeKeyboard(sessionId, enabled) {
   return new InlineKeyboard().text(
     enabled ? "\u{1F510} Disable Dangerous Mode" : "\u2620\uFE0F Enable Dangerous Mode",
@@ -2682,8 +2682,8 @@ function setupDangerousModeCallbacks(bot, core) {
     const session = core.sessionManager.getSession(sessionId);
     if (session) {
       session.dangerousMode = !session.dangerousMode;
-      log8.info({ sessionId, dangerousMode: session.dangerousMode }, "Dangerous mode toggled via button");
-      core.sessionManager.updateSessionDangerousMode(sessionId, session.dangerousMode).catch(() => {
+      log9.info({ sessionId, dangerousMode: session.dangerousMode }, "Dangerous mode toggled via button");
+      core.sessionManager.patchRecord(sessionId, { dangerousMode: session.dangerousMode }).catch(() => {
       });
       const toastText2 = session.dangerousMode ? "\u2620\uFE0F Dangerous mode enabled \u2014 permissions auto-approved" : "\u{1F510} Dangerous mode disabled \u2014 permissions shown normally";
       try {
@@ -2707,9 +2707,9 @@ function setupDangerousModeCallbacks(bot, core) {
       return;
     }
     const newDangerousMode = !(record.dangerousMode ?? false);
-    core.sessionManager.updateSessionDangerousMode(sessionId, newDangerousMode).catch(() => {
+    core.sessionManager.patchRecord(sessionId, { dangerousMode: newDangerousMode }).catch(() => {
     });
-    log8.info({ sessionId, dangerousMode: newDangerousMode }, "Dangerous mode toggled via button (store-only, session not in memory)");
+    log9.info({ sessionId, dangerousMode: newDangerousMode }, "Dangerous mode toggled via button (store-only, session not in memory)");
     const toastText = newDangerousMode ? "\u2620\uFE0F Dangerous mode enabled \u2014 permissions auto-approved" : "\u{1F510} Dangerous mode disabled \u2014 permissions shown normally";
     try {
       await ctx.answerCallbackQuery({ text: toastText });
@@ -2736,7 +2736,7 @@ async function handleEnableDangerous(ctx, core) {
       return;
     }
     session.dangerousMode = true;
-    core.sessionManager.updateSessionDangerousMode(session.id, true).catch(() => {
+    core.sessionManager.patchRecord(session.id, { dangerousMode: true }).catch(() => {
     });
   } else {
     const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
@@ -2748,7 +2748,7 @@ async function handleEnableDangerous(ctx, core) {
       await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
       return;
     }
-    core.sessionManager.updateSessionDangerousMode(record.sessionId, true).catch(() => {
+    core.sessionManager.patchRecord(record.sessionId, { dangerousMode: true }).catch(() => {
     });
   }
   await ctx.reply(
@@ -2773,7 +2773,7 @@ async function handleDisableDangerous(ctx, core) {
       return;
     }
     session.dangerousMode = false;
-    core.sessionManager.updateSessionDangerousMode(session.id, false).catch(() => {
+    core.sessionManager.patchRecord(session.id, { dangerousMode: false }).catch(() => {
     });
   } else {
     const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
@@ -2785,7 +2785,7 @@ async function handleDisableDangerous(ctx, core) {
       await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
       return;
     }
-    core.sessionManager.updateSessionDangerousMode(record.sessionId, false).catch(() => {
+    core.sessionManager.patchRecord(record.sessionId, { dangerousMode: false }).catch(() => {
     });
   }
   await ctx.reply("\u{1F510} <b>Dangerous mode disabled</b>\n\nPermission requests will be shown normally.", { parse_mode: "HTML" });
@@ -2838,7 +2838,7 @@ async function handleRestart(ctx, core) {
 }
 
 // src/adapters/telegram/commands/new-session.ts
-var log9 = createChildLogger({ module: "telegram-cmd-new-session" });
+var log10 = createChildLogger({ module: "telegram-cmd-new-session" });
 var pendingNewSessions = /* @__PURE__ */ new Map();
 var PENDING_TIMEOUT_MS = 5 * 60 * 1e3;
 function cleanupPending(userId) {
@@ -2870,37 +2870,12 @@ async function handleNew(ctx, core, chatId, assistant) {
       return;
     }
   }
-  const userId = ctx.from?.id;
-  if (!userId) return;
-  const agents = core.agentManager.getAvailableAgents();
-  const config = core.configManager.get();
-  if (agentName || agents.length === 1) {
-    const selectedAgent = agentName || config.defaultAgent;
-    await startWorkspaceStep(ctx, core, chatId, userId, selectedAgent);
-    return;
-  }
-  const keyboard = new InlineKeyboard2();
-  for (const agent of agents) {
-    const label = agent.name === config.defaultAgent ? `${agent.name} (default)` : agent.name;
-    keyboard.text(label, `m:new:agent:${agent.name}`).row();
-  }
-  keyboard.text("\u274C Cancel", "m:new:cancel");
-  const msg = await ctx.reply(
-    `\u{1F916} <b>Choose an agent:</b>`,
-    { parse_mode: "HTML", reply_markup: keyboard }
-  );
-  cleanupPending(userId);
-  pendingNewSessions.set(userId, {
-    step: "agent",
-    messageId: msg.message_id,
-    threadId: currentThreadId,
-    timer: setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS)
-  });
+  await showAgentPicker(ctx, core, chatId, agentName);
 }
 async function startWorkspaceStep(ctx, core, chatId, userId, agentName) {
   const config = core.configManager.get();
   const baseDir = config.workspace.baseDir;
-  const keyboard = new InlineKeyboard2().text(`\u{1F4C1} Use ${baseDir}`, "m:new:ws:default").row().text("\u270F\uFE0F Enter project path", "m:new:ws:custom").row().text("\u274C Cancel", "m:new:cancel");
+  const keyboard = new InlineKeyboard2().text(`\u{1F4C1} Use ${baseDir}`, "m:new:ws:default").row().text("\u270F\uFE0F Enter project path", "m:new:ws:custom");
   const text = `\u{1F4C1} <b>Where should ${escapeHtml(agentName)} work?</b>
 
 Enter the path to your project folder \u2014 the agent will read, write, and run code there.
@@ -2962,7 +2937,7 @@ async function startConfirmStep(ctx, chatId, userId, agentName, workspace) {
   });
 }
 async function createSessionDirect(ctx, core, chatId, agentName, workspace) {
-  log9.info({ userId: ctx.from?.id, agentName, workspace }, "New session command (direct)");
+  log10.info({ userId: ctx.from?.id, agentName, workspace }, "New session command (direct)");
   let threadId;
   try {
     const topicName = `\u{1F504} New Session`;
@@ -2973,7 +2948,7 @@ async function createSessionDirect(ctx, core, chatId, agentName, workspace) {
     });
     const session = await core.handleNewSession("telegram", agentName, workspace);
     session.threadId = String(threadId);
-    await core.sessionManager.updateSessionPlatform(session.id, { topicId: threadId });
+    await core.sessionManager.patchRecord(session.id, { platform: { topicId: threadId } });
     const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
     try {
       await ctx.api.editForumTopic(chatId, threadId, { name: finalName });
@@ -2992,10 +2967,10 @@ This is your coding session \u2014 chat here to work with the agent.`,
         reply_markup: buildDangerousModeKeyboard(session.id, false)
       }
     );
-    session.warmup().catch((err) => log9.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log10.error({ err }, "Warm-up error"));
     return threadId ?? null;
   } catch (err) {
-    log9.error({ err }, "Session creation failed");
+    log10.error({ err }, "Session creation failed");
     if (threadId) {
       try {
         await ctx.api.deleteForumTopic(chatId, threadId);
@@ -3059,9 +3034,9 @@ async function handleNewChat(ctx, core, chatId) {
       workspace
     );
     session.threadId = String(newThreadId);
-    await core.sessionManager.updateSessionPlatform(session.id, {
+    await core.sessionManager.patchRecord(session.id, { platform: {
       topicId: newThreadId
-    });
+    } });
     await ctx.api.sendMessage(
       chatId,
       `\u2705 New chat (same agent &amp; workspace)
@@ -3073,7 +3048,7 @@ async function handleNewChat(ctx, core, chatId) {
         reply_markup: buildDangerousModeKeyboard(session.id, false)
       }
     );
-    session.warmup().catch((err) => log9.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log10.error({ err }, "Warm-up error"));
   } catch (err) {
     if (newThreadId) {
       try {
@@ -3099,12 +3074,12 @@ async function executeNewSession(bot, core, chatId, agentName, workspace) {
       workspace
     );
     session.threadId = String(threadId);
-    await core.sessionManager.updateSessionPlatform(session.id, {
+    await core.sessionManager.patchRecord(session.id, { platform: {
       topicId: threadId
-    });
+    } });
     const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
     await renameSessionTopic(bot, chatId, threadId, finalName);
-    session.warmup().catch((err) => log9.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log10.error({ err }, "Warm-up error"));
     return { session, threadId, firstMsgId };
   } catch (err) {
     try {
@@ -3135,30 +3110,35 @@ async function handlePendingWorkspaceInput(ctx, core, chatId, assistantTopicId)
   return true;
 }
 async function startInteractiveNewSession(ctx, core, chatId, agentName) {
+  await showAgentPicker(ctx, core, chatId, agentName);
+}
+async function showAgentPicker(ctx, core, chatId, agentName) {
   const userId = ctx.from?.id;
   if (!userId) return;
-  const agents = core.agentManager.getAvailableAgents();
+  const installedEntries = core.agentCatalog.getInstalledEntries();
+  const agentKeys = Object.keys(installedEntries);
   const config = core.configManager.get();
-  if (agentName || agents.length === 1) {
+  if (agentName || agentKeys.length === 1) {
     const selectedAgent = agentName || config.defaultAgent;
     await startWorkspaceStep(ctx, core, chatId, userId, selectedAgent);
     return;
   }
   const keyboard = new InlineKeyboard2();
-  for (const agent of agents) {
-    const label = agent.name === config.defaultAgent ? `${agent.name} (default)` : agent.name;
-    keyboard.text(label, `m:new:agent:${agent.name}`).row();
+  for (const key of agentKeys) {
+    const agent = installedEntries[key];
+    const label = key === config.defaultAgent ? `${agent.name} (default)` : agent.name;
+    keyboard.text(label, `m:new:agent:${key}`).row();
   }
-  keyboard.text("\u274C Cancel", "m:new:cancel");
   const msg = await ctx.reply(
     `\u{1F916} <b>Choose an agent:</b>`,
     { parse_mode: "HTML", reply_markup: keyboard }
   );
   cleanupPending(userId);
+  const threadId = ctx.message?.message_thread_id ?? ctx.callbackQuery?.message?.message_thread_id;
   pendingNewSessions.set(userId, {
     step: "agent",
     messageId: msg.message_id,
-    threadId: ctx.callbackQuery?.message?.message_thread_id,
+    threadId,
     timer: setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS)
   });
 }
@@ -3247,7 +3227,7 @@ Or just the folder name like <code>my-project</code> (will use ${core.configMana
 
 // src/adapters/telegram/commands/session.ts
 import { InlineKeyboard as InlineKeyboard3 } from "grammy";
-var log10 = createChildLogger({ module: "telegram-cmd-session" });
+var log11 = createChildLogger({ module: "telegram-cmd-session" });
 async function handleCancel(ctx, core, assistant) {
   const threadId = ctx.message?.message_thread_id;
   if (!threadId) return;
@@ -3265,14 +3245,14 @@ async function handleCancel(ctx, core, assistant) {
     String(threadId)
   );
   if (session) {
-    log10.info({ sessionId: session.id }, "Cancel session command");
-    await session.cancel();
+    log11.info({ sessionId: session.id }, "Cancel session command");
+    await session.abortPrompt();
     await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
     return;
   }
   const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
   if (record && record.status !== "cancelled" && record.status !== "error") {
-    log10.info({ sessionId: record.sessionId }, "Cancel session command (from store)");
+    log11.info({ sessionId: record.sessionId }, "Cancel session command (from store)");
     await core.sessionManager.cancelSession(record.sessionId);
     await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
   }
@@ -3356,8 +3336,8 @@ async function handleTopics(ctx, core) {
     const truncated = records.length > MAX_DISPLAY ? `
 
 <i>...and ${records.length - MAX_DISPLAY} more</i>` : "";
-    const finishedCount = records.filter((r) => r.status === "finished").length;
-    const errorCount = records.filter((r) => r.status === "error" || r.status === "cancelled").length;
+    const finishedCount = allRecords.filter((r) => r.status === "finished").length;
+    const errorCount = allRecords.filter((r) => r.status === "error" || r.status === "cancelled").length;
     const keyboard = new InlineKeyboard3();
     if (finishedCount > 0) {
       keyboard.text(`Cleanup finished (${finishedCount})`, "m:cleanup:finished").row();
@@ -3368,7 +3348,7 @@ async function handleTopics(ctx, core) {
     if (finishedCount + errorCount > 0) {
       keyboard.text(`Cleanup all non-active (${finishedCount + errorCount})`, "m:cleanup:all").row();
     }
-    keyboard.text(`\u26A0\uFE0F Cleanup ALL (${records.length})`, "m:cleanup:everything").row();
+    keyboard.text(`\u26A0\uFE0F Cleanup ALL (${allRecords.length})`, "m:cleanup:everything").row();
     keyboard.text("Refresh", "m:topics");
     await ctx.reply(
       `${header}
@@ -3377,17 +3357,14 @@ ${lines.join("\n")}${truncated}`,
       { parse_mode: "HTML", reply_markup: keyboard }
     );
   } catch (err) {
-    log10.error({ err }, "handleTopics error");
+    log11.error({ err }, "handleTopics error");
     await ctx.reply("\u274C Failed to list sessions.", { parse_mode: "HTML" }).catch(() => {
     });
   }
 }
 async function handleCleanup(ctx, core, chatId, statuses) {
   const allRecords = core.sessionManager.listRecords();
-  const cleanable = allRecords.filter((r) => {
-    const platform = r.platform;
-    return !!platform?.topicId && statuses.includes(r.status);
-  });
+  const cleanable = allRecords.filter((r) => statuses.includes(r.status));
   if (cleanable.length === 0) {
     await ctx.reply("Nothing to clean up.", { parse_mode: "HTML" });
     return;
@@ -3401,13 +3378,13 @@ async function handleCleanup(ctx, core, chatId, statuses) {
         try {
           await ctx.api.deleteForumTopic(chatId, topicId);
         } catch (err) {
-          log10.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
+          log11.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
         }
       }
       await core.sessionManager.removeRecord(record.sessionId);
       deleted++;
     } catch (err) {
-      log10.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
+      log11.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
       failed++;
     }
   }
@@ -3420,8 +3397,7 @@ async function handleCleanupEverything(ctx, core, chatId, systemTopicIds) {
   const allRecords = core.sessionManager.listRecords();
   const cleanable = allRecords.filter((r) => {
     const platform = r.platform;
-    if (!platform?.topicId) return false;
-    if (systemTopicIds && (platform.topicId === systemTopicIds.notificationTopicId || platform.topicId === systemTopicIds.assistantTopicId)) return false;
+    if (systemTopicIds && platform?.topicId && (platform.topicId === systemTopicIds.notificationTopicId || platform.topicId === systemTopicIds.assistantTopicId)) return false;
     return true;
   });
   if (cleanable.length === 0) {
@@ -3464,8 +3440,7 @@ async function handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicId
   const allRecords = core.sessionManager.listRecords();
   const cleanable = allRecords.filter((r) => {
     const platform = r.platform;
-    if (!platform?.topicId) return false;
-    if (systemTopicIds && (platform.topicId === systemTopicIds.notificationTopicId || platform.topicId === systemTopicIds.assistantTopicId)) return false;
+    if (systemTopicIds && platform?.topicId && (platform.topicId === systemTopicIds.notificationTopicId || platform.topicId === systemTopicIds.assistantTopicId)) return false;
     return true;
   });
   if (cleanable.length === 0) {
@@ -3480,7 +3455,7 @@ async function handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicId
         try {
           await core.sessionManager.cancelSession(record.sessionId);
         } catch (err) {
-          log10.warn({ err, sessionId: record.sessionId }, "Failed to cancel session during cleanup");
+          log11.warn({ err, sessionId: record.sessionId }, "Failed to cancel session during cleanup");
         }
       }
       const topicId = record.platform?.topicId;
@@ -3488,13 +3463,13 @@ async function handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicId
         try {
           await ctx.api.deleteForumTopic(chatId, topicId);
         } catch (err) {
-          log10.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
+          log11.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
         }
       }
       await core.sessionManager.removeRecord(record.sessionId);
       deleted++;
     } catch (err) {
-      log10.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
+      log11.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
       failed++;
     }
   }
@@ -3507,7 +3482,7 @@ async function executeCancelSession(core, excludeSessionId) {
   const sessions = core.sessionManager.listSessions("telegram").filter((s) => s.status === "active" && s.id !== excludeSessionId).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
   const session = sessions[0];
   if (!session) return null;
-  await session.cancel();
+  await session.abortPrompt();
   return session;
 }
 function setupSessionCallbacks(bot, core, chatId, systemTopicIds) {
@@ -3537,100 +3512,213 @@ function setupSessionCallbacks(bot, core, chatId, systemTopicIds) {
   });
 }
 
-// src/adapters/telegram/commands/menu.ts
+// src/adapters/telegram/commands/agents.ts
 import { InlineKeyboard as InlineKeyboard4 } from "grammy";
-function buildMenuKeyboard() {
-  return new InlineKeyboard4().text("\u{1F195} New Session", "m:new").text("\u{1F4CB} Sessions", "m:topics").row().text("\u{1F4CA} Status", "m:status").text("\u{1F916} Agents", "m:agents").row().text("\u{1F517} Integrate", "m:integrate").text("\u2753 Help", "m:help").row().text("\u{1F504} Restart", "m:restart").text("\u2B06\uFE0F Update", "m:update");
-}
-async function handleMenu(ctx) {
-  await ctx.reply(`<b>OpenACP Menu</b>
-Choose an action:`, {
-    parse_mode: "HTML",
-    reply_markup: buildMenuKeyboard()
-  });
+var AGENTS_PER_PAGE = 6;
+async function handleAgents(ctx, core, page = 0) {
+  const catalog = core.agentCatalog;
+  const items = catalog.getAvailable();
+  const installed = items.filter((i) => i.installed);
+  const available = items.filter((i) => !i.installed);
+  let text = "<b>\u{1F916} Agents</b>\n\n";
+  if (installed.length > 0) {
+    text += "<b>Installed:</b>\n";
+    for (const item of installed) {
+      text += `\u2705 <b>${escapeHtml(item.name)}</b>`;
+      if (item.description) {
+        text += ` \u2014 <i>${escapeHtml(truncate(item.description, 50))}</i>`;
+      }
+      text += "\n";
+    }
+    text += "\n";
+  }
+  if (available.length > 0) {
+    const totalPages = Math.ceil(available.length / AGENTS_PER_PAGE);
+    const safePage = Math.max(0, Math.min(page, totalPages - 1));
+    const pageItems = available.slice(safePage * AGENTS_PER_PAGE, (safePage + 1) * AGENTS_PER_PAGE);
+    text += `<b>Available to install:</b>`;
+    if (totalPages > 1) {
+      text += ` (${safePage + 1}/${totalPages})`;
+    }
+    text += "\n";
+    for (const item of pageItems) {
+      if (item.available) {
+        text += `\u2B07\uFE0F <b>${escapeHtml(item.name)}</b>`;
+      } else {
+        const deps = item.missingDeps?.join(", ") ?? "requirements not met";
+        text += `\u26A0\uFE0F <b>${escapeHtml(item.name)}</b> <i>(needs: ${escapeHtml(deps)})</i>`;
+      }
+      if (item.description) {
+        text += `
+    <i>${escapeHtml(truncate(item.description, 60))}</i>`;
+      }
+      text += "\n";
+    }
+    const keyboard = new InlineKeyboard4();
+    const installable = pageItems.filter((i) => i.available);
+    for (let i = 0; i < installable.length; i += 2) {
+      const row = installable.slice(i, i + 2);
+      for (const item of row) {
+        keyboard.text(`\u2B07\uFE0F ${item.name}`, `ag:install:${item.key}`);
+      }
+      keyboard.row();
+    }
+    if (totalPages > 1) {
+      if (safePage > 0) {
+        keyboard.text("\u25C0\uFE0F Prev", `ag:page:${safePage - 1}`);
+      }
+      if (safePage < totalPages - 1) {
+        keyboard.text("Next \u25B6\uFE0F", `ag:page:${safePage + 1}`);
+      }
+      keyboard.row();
+    }
+    if (available.some((i) => !i.available)) {
+      text += "\n\u{1F4A1} <i>Agents marked \u26A0\uFE0F need additional setup. Use</i> <code>openacp agents info &lt;name&gt;</code> <i>for details.</i>\n";
+    }
+    await ctx.reply(text, { parse_mode: "HTML", reply_markup: keyboard });
+  } else {
+    text += "<i>All agents are already installed!</i>";
+    await ctx.reply(text, { parse_mode: "HTML" });
+  }
 }
-async function handleAgents(ctx, core) {
-  const agents = core.agentManager.getAvailableAgents();
-  const defaultAgent = core.configManager.get().defaultAgent;
-  const lines = agents.map(
-    (a) => `\u2022 <b>${escapeHtml(a.name)}</b>${a.name === defaultAgent ? " (default)" : ""}
-  <code>${escapeHtml(a.command)} ${a.args.map((arg) => escapeHtml(arg)).join(" ")}</code>`
-  );
-  const text = lines.length > 0 ? `<b>Available Agents:</b>
-
-${lines.join("\n")}` : `<b>Available Agents:</b>
-
-No agents configured.`;
-  await ctx.reply(text, { parse_mode: "HTML" });
+async function handleInstall(ctx, core) {
+  const text = (ctx.message?.text ?? "").trim();
+  const parts = text.split(/\s+/);
+  const nameOrId = parts[1];
+  if (!nameOrId) {
+    await ctx.reply(
+      "\u{1F4E6} <b>Install an agent</b>\n\nUsage: <code>/install &lt;agent-name&gt;</code>\nExample: <code>/install gemini</code>\n\nUse /agents to browse available agents.",
+      { parse_mode: "HTML" }
+    );
+    return;
+  }
+  await installAgentWithProgress(ctx, core, nameOrId);
 }
-async function handleHelp(ctx) {
-  await ctx.reply(
-    `\u{1F4D6} <b>OpenACP Help</b>
-
-\u{1F680} <b>Getting Started</b>
-Tap \u{1F195} New Session to start coding with AI.
-Each session gets its own topic \u2014 chat there to work with the agent.
-
-\u{1F4A1} <b>Common Tasks</b>
-/new [agent] [workspace] \u2014 Create new session
-/cancel \u2014 Cancel session (in session topic)
-/status \u2014 Show session or system status
-/sessions \u2014 List all sessions
-/agents \u2014 List available agents
-
-\u2699\uFE0F <b>System</b>
-/restart \u2014 Restart OpenACP
-/update \u2014 Update to latest version
-/integrate \u2014 Manage agent integrations
-/menu \u2014 Show action menu
-
-\u{1F512} <b>Session Options</b>
-/enable_dangerous \u2014 Auto-approve permissions
-/disable_dangerous \u2014 Restore permission prompts
-/handoff \u2014 Continue session in terminal
-/clear \u2014 Clear assistant history
-
-\u{1F4AC} Need help? Just ask me in this topic!`,
-    { parse_mode: "HTML" }
-  );
-}
-async function handleClear(ctx, assistant) {
-  if (!assistant) {
-    await ctx.reply("\u26A0\uFE0F Assistant is not available.", { parse_mode: "HTML" });
-    return;
-  }
-  const threadId = ctx.message?.message_thread_id;
-  if (threadId !== assistant.topicId) {
-    await ctx.reply("\u2139\uFE0F /clear only works in the Assistant topic.", { parse_mode: "HTML" });
+async function handleAgentCallback(ctx, core) {
+  const data = ctx.callbackQuery?.data ?? "";
+  await ctx.answerCallbackQuery();
+  if (data.startsWith("ag:install:")) {
+    const nameOrId = data.replace("ag:install:", "");
+    await installAgentWithProgress(ctx, core, nameOrId);
     return;
   }
-  await ctx.reply("\u{1F504} Clearing assistant history...", { parse_mode: "HTML" });
-  try {
-    await assistant.respawn();
-    await ctx.reply("\u2705 Assistant history cleared.", { parse_mode: "HTML" });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    await ctx.reply(`\u274C Failed to clear: <code>${message}</code>`, { parse_mode: "HTML" });
+  if (data.startsWith("ag:page:")) {
+    const page = parseInt(data.replace("ag:page:", ""), 10);
+    try {
+      const catalog = core.agentCatalog;
+      const items = catalog.getAvailable();
+      const installed = items.filter((i) => i.installed);
+      const available = items.filter((i) => !i.installed);
+      let text = "<b>\u{1F916} Agents</b>\n\n";
+      if (installed.length > 0) {
+        text += "<b>Installed:</b>\n";
+        for (const item of installed) {
+          text += `\u2705 <b>${escapeHtml(item.name)}</b>`;
+          if (item.description) {
+            text += ` \u2014 <i>${escapeHtml(truncate(item.description, 50))}</i>`;
+          }
+          text += "\n";
+        }
+        text += "\n";
+      }
+      const totalPages = Math.ceil(available.length / AGENTS_PER_PAGE);
+      const safePage = Math.max(0, Math.min(page, totalPages - 1));
+      const pageItems = available.slice(safePage * AGENTS_PER_PAGE, (safePage + 1) * AGENTS_PER_PAGE);
+      text += `<b>Available to install:</b>`;
+      if (totalPages > 1) {
+        text += ` (${safePage + 1}/${totalPages})`;
+      }
+      text += "\n";
+      for (const item of pageItems) {
+        if (item.available) {
+          text += `\u2B07\uFE0F <b>${escapeHtml(item.name)}</b>`;
+        } else {
+          const deps = item.missingDeps?.join(", ") ?? "requirements not met";
+          text += `\u26A0\uFE0F <b>${escapeHtml(item.name)}</b> <i>(needs: ${escapeHtml(deps)})</i>`;
+        }
+        if (item.description) {
+          text += `
+    <i>${escapeHtml(truncate(item.description, 60))}</i>`;
+        }
+        text += "\n";
+      }
+      const keyboard = new InlineKeyboard4();
+      const installable = pageItems.filter((i) => i.available);
+      for (let i = 0; i < installable.length; i += 2) {
+        const row = installable.slice(i, i + 2);
+        for (const item of row) {
+          keyboard.text(`\u2B07\uFE0F ${item.name}`, `ag:install:${item.key}`);
+        }
+        keyboard.row();
+      }
+      if (totalPages > 1) {
+        if (safePage > 0) {
+          keyboard.text("\u25C0\uFE0F Prev", `ag:page:${safePage - 1}`);
+        }
+        if (safePage < totalPages - 1) {
+          keyboard.text("Next \u25B6\uFE0F", `ag:page:${safePage + 1}`);
+        }
+        keyboard.row();
+      }
+      await ctx.editMessageText(text, { parse_mode: "HTML", reply_markup: keyboard });
+    } catch {
+    }
   }
 }
-var TELEGRAM_MSG_LIMIT = 4096;
-function buildSkillMessages(commands) {
-  const sorted = [...commands].sort((a, b) => a.name.localeCompare(b.name));
-  const header = "\u{1F6E0} <b>Available Skills</b>\n";
-  const lines = sorted.map((c) => `<code>/${c.name}</code>`);
-  const messages = [];
-  let current = header;
-  for (const line of lines) {
-    const candidate = current + "\n" + line;
-    if (candidate.length > TELEGRAM_MSG_LIMIT) {
-      messages.push(current);
-      current = line;
-    } else {
-      current = candidate;
+async function installAgentWithProgress(ctx, core, nameOrId) {
+  const catalog = core.agentCatalog;
+  const msg = await ctx.reply(`\u23F3 Installing <b>${escapeHtml(nameOrId)}</b>...`, { parse_mode: "HTML" });
+  let lastEdit = 0;
+  const EDIT_THROTTLE_MS = 1500;
+  const progress = {
+    onStart(_id, _name) {
+    },
+    async onStep(step) {
+      const now = Date.now();
+      if (now - lastEdit > EDIT_THROTTLE_MS) {
+        lastEdit = now;
+        try {
+          await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u23F3 <b>${escapeHtml(nameOrId)}</b>: ${escapeHtml(step)}`, { parse_mode: "HTML" });
+        } catch {
+        }
+      }
+    },
+    async onDownloadProgress(percent) {
+      const now = Date.now();
+      if (now - lastEdit > EDIT_THROTTLE_MS) {
+        lastEdit = now;
+        try {
+          const bar = buildProgressBar(percent);
+          await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u23F3 <b>${escapeHtml(nameOrId)}</b>
+Downloading... ${bar} ${percent}%`, { parse_mode: "HTML" });
+        } catch {
+        }
+      }
+    },
+    async onSuccess(name) {
+      try {
+        const keyboard = new InlineKeyboard4().text(`\u{1F680} Start session with ${name}`, `na:${nameOrId}`);
+        await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u2705 <b>${escapeHtml(name)}</b> installed!`, { parse_mode: "HTML", reply_markup: keyboard });
+      } catch {
+      }
+    },
+    async onError(error) {
+      try {
+        await ctx.api.editMessageText(msg.chat.id, msg.message_id, `\u274C ${escapeHtml(error)}`, { parse_mode: "HTML" });
+      } catch {
+      }
     }
-  }
-  if (current) messages.push(current);
-  return messages;
+  };
+  await catalog.install(nameOrId, progress);
+}
+function truncate(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 1) + "\u2026";
+}
+function buildProgressBar(percent) {
+  const filled = Math.round(percent / 10);
+  const empty = 10 - filled;
+  return "\u2588".repeat(filled) + "\u2591".repeat(empty);
 }
 
 // src/adapters/telegram/commands/integrate.ts
@@ -3751,6 +3839,298 @@ ${resultText}`,
   });
 }
 
+// src/adapters/telegram/commands/settings.ts
+import { InlineKeyboard as InlineKeyboard6 } from "grammy";
+var log12 = createChildLogger({ module: "telegram-settings" });
+function buildSettingsKeyboard(core) {
+  const config = core.configManager.get();
+  const fields = getSafeFields();
+  const kb = new InlineKeyboard6();
+  for (const field of fields) {
+    const value = getConfigValue(config, field.path);
+    const label = formatFieldLabel(field, value);
+    if (field.type === "toggle") {
+      kb.text(`${label}`, `s:toggle:${field.path}`).row();
+    } else if (field.type === "select") {
+      kb.text(`${label}`, `s:select:${field.path}`).row();
+    } else {
+      kb.text(`${label}`, `s:input:${field.path}`).row();
+    }
+  }
+  kb.text("\u25C0\uFE0F Back to Menu", "s:back");
+  return kb;
+}
+function formatFieldLabel(field, value) {
+  const icons = {
+    agent: "\u{1F916}",
+    logging: "\u{1F4DD}",
+    tunnel: "\u{1F517}",
+    security: "\u{1F512}",
+    workspace: "\u{1F4C1}",
+    storage: "\u{1F4BE}"
+  };
+  const icon = icons[field.group] ?? "\u2699\uFE0F";
+  if (field.type === "toggle") {
+    return `${icon} ${field.displayName}: ${value ? "ON" : "OFF"}`;
+  }
+  return `${icon} ${field.displayName}: ${String(value)}`;
+}
+async function handleSettings(ctx, core) {
+  const kb = buildSettingsKeyboard(core);
+  await ctx.reply(`<b>\u2699\uFE0F Settings</b>
+Tap to change:`, {
+    parse_mode: "HTML",
+    reply_markup: kb
+  });
+}
+function setupSettingsCallbacks(bot, core, getAssistantSession) {
+  bot.callbackQuery(/^s:toggle:/, async (ctx) => {
+    const fieldPath = ctx.callbackQuery.data.replace("s:toggle:", "");
+    const config = core.configManager.get();
+    const currentValue = getConfigValue(config, fieldPath);
+    const newValue = !currentValue;
+    try {
+      const updates = buildNestedUpdate(fieldPath, newValue);
+      await core.configManager.save(updates, fieldPath);
+      const toast = isHotReloadable(fieldPath) ? `\u2705 ${fieldPath} = ${newValue}` : `\u2705 ${fieldPath} = ${newValue} (restart needed)`;
+      try {
+        await ctx.answerCallbackQuery({ text: toast });
+      } catch {
+      }
+      try {
+        await ctx.editMessageReplyMarkup({ reply_markup: buildSettingsKeyboard(core) });
+      } catch {
+      }
+    } catch (err) {
+      log12.error({ err, fieldPath }, "Failed to toggle config");
+      try {
+        await ctx.answerCallbackQuery({ text: "\u274C Failed to update" });
+      } catch {
+      }
+    }
+  });
+  bot.callbackQuery(/^s:select:/, async (ctx) => {
+    const fieldPath = ctx.callbackQuery.data.replace("s:select:", "");
+    const config = core.configManager.get();
+    const fieldDef = getSafeFields().find((f) => f.path === fieldPath);
+    if (!fieldDef) return;
+    const options = resolveOptions(fieldDef, config) ?? [];
+    const currentValue = getConfigValue(config, fieldPath);
+    const kb = new InlineKeyboard6();
+    for (const opt of options) {
+      const marker = opt === String(currentValue) ? " \u2713" : "";
+      kb.text(`${opt}${marker}`, `s:pick:${fieldPath}:${opt}`).row();
+    }
+    kb.text("\u25C0\uFE0F Back", "s:back:refresh");
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    try {
+      await ctx.editMessageText(`<b>\u2699\uFE0F ${fieldDef.displayName}</b>
+Select a value:`, {
+        parse_mode: "HTML",
+        reply_markup: kb
+      });
+    } catch {
+    }
+  });
+  bot.callbackQuery(/^s:pick:/, async (ctx) => {
+    const parts = ctx.callbackQuery.data.replace("s:pick:", "").split(":");
+    const fieldPath = parts.slice(0, -1).join(":");
+    const newValue = parts[parts.length - 1];
+    try {
+      const updates = buildNestedUpdate(fieldPath, newValue);
+      await core.configManager.save(updates, fieldPath);
+      try {
+        await ctx.answerCallbackQuery({ text: `\u2705 ${fieldPath} = ${newValue}` });
+      } catch {
+      }
+      try {
+        await ctx.editMessageText(`<b>\u2699\uFE0F Settings</b>
+Tap to change:`, {
+          parse_mode: "HTML",
+          reply_markup: buildSettingsKeyboard(core)
+        });
+      } catch {
+      }
+    } catch (err) {
+      log12.error({ err, fieldPath }, "Failed to set config");
+      try {
+        await ctx.answerCallbackQuery({ text: "\u274C Failed to update" });
+      } catch {
+      }
+    }
+  });
+  bot.callbackQuery(/^s:input:/, async (ctx) => {
+    const fieldPath = ctx.callbackQuery.data.replace("s:input:", "");
+    const config = core.configManager.get();
+    const fieldDef = getSafeFields().find((f) => f.path === fieldPath);
+    if (!fieldDef) return;
+    const currentValue = getConfigValue(config, fieldPath);
+    const assistant = getAssistantSession();
+    if (!assistant) {
+      try {
+        await ctx.answerCallbackQuery({ text: "\u26A0\uFE0F Start the assistant first (/assistant)" });
+      } catch {
+      }
+      return;
+    }
+    try {
+      await ctx.answerCallbackQuery({ text: `Delegating to assistant...` });
+    } catch {
+    }
+    const prompt = `User wants to change ${fieldDef.displayName} (config path: ${fieldPath}). Current value: ${JSON.stringify(currentValue)}. Ask them for the new value and apply it using: openacp config set ${fieldPath} <value>`;
+    await assistant.enqueuePrompt(prompt);
+  });
+  bot.callbackQuery("s:back", async (ctx) => {
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    const { buildMenuKeyboard: buildMenuKeyboard3 } = await import("./menu-6RCPBVGQ.js");
+    try {
+      await ctx.editMessageText(`<b>OpenACP Menu</b>
+Choose an action:`, {
+        parse_mode: "HTML",
+        reply_markup: buildMenuKeyboard3()
+      });
+    } catch {
+    }
+  });
+  bot.callbackQuery("s:back:refresh", async (ctx) => {
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    try {
+      await ctx.editMessageText(`<b>\u2699\uFE0F Settings</b>
+Tap to change:`, {
+        parse_mode: "HTML",
+        reply_markup: buildSettingsKeyboard(core)
+      });
+    } catch {
+    }
+  });
+}
+function buildNestedUpdate(dotPath, value) {
+  const parts = dotPath.split(".");
+  const result = {};
+  let target = result;
+  for (let i = 0; i < parts.length - 1; i++) {
+    target[parts[i]] = {};
+    target = target[parts[i]];
+  }
+  target[parts[parts.length - 1]] = value;
+  return result;
+}
+
+// src/adapters/telegram/commands/doctor.ts
+import { InlineKeyboard as InlineKeyboard7 } from "grammy";
+var log13 = createChildLogger({ module: "telegram-cmd-doctor" });
+var pendingFixesStore = /* @__PURE__ */ new Map();
+function renderReport(report) {
+  const icons = { pass: "\u2705", warn: "\u26A0\uFE0F", fail: "\u274C" };
+  const lines = ["\u{1FA7A} <b>OpenACP Doctor</b>\n"];
+  for (const category of report.categories) {
+    lines.push(`<b>${category.name}</b>`);
+    for (const result of category.results) {
+      lines.push(`  ${icons[result.status]} ${escapeHtml2(result.message)}`);
+    }
+    lines.push("");
+  }
+  const { passed, warnings, failed, fixed } = report.summary;
+  const fixedStr = fixed > 0 ? `, ${fixed} fixed` : "";
+  lines.push(`<b>Result:</b> ${passed} passed, ${warnings} warnings, ${failed} failed${fixedStr}`);
+  let keyboard;
+  if (report.pendingFixes.length > 0) {
+    keyboard = new InlineKeyboard7();
+    for (let i = 0; i < report.pendingFixes.length; i++) {
+      const label = `\u{1F527} Fix: ${report.pendingFixes[i].message.slice(0, 30)}`;
+      keyboard.text(label, `m:doctor:fix:${i}`).row();
+    }
+  }
+  return { text: lines.join("\n"), keyboard };
+}
+function escapeHtml2(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+async function handleDoctor(ctx) {
+  const statusMsg = await ctx.reply("\u{1FA7A} Running diagnostics...", { parse_mode: "HTML" });
+  try {
+    const engine = new DoctorEngine();
+    const report = await engine.runAll();
+    const { text, keyboard } = renderReport(report);
+    const storeKey = `${ctx.chat.id}:${statusMsg.message_id}`;
+    if (report.pendingFixes.length > 0) {
+      pendingFixesStore.set(storeKey, report.pendingFixes);
+    }
+    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, text, {
+      parse_mode: "HTML",
+      reply_markup: keyboard
+    });
+  } catch (err) {
+    log13.error({ err }, "Doctor command failed");
+    await ctx.api.editMessageText(
+      ctx.chat.id,
+      statusMsg.message_id,
+      `\u274C Doctor failed: ${err instanceof Error ? err.message : String(err)}`,
+      { parse_mode: "HTML" }
+    );
+  }
+}
+function setupDoctorCallbacks(bot) {
+  bot.callbackQuery(/^m:doctor:fix:/, async (ctx) => {
+    const data = ctx.callbackQuery.data;
+    const index = parseInt(data.replace("m:doctor:fix:", ""), 10);
+    const chatId = ctx.callbackQuery.message?.chat.id;
+    const messageId = ctx.callbackQuery.message?.message_id;
+    try {
+      await ctx.answerCallbackQuery({ text: "Applying fix..." });
+    } catch {
+    }
+    if (chatId === void 0 || messageId === void 0) return;
+    const storeKey = `${chatId}:${messageId}`;
+    const fixes = pendingFixesStore.get(storeKey);
+    if (!fixes || index < 0 || index >= fixes.length) {
+      try {
+        await ctx.answerCallbackQuery({ text: "Fix no longer available" });
+      } catch {
+      }
+      return;
+    }
+    const pending = fixes[index];
+    try {
+      const result = await pending.fix();
+      if (result.success) {
+        const engine = new DoctorEngine();
+        const report = await engine.runAll();
+        const { text, keyboard } = renderReport(report);
+        if (report.pendingFixes.length > 0) {
+          pendingFixesStore.set(storeKey, report.pendingFixes);
+        } else {
+          pendingFixesStore.delete(storeKey);
+        }
+        await ctx.editMessageText(text, { parse_mode: "HTML", reply_markup: keyboard });
+      } else {
+        try {
+          await ctx.answerCallbackQuery({ text: `Fix failed: ${result.message}` });
+        } catch {
+        }
+      }
+    } catch (err) {
+      log13.error({ err, index }, "Doctor fix callback failed");
+    }
+  });
+  bot.callbackQuery("m:doctor", async (ctx) => {
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    await handleDoctor(ctx);
+  });
+}
+
 // src/adapters/telegram/commands/index.ts
 function setupCommands(bot, core, chatId, assistant) {
   bot.command("new", (ctx) => handleNew(ctx, core, chatId, assistant));
@@ -3759,6 +4139,7 @@ function setupCommands(bot, core, chatId, assistant) {
   bot.command("status", (ctx) => handleStatus(ctx, core));
   bot.command("sessions", (ctx) => handleTopics(ctx, core));
   bot.command("agents", (ctx) => handleAgents(ctx, core));
+  bot.command("install", (ctx) => handleInstall(ctx, core));
   bot.command("help", (ctx) => handleHelp(ctx));
   bot.command("menu", (ctx) => handleMenu(ctx));
   bot.command("enable_dangerous", (ctx) => handleEnableDangerous(ctx, core));
@@ -3767,10 +4148,19 @@ function setupCommands(bot, core, chatId, assistant) {
   bot.command("update", (ctx) => handleUpdate(ctx, core));
   bot.command("integrate", (ctx) => handleIntegrate(ctx, core));
   bot.command("clear", (ctx) => handleClear(ctx, assistant));
+  bot.command("doctor", (ctx) => handleDoctor(ctx));
 }
-function setupAllCallbacks(bot, core, chatId, systemTopicIds) {
+function setupAllCallbacks(bot, core, chatId, systemTopicIds, getAssistantSession) {
   setupNewSessionCallbacks(bot, core, chatId);
   setupSessionCallbacks(bot, core, chatId, systemTopicIds);
+  setupSettingsCallbacks(bot, core, getAssistantSession ?? (() => void 0));
+  setupDoctorCallbacks(bot);
+  bot.callbackQuery(/^ag:/, (ctx) => handleAgentCallback(ctx, core));
+  bot.callbackQuery(/^na:/, async (ctx) => {
+    const agentKey = ctx.callbackQuery.data.replace("na:", "");
+    await ctx.answerCallbackQuery();
+    await createSessionDirect(ctx, core, chatId, agentKey, core.configManager.get().workspace.baseDir);
+  });
   bot.callbackQuery(/^m:/, async (ctx) => {
     const data = ctx.callbackQuery.data;
     try {
@@ -3802,6 +4192,9 @@ function setupAllCallbacks(bot, core, chatId, systemTopicIds) {
       case "m:topics":
         await handleTopics(ctx, core);
         break;
+      case "m:settings":
+        await handleSettings(ctx, core);
+        break;
     }
   });
 }
@@ -3812,6 +4205,7 @@ var STATIC_COMMANDS = [
   { command: "status", description: "Show status" },
   { command: "sessions", description: "List all sessions" },
   { command: "agents", description: "List available agents" },
+  { command: "install", description: "Install a new agent" },
   { command: "help", description: "Help" },
   { command: "menu", description: "Show menu" },
   { command: "enable_dangerous", description: "Auto-approve all permission requests (session only)" },
@@ -3820,13 +4214,14 @@ var STATIC_COMMANDS = [
   { command: "handoff", description: "Continue this session in your terminal" },
   { command: "clear", description: "Clear assistant history" },
   { command: "restart", description: "Restart OpenACP" },
-  { command: "update", description: "Update to latest version and restart" }
+  { command: "update", description: "Update to latest version and restart" },
+  { command: "doctor", description: "Run system diagnostics" }
 ];
 
 // src/adapters/telegram/permissions.ts
-import { InlineKeyboard as InlineKeyboard6 } from "grammy";
+import { InlineKeyboard as InlineKeyboard8 } from "grammy";
 import { nanoid as nanoid2 } from "nanoid";
-var log11 = createChildLogger({ module: "telegram-permissions" });
+var log14 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
   constructor(bot, chatId, getSession, sendNotification) {
     this.bot = bot;
@@ -3843,7 +4238,7 @@ var PermissionHandler = class {
       requestId: request.id,
       options: request.options.map((o) => ({ id: o.id, isAllow: o.isAllow }))
     });
-    const keyboard = new InlineKeyboard6();
+    const keyboard = new InlineKeyboard8();
     for (const option of request.options) {
       const emoji = option.isAllow ? "\u2705" : "\u274C";
       keyboard.text(`${emoji} ${option.label}`, `p:${callbackKey}:${option.id}`);
@@ -3886,7 +4281,7 @@ ${escapeHtml(request.description)}`,
       }
       const session = this.getSession(pending.sessionId);
       const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
-      log11.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
+      log14.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
       if (session?.permissionGate.requestId === pending.requestId) {
         session.permissionGate.resolve(optionId);
       }
@@ -4268,20 +4663,19 @@ Session logs auto-cleanup: 30 days (configurable via \`logging.sessionLogRetenti
 `;
 
 // src/adapters/telegram/assistant.ts
-var log12 = createChildLogger({ module: "telegram-assistant" });
+var log15 = createChildLogger({ module: "telegram-assistant" });
 async function spawnAssistant(core, adapter, assistantTopicId) {
   const config = core.configManager.get();
-  log12.info({ agent: config.defaultAgent }, "Creating assistant session...");
-  const session = await core.sessionManager.createSession(
-    "telegram",
-    config.defaultAgent,
-    core.configManager.resolveWorkspace(),
-    core.agentManager
-  );
+  log15.info({ agent: config.defaultAgent }, "Creating assistant session...");
+  const session = await core.createSession({
+    channelId: "telegram",
+    agentName: config.defaultAgent,
+    workingDirectory: core.configManager.resolveWorkspace(),
+    initialName: "Assistant"
+    // Prevent auto-naming from triggering after system prompt
+  });
   session.threadId = String(assistantTopicId);
-  session.name = "Assistant";
-  log12.info({ sessionId: session.id }, "Assistant agent spawned");
-  core.wireSessionEvents(session, adapter);
+  log15.info({ sessionId: session.id }, "Assistant agent spawned");
   const allRecords = core.sessionManager.listRecords();
   const activeCount = allRecords.filter((r) => r.status === "active" || r.status === "initializing").length;
   const statusCounts = /* @__PURE__ */ new Map();
@@ -4297,9 +4691,9 @@ async function spawnAssistant(core, adapter, assistantTopicId) {
   };
   const systemPrompt = buildAssistantSystemPrompt(ctx);
   const ready = session.enqueuePrompt(systemPrompt).then(() => {
-    log12.info({ sessionId: session.id }, "Assistant system prompt completed");
+    log15.info({ sessionId: session.id }, "Assistant system prompt completed");
   }).catch((err) => {
-    log12.warn({ err }, "Assistant system prompt failed");
+    log15.warn({ err }, "Assistant system prompt failed");
   });
   return { session, ready };
 }
@@ -4367,8 +4761,10 @@ function buildAssistantSystemPrompt(ctx) {
 - Execute: \`openacp api cleanup --status <statuses>\`
 
 ### Configuration
-- View: \`openacp api config\`
-- Update: \`openacp api config set <key> <value>\`
+- View: \`openacp config\` (or \`openacp api config\` \u2014 deprecated)
+- Update: \`openacp config set <key> <value>\`
+- When user asks about "settings" or "config", use \`openacp config set\` directly
+- When receiving a delegated request from the Settings menu, ask user for the new value, then apply with \`openacp config set <path> <value>\`
 
 ### Restart / Update
 - Always ask for confirmation \u2014 these are disruptive actions
@@ -4398,8 +4794,10 @@ openacp api cleanup --status finished,error
 
 # System
 openacp api health                       # System health
-openacp api config                       # Show config
-openacp api config set <key> <value>     # Update config
+openacp config                           # Edit config (interactive)
+openacp config set <key> <value>         # Update config value
+openacp api config                       # Show config (deprecated)
+openacp api config set <key> <value>     # Update config (deprecated)
 openacp api adapters                     # List adapters
 openacp api tunnel                       # Tunnel status
 openacp api notify "message"             # Send notification
@@ -4432,7 +4830,7 @@ function redirectToAssistant(chatId, assistantTopicId) {
 }
 
 // src/adapters/telegram/activity.ts
-var log13 = createChildLogger({ module: "telegram:activity" });
+var log16 = createChildLogger({ module: "telegram:activity" });
 var THINKING_REFRESH_MS = 15e3;
 var THINKING_MAX_MS = 3 * 60 * 1e3;
 var ThinkingIndicator = class {
@@ -4464,7 +4862,7 @@ var ThinkingIndicator = class {
         this.startRefreshTimer();
       }
     } catch (err) {
-      log13.warn({ err }, "ThinkingIndicator.show() failed");
+      log16.warn({ err }, "ThinkingIndicator.show() failed");
     } finally {
       this.sending = false;
     }
@@ -4537,7 +4935,7 @@ var UsageMessage = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log13.warn({ err }, "UsageMessage.send() failed");
+      log16.warn({ err }, "UsageMessage.send() failed");
     }
   }
   getMsgId() {
@@ -4550,7 +4948,7 @@ var UsageMessage = class {
     try {
       await this.sendQueue.enqueue(() => this.api.deleteMessage(this.chatId, id));
     } catch (err) {
-      log13.warn({ err }, "UsageMessage.delete() failed");
+      log16.warn({ err }, "UsageMessage.delete() failed");
     }
   }
 };
@@ -4636,7 +5034,7 @@ var PlanCard = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log13.warn({ err }, "PlanCard flush failed");
+      log16.warn({ err }, "PlanCard flush failed");
     }
   }
 };
@@ -4699,7 +5097,7 @@ var ActivityTracker = class {
           })
         );
       } catch (err) {
-        log13.warn({ err }, "ActivityTracker.onComplete() Done send failed");
+        log16.warn({ err }, "ActivityTracker.onComplete() Done send failed");
       }
     }
   }
@@ -4782,7 +5180,7 @@ var TelegramSendQueue = class {
 
 // src/adapters/telegram/action-detect.ts
 import { nanoid as nanoid3 } from "nanoid";
-import { InlineKeyboard as InlineKeyboard7 } from "grammy";
+import { InlineKeyboard as InlineKeyboard9 } from "grammy";
 var CMD_NEW_RE = /\/new(?:\s+([^\s\u0080-\uFFFF]+)(?:\s+([^\s\u0080-\uFFFF]+))?)?/;
 var CMD_CANCEL_RE = /\/cancel\b/;
 var KW_NEW_RE = /(?:create|new)\s+session/i;
@@ -4829,7 +5227,7 @@ function removeAction(id) {
   actionMap.delete(id);
 }
 function buildActionKeyboard(actionId, action) {
-  const keyboard = new InlineKeyboard7();
+  const keyboard = new InlineKeyboard9();
   if (action.action === "new_session") {
     keyboard.text("\u2705 Create session", `a:${actionId}`);
     keyboard.text("\u274C Cancel", `a:dismiss:${actionId}`);
@@ -4936,79 +5334,525 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
   });
 }
 
-// src/adapters/telegram/adapter.ts
-var log14 = createChildLogger({ module: "telegram" });
-function patchedFetch(input, init) {
-  if (init?.signal && !(init.signal instanceof AbortSignal)) {
-    const nativeController = new AbortController();
-    const polyfillSignal = init.signal;
-    if (polyfillSignal.aborted) {
-      nativeController.abort();
-    } else {
-      polyfillSignal.addEventListener("abort", () => nativeController.abort());
-    }
-    init = { ...init, signal: nativeController.signal };
+// src/adapters/telegram/tool-call-tracker.ts
+var log17 = createChildLogger({ module: "tool-call-tracker" });
+var ToolCallTracker = class {
+  constructor(bot, chatId, sendQueue) {
+    this.bot = bot;
+    this.chatId = chatId;
+    this.sendQueue = sendQueue;
   }
-  return fetch(input, init);
-}
-var TelegramAdapter = class extends ChannelAdapter {
-  bot;
-  telegramConfig;
-  sessionDrafts = /* @__PURE__ */ new Map();
-  sessionTextBuffers = /* @__PURE__ */ new Map();
-  toolCallMessages = /* @__PURE__ */ new Map();
-  // sessionId → (toolCallId → state)
-  permissionHandler;
-  assistantSession = null;
-  assistantInitializing = false;
-  notificationTopicId;
-  assistantTopicId;
-  skillMessages = /* @__PURE__ */ new Map();
-  // sessionId → pinned messageId
-  sendQueue = new TelegramSendQueue(3e3);
-  sessionTrackers = /* @__PURE__ */ new Map();
-  getOrCreateTracker(sessionId, threadId) {
-    let tracker = this.sessionTrackers.get(sessionId);
-    if (!tracker) {
-      tracker = new ActivityTracker(
-        this.bot.api,
-        this.telegramConfig.chatId,
-        threadId,
-        this.sendQueue
+  sessions = /* @__PURE__ */ new Map();
+  async trackNewCall(sessionId, threadId, meta) {
+    if (!this.sessions.has(sessionId)) {
+      this.sessions.set(sessionId, /* @__PURE__ */ new Map());
+    }
+    let resolveReady;
+    const ready = new Promise((r) => {
+      resolveReady = r;
+    });
+    this.sessions.get(sessionId).set(meta.id, {
+      msgId: 0,
+      name: meta.name,
+      kind: meta.kind,
+      viewerLinks: meta.viewerLinks,
+      viewerFilePath: meta.viewerFilePath,
+      ready
+    });
+    const msg = await this.sendQueue.enqueue(
+      () => this.bot.api.sendMessage(
+        this.chatId,
+        formatToolCall(meta),
+        {
+          message_thread_id: threadId,
+          parse_mode: "HTML",
+          disable_notification: true
+        }
+      )
+    );
+    const toolEntry = this.sessions.get(sessionId).get(meta.id);
+    toolEntry.msgId = msg.message_id;
+    resolveReady();
+  }
+  async updateCall(sessionId, meta) {
+    const toolState = this.sessions.get(sessionId)?.get(meta.id);
+    if (!toolState) return;
+    if (meta.viewerLinks) {
+      toolState.viewerLinks = meta.viewerLinks;
+      log17.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated viewerLinks");
+    }
+    if (meta.viewerFilePath) toolState.viewerFilePath = meta.viewerFilePath;
+    if (meta.name) toolState.name = meta.name;
+    if (meta.kind) toolState.kind = meta.kind;
+    const isTerminal = meta.status === "completed" || meta.status === "failed";
+    if (!isTerminal) return;
+    await toolState.ready;
+    log17.debug(
+      {
+        toolId: meta.id,
+        status: meta.status,
+        hasViewerLinks: !!toolState.viewerLinks,
+        viewerLinks: toolState.viewerLinks,
+        name: toolState.name,
+        msgId: toolState.msgId
+      },
+      "Tool completed, preparing edit"
+    );
+    const merged = {
+      ...meta,
+      name: toolState.name,
+      kind: toolState.kind,
+      viewerLinks: toolState.viewerLinks,
+      viewerFilePath: toolState.viewerFilePath
+    };
+    const formattedText = formatToolUpdate(merged);
+    try {
+      await this.sendQueue.enqueue(
+        () => this.bot.api.editMessageText(
+          this.chatId,
+          toolState.msgId,
+          formattedText,
+          { parse_mode: "HTML" }
+        )
+      );
+    } catch (err) {
+      log17.warn(
+        {
+          err,
+          msgId: toolState.msgId,
+          textLen: formattedText.length,
+          hasViewerLinks: !!merged.viewerLinks
+        },
+        "Tool update edit failed"
       );
-      this.sessionTrackers.set(sessionId, tracker);
     }
-    return tracker;
   }
-  constructor(core, config) {
-    super(core, config);
-    this.telegramConfig = config;
+  cleanup(sessionId) {
+    this.sessions.delete(sessionId);
   }
-  async start() {
-    this.bot = new Bot(this.telegramConfig.botToken, { client: { fetch: patchedFetch } });
-    this.bot.catch((err) => {
-      const rootCause = err.error instanceof Error ? err.error : err;
-      log14.error({ err: rootCause }, "Telegram bot error");
-    });
-    this.bot.api.config.use(async (prev, method, payload, signal) => {
-      const maxRetries = 3;
-      for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        const result = await prev(method, payload, signal);
-        if (result.ok || result.error_code !== 429 || attempt === maxRetries) {
-          return result;
-        }
-        const retryAfter = (result.parameters?.retry_after ?? 5) + 1;
-        const rateLimitedMethods = ["sendMessage", "editMessageText", "editMessageReplyMarkup"];
-        if (rateLimitedMethods.includes(method)) {
-          this.sendQueue.onRateLimited();
-        }
-        log14.warn(
-          { method, retryAfter, attempt: attempt + 1 },
-          "Rate limited by Telegram, retrying"
-        );
-        await new Promise((r) => setTimeout(r, retryAfter * 1e3));
-      }
-      return prev(method, payload, signal);
+};
+
+// src/adapters/telegram/streaming.ts
+var FLUSH_INTERVAL = 5e3;
+var MessageDraft = class {
+  constructor(bot, chatId, threadId, sendQueue, sessionId) {
+    this.bot = bot;
+    this.chatId = chatId;
+    this.threadId = threadId;
+    this.sendQueue = sendQueue;
+    this.sessionId = sessionId;
+  }
+  buffer = "";
+  messageId;
+  firstFlushPending = false;
+  flushTimer;
+  flushPromise = Promise.resolve();
+  lastSentBuffer = "";
+  displayTruncated = false;
+  append(text) {
+    if (!text) return;
+    this.buffer += text;
+    this.scheduleFlush();
+  }
+  scheduleFlush() {
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = void 0;
+      this.flushPromise = this.flushPromise.then(() => this.flush()).catch(() => {
+      });
+    }, FLUSH_INTERVAL);
+  }
+  async flush() {
+    if (!this.buffer) return;
+    if (this.firstFlushPending) return;
+    const snapshot = this.buffer;
+    let html = markdownToTelegramHtml(snapshot);
+    if (!html) return;
+    let truncated = false;
+    if (html.length > 4096) {
+      const ratio = 4e3 / html.length;
+      const targetLen = Math.floor(snapshot.length * ratio);
+      let cutAt = snapshot.lastIndexOf("\n", targetLen);
+      if (cutAt < targetLen * 0.5) cutAt = targetLen;
+      html = markdownToTelegramHtml(snapshot.slice(0, cutAt) + "\n\u2026");
+      truncated = true;
+      if (html.length > 4096) {
+        html = html.slice(0, 4090) + "\n\u2026";
+      }
+    }
+    if (!this.messageId) {
+      this.firstFlushPending = true;
+      try {
+        const result = await this.sendQueue.enqueue(
+          () => this.bot.api.sendMessage(this.chatId, html, {
+            message_thread_id: this.threadId,
+            parse_mode: "HTML",
+            disable_notification: true
+          }),
+          { type: "other" }
+        );
+        if (result) {
+          this.messageId = result.message_id;
+          if (!truncated) {
+            this.lastSentBuffer = snapshot;
+            this.displayTruncated = false;
+          } else {
+            this.displayTruncated = true;
+          }
+        }
+      } catch {
+      } finally {
+        this.firstFlushPending = false;
+      }
+    } else {
+      try {
+        const result = await this.sendQueue.enqueue(
+          () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
+            parse_mode: "HTML"
+          }),
+          { type: "text", key: this.sessionId }
+        );
+        if (result !== void 0) {
+          if (!truncated) {
+            this.lastSentBuffer = snapshot;
+            this.displayTruncated = false;
+          } else {
+            this.displayTruncated = true;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  async finalize() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+    await this.flushPromise;
+    if (!this.buffer) return this.messageId;
+    if (this.messageId && this.buffer === this.lastSentBuffer && !this.displayTruncated) {
+      return this.messageId;
+    }
+    const fullHtml = markdownToTelegramHtml(this.buffer);
+    if (fullHtml.length <= 4096) {
+      try {
+        if (this.messageId) {
+          await this.sendQueue.enqueue(
+            () => this.bot.api.editMessageText(this.chatId, this.messageId, fullHtml, {
+              parse_mode: "HTML"
+            }),
+            { type: "other" }
+          );
+        } else {
+          const msg = await this.sendQueue.enqueue(
+            () => this.bot.api.sendMessage(this.chatId, fullHtml, {
+              message_thread_id: this.threadId,
+              parse_mode: "HTML",
+              disable_notification: true
+            }),
+            { type: "other" }
+          );
+          if (msg) this.messageId = msg.message_id;
+        }
+        return this.messageId;
+      } catch {
+      }
+    }
+    const mdChunks = splitMessage(this.buffer);
+    for (let i = 0; i < mdChunks.length; i++) {
+      const html = markdownToTelegramHtml(mdChunks[i]);
+      try {
+        if (i === 0 && this.messageId) {
+          await this.sendQueue.enqueue(
+            () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
+              parse_mode: "HTML"
+            }),
+            { type: "other" }
+          );
+        } else {
+          const msg = await this.sendQueue.enqueue(
+            () => this.bot.api.sendMessage(this.chatId, html, {
+              message_thread_id: this.threadId,
+              parse_mode: "HTML",
+              disable_notification: true
+            }),
+            { type: "other" }
+          );
+          if (msg) {
+            this.messageId = msg.message_id;
+          }
+        }
+      } catch {
+        try {
+          if (i === 0 && this.messageId) {
+            await this.sendQueue.enqueue(
+              () => this.bot.api.editMessageText(this.chatId, this.messageId, mdChunks[i].slice(0, 4096)),
+              { type: "other" }
+            );
+          } else {
+            const msg = await this.sendQueue.enqueue(
+              () => this.bot.api.sendMessage(this.chatId, mdChunks[i].slice(0, 4096), {
+                message_thread_id: this.threadId,
+                disable_notification: true
+              }),
+              { type: "other" }
+            );
+            if (msg) {
+              this.messageId = msg.message_id;
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    return this.messageId;
+  }
+  getMessageId() {
+    return this.messageId;
+  }
+};
+
+// src/adapters/telegram/draft-manager.ts
+var DraftManager = class {
+  constructor(bot, chatId, sendQueue) {
+    this.bot = bot;
+    this.chatId = chatId;
+    this.sendQueue = sendQueue;
+  }
+  drafts = /* @__PURE__ */ new Map();
+  textBuffers = /* @__PURE__ */ new Map();
+  getOrCreate(sessionId, threadId) {
+    let draft = this.drafts.get(sessionId);
+    if (!draft) {
+      draft = new MessageDraft(
+        this.bot,
+        this.chatId,
+        threadId,
+        this.sendQueue,
+        sessionId
+      );
+      this.drafts.set(sessionId, draft);
+    }
+    return draft;
+  }
+  hasDraft(sessionId) {
+    return this.drafts.has(sessionId);
+  }
+  appendText(sessionId, text) {
+    this.textBuffers.set(
+      sessionId,
+      (this.textBuffers.get(sessionId) ?? "") + text
+    );
+  }
+  /**
+   * Finalize the current draft and return the message ID.
+   * Optionally detects actions in assistant responses.
+   */
+  async finalize(sessionId, assistantSessionId) {
+    const draft = this.drafts.get(sessionId);
+    if (!draft) return;
+    this.drafts.delete(sessionId);
+    const finalMsgId = await draft.finalize();
+    if (assistantSessionId && sessionId === assistantSessionId) {
+      const fullText = this.textBuffers.get(sessionId);
+      this.textBuffers.delete(sessionId);
+      if (fullText && finalMsgId) {
+        const detected = detectAction(fullText);
+        if (detected) {
+          const actionId = storeAction(detected);
+          const keyboard = buildActionKeyboard(actionId, detected);
+          try {
+            await this.bot.api.editMessageReplyMarkup(
+              this.chatId,
+              finalMsgId,
+              { reply_markup: keyboard }
+            );
+          } catch {
+          }
+        }
+      }
+    } else {
+      this.textBuffers.delete(sessionId);
+    }
+  }
+  cleanup(sessionId) {
+    this.drafts.delete(sessionId);
+    this.textBuffers.delete(sessionId);
+  }
+};
+
+// src/adapters/telegram/skill-command-manager.ts
+var log18 = createChildLogger({ module: "skill-commands" });
+var SkillCommandManager = class {
+  // sessionId → pinned msgId
+  constructor(bot, chatId, sendQueue, sessionManager) {
+    this.bot = bot;
+    this.chatId = chatId;
+    this.sendQueue = sendQueue;
+    this.sessionManager = sessionManager;
+  }
+  messages = /* @__PURE__ */ new Map();
+  async send(sessionId, threadId, commands) {
+    if (!this.messages.has(sessionId)) {
+      const record = this.sessionManager.getSessionRecord(sessionId);
+      const platform = record?.platform;
+      if (platform?.skillMsgId) {
+        this.messages.set(sessionId, platform.skillMsgId);
+      }
+    }
+    if (commands.length === 0) {
+      await this.cleanup(sessionId);
+      return;
+    }
+    const messages = buildSkillMessages(commands);
+    const existingMsgId = this.messages.get(sessionId);
+    if (existingMsgId) {
+      try {
+        await this.bot.api.editMessageText(
+          this.chatId,
+          existingMsgId,
+          messages[0],
+          { parse_mode: "HTML" }
+        );
+        return;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "";
+        if (msg.includes("message is not modified")) return;
+        try {
+          await this.bot.api.deleteMessage(this.chatId, existingMsgId);
+        } catch {
+        }
+        this.messages.delete(sessionId);
+      }
+    }
+    try {
+      let firstMsgId;
+      for (const text of messages) {
+        const msg = await this.sendQueue.enqueue(
+          () => this.bot.api.sendMessage(this.chatId, text, {
+            message_thread_id: threadId,
+            parse_mode: "HTML",
+            disable_notification: true
+          })
+        );
+        if (!firstMsgId) firstMsgId = msg.message_id;
+      }
+      this.messages.set(sessionId, firstMsgId);
+      const record = this.sessionManager.getSessionRecord(sessionId);
+      if (record) {
+        await this.sessionManager.patchRecord(sessionId, {
+          platform: { ...record.platform, skillMsgId: firstMsgId }
+        });
+      }
+      await this.bot.api.pinChatMessage(this.chatId, firstMsgId, {
+        disable_notification: true
+      });
+    } catch (err) {
+      log18.error({ err, sessionId }, "Failed to send skill commands");
+    }
+  }
+  async cleanup(sessionId) {
+    const msgId = this.messages.get(sessionId);
+    if (!msgId) return;
+    try {
+      await this.bot.api.editMessageText(
+        this.chatId,
+        msgId,
+        "\u{1F6E0} <i>Session ended</i>",
+        { parse_mode: "HTML" }
+      );
+      await this.bot.api.unpinChatMessage(this.chatId, msgId);
+    } catch {
+    }
+    this.messages.delete(sessionId);
+    const record = this.sessionManager.getSessionRecord(sessionId);
+    if (record) {
+      const { skillMsgId: _removed, ...rest } = record.platform;
+      await this.sessionManager.patchRecord(sessionId, { platform: rest });
+    }
+  }
+};
+
+// src/adapters/telegram/adapter.ts
+var log19 = createChildLogger({ module: "telegram" });
+function patchedFetch(input, init) {
+  if (init?.signal && !(init.signal instanceof AbortSignal)) {
+    const nativeController = new AbortController();
+    const polyfillSignal = init.signal;
+    if (polyfillSignal.aborted) {
+      nativeController.abort();
+    } else {
+      polyfillSignal.addEventListener("abort", () => nativeController.abort());
+    }
+    init = { ...init, signal: nativeController.signal };
+  }
+  return fetch(input, init);
+}
+var TelegramAdapter = class extends ChannelAdapter {
+  bot;
+  telegramConfig;
+  permissionHandler;
+  assistantSession = null;
+  assistantInitializing = false;
+  notificationTopicId;
+  assistantTopicId;
+  sendQueue = new TelegramSendQueue(3e3);
+  // Extracted managers
+  toolTracker;
+  draftManager;
+  skillManager;
+  sessionTrackers = /* @__PURE__ */ new Map();
+  getOrCreateTracker(sessionId, threadId) {
+    let tracker = this.sessionTrackers.get(sessionId);
+    if (!tracker) {
+      tracker = new ActivityTracker(
+        this.bot.api,
+        this.telegramConfig.chatId,
+        threadId,
+        this.sendQueue
+      );
+      this.sessionTrackers.set(sessionId, tracker);
+    }
+    return tracker;
+  }
+  constructor(core, config) {
+    super(core, config);
+    this.telegramConfig = config;
+  }
+  async start() {
+    this.bot = new Bot(this.telegramConfig.botToken, { client: { fetch: patchedFetch } });
+    this.toolTracker = new ToolCallTracker(this.bot, this.telegramConfig.chatId, this.sendQueue);
+    this.draftManager = new DraftManager(this.bot, this.telegramConfig.chatId, this.sendQueue);
+    this.skillManager = new SkillCommandManager(
+      this.bot,
+      this.telegramConfig.chatId,
+      this.sendQueue,
+      this.core.sessionManager
+    );
+    this.bot.catch((err) => {
+      const rootCause = err.error instanceof Error ? err.error : err;
+      log19.error({ err: rootCause }, "Telegram bot error");
+    });
+    this.bot.api.config.use(async (prev, method, payload, signal) => {
+      const maxRetries = 3;
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        const result = await prev(method, payload, signal);
+        if (result.ok || result.error_code !== 429 || attempt === maxRetries) {
+          return result;
+        }
+        const retryAfter = (result.parameters?.retry_after ?? 5) + 1;
+        const rateLimitedMethods = ["sendMessage", "editMessageText", "editMessageReplyMarkup"];
+        if (rateLimitedMethods.includes(method)) {
+          this.sendQueue.onRateLimited();
+        }
+        log19.warn(
+          { method, retryAfter, attempt: attempt + 1 },
+          "Rate limited by Telegram, retrying"
+        );
+        await new Promise((r) => setTimeout(r, retryAfter * 1e3));
+      }
+      return prev(method, payload, signal);
     });
     this.bot.api.config.use((prev, method, payload, signal) => {
       if (method === "getUpdates") {
@@ -5058,7 +5902,14 @@ var TelegramAdapter = class extends ChannelAdapter {
       this.bot,
       this.core,
       this.telegramConfig.chatId,
-      { notificationTopicId: this.notificationTopicId, assistantTopicId: this.assistantTopicId }
+      { notificationTopicId: this.notificationTopicId, assistantTopicId: this.assistantTopicId },
+      () => {
+        if (!this.assistantSession) return void 0;
+        return {
+          topicId: this.assistantTopicId,
+          enqueuePrompt: (p) => this.assistantSession.enqueuePrompt(p)
+        };
+      }
     );
     setupCommands(
       this.bot,
@@ -5105,7 +5956,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         });
         return;
       }
-      const { getAgentCapabilities: getAgentCapabilities2 } = await import("./agent-registry-7HC6D4CH.js");
+      const { getAgentCapabilities: getAgentCapabilities2 } = await import("./agent-registry-B5YAMA4T.js");
       const caps = getAgentCapabilities2(agentName);
       if (!caps.supportsResume || !caps.resumeCommand) {
         await ctx.reply("This agent does not support session transfer.", {
@@ -5127,7 +5978,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log14.info(
+      onStart: () => log19.info(
         { chatId: this.telegramConfig.chatId },
         "Telegram bot started"
       )
@@ -5149,10 +6000,10 @@ var TelegramAdapter = class extends ChannelAdapter {
         reply_markup: buildMenuKeyboard()
       });
     } catch (err) {
-      log14.warn({ err }, "Failed to send welcome message");
+      log19.warn({ err }, "Failed to send welcome message");
     }
     try {
-      log14.info("Spawning assistant session...");
+      log19.info("Spawning assistant session...");
       const { session, ready } = await spawnAssistant(
         this.core,
         this,
@@ -5160,13 +6011,13 @@ var TelegramAdapter = class extends ChannelAdapter {
       );
       this.assistantSession = session;
       this.assistantInitializing = true;
-      log14.info({ sessionId: session.id }, "Assistant session ready, system prompt running in background");
+      log19.info({ sessionId: session.id }, "Assistant session ready, system prompt running in background");
       ready.then(() => {
         this.assistantInitializing = false;
-        log14.info({ sessionId: session.id }, "Assistant ready for user messages");
+        log19.info({ sessionId: session.id }, "Assistant ready for user messages");
       });
     } catch (err) {
-      log14.error({ err }, "Failed to spawn assistant");
+      log19.error({ err }, "Failed to spawn assistant");
       this.bot.api.sendMessage(
         this.telegramConfig.chatId,
         `\u26A0\uFE0F <b>Failed to start assistant session.</b>
@@ -5182,7 +6033,7 @@ var TelegramAdapter = class extends ChannelAdapter {
       await this.assistantSession.destroy();
     }
     await this.bot.stop();
-    log14.info("Telegram bot stopped");
+    log19.info("Telegram bot stopped");
   }
   setupRoutes() {
     this.bot.on("message:text", async (ctx) => {
@@ -5204,16 +6055,16 @@ var TelegramAdapter = class extends ChannelAdapter {
           await ctx.reply("\u26A0\uFE0F Assistant is not available yet. Please try again shortly.", { parse_mode: "HTML" });
           return;
         }
-        await this.finalizeDraft(this.assistantSession.id);
+        await this.draftManager.finalize(this.assistantSession.id, this.assistantSession.id);
         ctx.replyWithChatAction("typing").catch(() => {
         });
         handleAssistantMessage(this.assistantSession, ctx.message.text).catch(
-          (err) => log14.error({ err }, "Assistant error")
+          (err) => log19.error({ err }, "Assistant error")
         );
         return;
       }
       const sessionId = this.core.sessionManager.getSessionByThread("telegram", String(threadId))?.id;
-      if (sessionId) await this.finalizeDraft(sessionId);
+      if (sessionId) await this.draftManager.finalize(sessionId, this.assistantSession?.id);
       if (sessionId) {
         const tracker = this.sessionTrackers.get(sessionId);
         if (tracker) await tracker.onNewPrompt();
@@ -5225,19 +6076,17 @@ var TelegramAdapter = class extends ChannelAdapter {
         threadId: String(threadId),
         userId: String(ctx.from.id),
         text: ctx.message.text
-      }).catch((err) => log14.error({ err }, "handleMessage error"));
+      }).catch((err) => log19.error({ err }, "handleMessage error"));
     });
   }
   // --- ChannelAdapter implementations ---
   async sendMessage(sessionId, content) {
     if (this.assistantInitializing && sessionId === this.assistantSession?.id) return;
-    const session = this.core.sessionManager.getSession(
-      sessionId
-    );
+    const session = this.core.sessionManager.getSession(sessionId);
     if (!session) return;
     const threadId = Number(session.threadId);
     if (!threadId || isNaN(threadId)) {
-      log14.warn({ sessionId, threadId: session.threadId }, "Session has no valid threadId, skipping message");
+      log19.warn({ sessionId, threadId: session.threadId }, "Session has no valid threadId, skipping message");
       return;
     }
     switch (content.type) {
@@ -5247,105 +6096,32 @@ var TelegramAdapter = class extends ChannelAdapter {
         break;
       }
       case "text": {
-        let draft = this.sessionDrafts.get(sessionId);
-        if (!draft) {
+        if (!this.draftManager.hasDraft(sessionId)) {
           const tracker = this.getOrCreateTracker(sessionId, threadId);
           await tracker.onTextStart();
-          draft = new MessageDraft(
-            this.bot,
-            this.telegramConfig.chatId,
-            threadId,
-            this.sendQueue,
-            sessionId
-          );
-          this.sessionDrafts.set(sessionId, draft);
         }
+        const draft = this.draftManager.getOrCreate(sessionId, threadId);
         draft.append(content.text);
-        this.sessionTextBuffers.set(
-          sessionId,
-          (this.sessionTextBuffers.get(sessionId) ?? "") + content.text
-        );
+        this.draftManager.appendText(sessionId, content.text);
         break;
       }
       case "tool_call": {
         const tracker = this.getOrCreateTracker(sessionId, threadId);
         await tracker.onToolCall();
-        await this.finalizeDraft(sessionId);
+        await this.draftManager.finalize(sessionId, this.assistantSession?.id);
         const meta = content.metadata;
-        if (!this.toolCallMessages.has(sessionId)) {
-          this.toolCallMessages.set(sessionId, /* @__PURE__ */ new Map());
-        }
-        let resolveReady;
-        const ready = new Promise((r) => {
-          resolveReady = r;
-        });
-        this.toolCallMessages.get(sessionId).set(meta.id, {
-          msgId: 0,
-          name: meta.name,
-          kind: meta.kind,
-          viewerLinks: meta.viewerLinks,
-          viewerFilePath: content.metadata?.viewerFilePath,
-          ready
+        await this.toolTracker.trackNewCall(sessionId, threadId, {
+          ...meta,
+          viewerFilePath: content.metadata?.viewerFilePath
         });
-        const msg = await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(
-            this.telegramConfig.chatId,
-            formatToolCall(meta),
-            {
-              message_thread_id: threadId,
-              parse_mode: "HTML",
-              disable_notification: true
-            }
-          )
-        );
-        const toolEntry = this.toolCallMessages.get(sessionId).get(meta.id);
-        toolEntry.msgId = msg.message_id;
-        resolveReady();
         break;
       }
       case "tool_update": {
         const meta = content.metadata;
-        const toolState = this.toolCallMessages.get(sessionId)?.get(meta.id);
-        if (toolState) {
-          if (meta.viewerLinks) {
-            toolState.viewerLinks = meta.viewerLinks;
-            log14.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated viewerLinks");
-          }
-          const viewerFilePath = content.metadata?.viewerFilePath;
-          if (viewerFilePath) toolState.viewerFilePath = viewerFilePath;
-          if (meta.name) toolState.name = meta.name;
-          if (meta.kind) toolState.kind = meta.kind;
-          const isTerminal = meta.status === "completed" || meta.status === "failed";
-          if (!isTerminal) break;
-          await toolState.ready;
-          log14.debug(
-            { toolId: meta.id, status: meta.status, hasViewerLinks: !!toolState.viewerLinks, viewerLinks: toolState.viewerLinks, name: toolState.name, msgId: toolState.msgId },
-            "Tool completed, preparing edit"
-          );
-          const merged = {
-            ...meta,
-            name: toolState.name,
-            kind: toolState.kind,
-            viewerLinks: toolState.viewerLinks,
-            viewerFilePath: toolState.viewerFilePath
-          };
-          const formattedText = formatToolUpdate(merged);
-          try {
-            await this.sendQueue.enqueue(
-              () => this.bot.api.editMessageText(
-                this.telegramConfig.chatId,
-                toolState.msgId,
-                formattedText,
-                { parse_mode: "HTML" }
-              )
-            );
-          } catch (err) {
-            log14.warn(
-              { err, msgId: toolState.msgId, textLen: formattedText.length, hasViewerLinks: !!merged.viewerLinks },
-              "Tool update edit failed"
-            );
-          }
-        }
+        await this.toolTracker.updateCall(sessionId, {
+          ...meta,
+          viewerFilePath: content.metadata?.viewerFilePath
+        });
         break;
       }
       case "plan": {
@@ -5362,7 +6138,7 @@ var TelegramAdapter = class extends ChannelAdapter {
       }
       case "usage": {
         const meta = content.metadata;
-        await this.finalizeDraft(sessionId);
+        await this.draftManager.finalize(sessionId, this.assistantSession?.id);
         const tracker = this.getOrCreateTracker(sessionId, threadId);
         await tracker.sendUsage(meta);
         if (this.notificationTopicId && sessionId !== this.assistantSession?.id) {
@@ -5388,10 +6164,10 @@ Task completed.
         break;
       }
       case "session_end": {
-        await this.finalizeDraft(sessionId);
-        this.sessionDrafts.delete(sessionId);
-        this.toolCallMessages.delete(sessionId);
-        await this.cleanupSkillCommands(sessionId);
+        await this.draftManager.finalize(sessionId, this.assistantSession?.id);
+        this.draftManager.cleanup(sessionId);
+        this.toolTracker.cleanup(sessionId);
+        await this.skillManager.cleanup(sessionId);
         const tracker = this.sessionTrackers.get(sessionId);
         if (tracker) {
           await tracker.onComplete();
@@ -5413,7 +6189,7 @@ Task completed.
         break;
       }
       case "error": {
-        await this.finalizeDraft(sessionId);
+        await this.draftManager.finalize(sessionId, this.assistantSession?.id);
         const tracker = this.sessionTrackers.get(sessionId);
         if (tracker) {
           tracker.destroy();
@@ -5435,15 +6211,13 @@ Task completed.
     }
   }
   async sendPermissionRequest(sessionId, request) {
-    log14.info({ sessionId, requestId: request.id }, "Permission request sent");
-    const session = this.core.sessionManager.getSession(
-      sessionId
-    );
+    log19.info({ sessionId, requestId: request.id }, "Permission request sent");
+    const session = this.core.sessionManager.getSession(sessionId);
     if (!session) return;
     if (request.description.includes("openacp")) {
       const allowOption = request.options.find((o) => o.isAllow);
       if (allowOption && session.permissionGate.requestId === request.id) {
-        log14.info({ sessionId, requestId: request.id }, "Auto-approving openacp command");
+        log19.info({ sessionId, requestId: request.id }, "Auto-approving openacp command");
         session.permissionGate.resolve(allowOption.id);
       }
       return;
@@ -5451,7 +6225,7 @@ Task completed.
     if (session.dangerousMode) {
       const allowOption = request.options.find((o) => o.isAllow);
       if (allowOption && session.permissionGate.requestId === request.id) {
-        log14.info({ sessionId, requestId: request.id, optionId: allowOption.id }, "Dangerous mode: auto-approving permission");
+        log19.info({ sessionId, requestId: request.id, optionId: allowOption.id }, "Dangerous mode: auto-approving permission");
         session.permissionGate.resolve(allowOption.id);
       }
       return;
@@ -5462,7 +6236,7 @@ Task completed.
   }
   async sendNotification(notification) {
     if (notification.sessionId === this.assistantSession?.id) return;
-    log14.info(
+    log19.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -5498,15 +6272,13 @@ Task completed.
     );
   }
   async createSessionThread(sessionId, name) {
-    log14.info({ sessionId, name }, "Session topic created");
+    log19.info({ sessionId, name }, "Session topic created");
     return String(
       await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
     );
   }
   async renameSessionThread(sessionId, newName) {
-    const session = this.core.sessionManager.getSession(
-      sessionId
-    );
+    const session = this.core.sessionManager.getSession(sessionId);
     if (!session) return;
     await renameSessionTopic(
       this.bot,
@@ -5514,10 +6286,7 @@ Task completed.
       Number(session.threadId),
       newName
     );
-    await this.core.sessionManager.updateSessionName(
-      sessionId,
-      newName
-    );
+    await this.core.sessionManager.patchRecord(sessionId, { name: newName });
   }
   async deleteSessionThread(sessionId) {
     const record = this.core.sessionManager.getSessionRecord(sessionId);
@@ -5527,7 +6296,7 @@ Task completed.
     try {
       await this.bot.api.deleteForumTopic(this.telegramConfig.chatId, topicId);
     } catch (err) {
-      log14.warn({ err, sessionId, topicId }, "Failed to delete forum topic (may already be deleted)");
+      log19.warn({ err, sessionId, topicId }, "Failed to delete forum topic (may already be deleted)");
     }
   }
   async sendSkillCommands(sessionId, commands) {
@@ -5536,119 +6305,10 @@ Task completed.
     if (!session) return;
     const threadId = Number(session.threadId);
     if (!threadId) return;
-    if (!this.skillMessages.has(sessionId)) {
-      const record = this.core.sessionManager.getSessionRecord(sessionId);
-      const platform = record?.platform;
-      if (platform?.skillMsgId) {
-        this.skillMessages.set(sessionId, platform.skillMsgId);
-      }
-    }
-    if (commands.length === 0) {
-      await this.cleanupSkillCommands(sessionId);
-      return;
-    }
-    const messages = buildSkillMessages(commands);
-    const existingMsgId = this.skillMessages.get(sessionId);
-    if (existingMsgId) {
-      try {
-        await this.bot.api.editMessageText(
-          this.telegramConfig.chatId,
-          existingMsgId,
-          messages[0],
-          { parse_mode: "HTML" }
-        );
-        return;
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : "";
-        if (msg.includes("message is not modified")) {
-          return;
-        }
-        try {
-          await this.bot.api.deleteMessage(this.telegramConfig.chatId, existingMsgId);
-        } catch {
-        }
-        this.skillMessages.delete(sessionId);
-      }
-    }
-    try {
-      let firstMsgId;
-      for (const text of messages) {
-        const msg = await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(
-            this.telegramConfig.chatId,
-            text,
-            {
-              message_thread_id: threadId,
-              parse_mode: "HTML",
-              disable_notification: true
-            }
-          )
-        );
-        if (!firstMsgId) firstMsgId = msg.message_id;
-      }
-      this.skillMessages.set(sessionId, firstMsgId);
-      const record = this.core.sessionManager.getSessionRecord(sessionId);
-      if (record) {
-        await this.core.sessionManager.updateSessionPlatform(
-          sessionId,
-          { ...record.platform, skillMsgId: firstMsgId }
-        );
-      }
-      await this.bot.api.pinChatMessage(
-        this.telegramConfig.chatId,
-        firstMsgId,
-        { disable_notification: true }
-      );
-    } catch (err) {
-      log14.error({ err, sessionId }, "Failed to send skill commands");
-    }
+    await this.skillManager.send(sessionId, threadId, commands);
   }
   async cleanupSkillCommands(sessionId) {
-    const msgId = this.skillMessages.get(sessionId);
-    if (!msgId) return;
-    try {
-      await this.bot.api.editMessageText(
-        this.telegramConfig.chatId,
-        msgId,
-        "\u{1F6E0} <i>Session ended</i>",
-        { parse_mode: "HTML" }
-      );
-      await this.bot.api.unpinChatMessage(this.telegramConfig.chatId, msgId);
-    } catch {
-    }
-    this.skillMessages.delete(sessionId);
-    const record = this.core.sessionManager.getSessionRecord(sessionId);
-    if (record) {
-      const { skillMsgId: _removed, ...rest } = record.platform;
-      await this.core.sessionManager.updateSessionPlatform(sessionId, rest);
-    }
-  }
-  async finalizeDraft(sessionId) {
-    const draft = this.sessionDrafts.get(sessionId);
-    if (!draft) return;
-    this.sessionDrafts.delete(sessionId);
-    const finalMsgId = await draft.finalize();
-    if (sessionId === this.assistantSession?.id) {
-      const fullText = this.sessionTextBuffers.get(sessionId);
-      this.sessionTextBuffers.delete(sessionId);
-      if (fullText && finalMsgId) {
-        const detected = detectAction(fullText);
-        if (detected) {
-          const actionId = storeAction(detected);
-          const keyboard = buildActionKeyboard(actionId, detected);
-          try {
-            await this.bot.api.editMessageReplyMarkup(
-              this.telegramConfig.chatId,
-              finalMsgId,
-              { reply_markup: keyboard }
-            );
-          } catch {
-          }
-        }
-      }
-    } else {
-      this.sessionTextBuffers.delete(sessionId);
-    }
+    await this.skillManager.cleanup(sessionId);
   }
 };
 
@@ -5663,6 +6323,7 @@ export {
   PermissionGate,
   Session,
   SessionManager,
+  SessionBridge,
   NotificationManager,
   MessageTransformer,
   OpenACPCore,
@@ -5671,4 +6332,4 @@ export {
   TopicManager,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-KPI4HGJC.js.map
+//# sourceMappingURL=chunk-FWN3UIRT.js.map