@openacp/cli 0.4.9 → 0.4.11

package/dist/{chunk-45DFYWJT.js → chunk-66RVSUAR.js}

@@ -1,10 +1,33 @@
+import {
+  DoctorEngine
+} from "./chunk-3DIPXFZJ.js";
 import {
   getAgentCapabilities
 } from "./chunk-VA2M52CM.js";
+import {
+  buildMenuKeyboard,
+  buildSkillMessages,
+  escapeHtml,
+  formatToolCall,
+  formatToolUpdate,
+  formatUsage,
+  handleAgents,
+  handleClear,
+  handleHelp,
+  handleMenu,
+  markdownToTelegramHtml,
+  splitMessage
+} from "./chunk-BGKQHQB4.js";
+import {
+  getConfigValue,
+  getSafeFields,
+  isHotReloadable,
+  resolveOptions
+} from "./chunk-C33LTDZV.js";
 import {
   createChildLogger,
   createSessionLogger
-} from "./chunk-LYKCQTH5.js";
+} from "./chunk-ESOPMQAY.js";
 
 // src/core/streams.ts
 function nodeToWebWritable(nodeStream) {
@@ -674,6 +697,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 +712,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 +731,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 +786,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 +813,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 +832,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 +841,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 +918,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 +933,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 +976,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 +1212,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 +1274,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 +1286,7 @@ var MessageTransformer = class {
       event.meta
     );
     if (!fileInfo) return;
-    log2.info(
+    log3.info(
       {
         name,
         kind,
@@ -1178,7 +1328,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 +1410,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 +1419,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 +1437,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,7 +1450,7 @@ var JsonFileSessionStore = class {
 };
 
 // src/core/core.ts
-var log4 = createChildLogger({ module: "core" });
+var log5 = createChildLogger({ module: "core" });
 var OpenACPCore = class {
   configManager;
   agentManager;
@@ -1325,6 +1475,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;
@@ -1358,7 +1515,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 +1525,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 +1534,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 +1558,87 @@ 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 resolvedWorkspace = this.configManager.resolveWorkspace(
       workspacePath || config.agents[resolvedAgent]?.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 +1661,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 +1679,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 +1701,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 +1743,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 +1800,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 +1831,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 +1877,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 +1890,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 +1946,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 +1971,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 +1999,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 +2099,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 +2127,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-OGX4YM2U.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 +2182,7 @@ var ApiServer = class {
       return;
     }
     target[lastKey] = value;
-    const { ConfigSchema } = await import("./config-H2DSEHNW.js");
+    const { ConfigSchema } = await import("./config-XURP6B3S.js");
     const result = ConfigSchema.safeParse(cloned);
     if (!result.success) {
       this.sendJson(res, 400, {
@@ -2033,12 +2198,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-OGX4YM2U.js");
+    const needsRestart = !isHotReloadable2(configPath);
     this.sendJson(res, 200, {
       ok: true,
       needsRestart,
@@ -2097,7 +2259,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 +2368,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 +2407,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 +2430,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,497 +2451,223 @@ var TopicManager = class {
 // src/adapters/telegram/adapter.ts
 import { Bot } from "grammy";
 
-// src/adapters/telegram/formatting.ts
-function escapeHtml(text) {
-  if (!text) return "";
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function markdownToTelegramHtml(md) {
-  const codeBlocks = [];
-  const inlineCodes = [];
-  let text = md.replace(/```(\w*)\n?([\s\S]*?)```/g, (_match, lang, code) => {
-    const index = codeBlocks.length;
-    const escapedCode = escapeHtml(code);
-    const langAttr = lang ? ` class="language-${escapeHtml(lang)}"` : "";
-    codeBlocks.push(`<pre><code${langAttr}>${escapedCode}</code></pre>`);
-    return `\0CODE_BLOCK_${index}\0`;
-  });
-  text = text.replace(/`([^`]+)`/g, (_match, code) => {
-    const index = inlineCodes.length;
-    inlineCodes.push(`<code>${escapeHtml(code)}</code>`);
-    return `\0INLINE_CODE_${index}\0`;
-  });
-  text = escapeHtml(text);
-  text = text.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
-  text = text.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "<i>$1</i>");
-  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
-  text = text.replace(/\x00CODE_BLOCK_(\d+)\x00/g, (_match, idx) => {
-    return codeBlocks[parseInt(idx, 10)];
-  });
-  text = text.replace(/\x00INLINE_CODE_(\d+)\x00/g, (_match, idx) => {
-    return inlineCodes[parseInt(idx, 10)];
-  });
-  return text;
-}
-var STATUS_ICON = {
-  pending: "\u23F3",
-  in_progress: "\u{1F504}",
-  completed: "\u2705",
-  failed: "\u274C"
-};
-var KIND_ICON = {
-  read: "\u{1F4D6}",
-  edit: "\u270F\uFE0F",
-  delete: "\u{1F5D1}\uFE0F",
-  execute: "\u25B6\uFE0F",
-  search: "\u{1F50D}",
-  fetch: "\u{1F310}",
-  think: "\u{1F9E0}",
-  move: "\u{1F4E6}",
-  other: "\u{1F6E0}\uFE0F"
-};
-function extractContentText(content, depth = 0) {
-  if (!content || depth > 5) return "";
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.map((c) => extractContentText(c, depth + 1)).filter(Boolean).join("\n");
-  }
-  if (typeof content === "object" && content !== null) {
-    const c = content;
-    if (c.type === "text" && typeof c.text === "string") return c.text;
-    if (typeof c.text === "string") return c.text;
-    if (typeof c.content === "string") return c.content;
-    if (c.content && typeof c.content === "object") return extractContentText(c.content, depth + 1);
-    if (c.input) return extractContentText(c.input, depth + 1);
-    if (c.output) return extractContentText(c.output, depth + 1);
-    const keys = Object.keys(c).filter((k) => k !== "type");
-    if (keys.length === 0) return "";
-    return JSON.stringify(c, null, 2);
-  }
-  return String(content);
-}
-function truncateContent(text, maxLen = 3800) {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen) + "\n\u2026 (truncated)";
-}
-function formatToolCall(tool) {
-  const si = STATUS_ICON[tool.status || ""] || "\u{1F527}";
-  const ki = KIND_ICON[tool.kind || ""] || "\u{1F6E0}\uFE0F";
-  let text = `${si} ${ki} <b>${escapeHtml(tool.name || "Tool")}</b>`;
-  text += formatViewerLinks(tool.viewerLinks, tool.viewerFilePath);
-  if (!tool.viewerLinks) {
-    const details = extractContentText(tool.content);
-    if (details) {
-      text += `
-<pre>${escapeHtml(truncateContent(details))}</pre>`;
-    }
+// 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 });
   }
-  return text;
-}
-function formatToolUpdate(update) {
-  const si = STATUS_ICON[update.status] || "\u{1F527}";
-  const ki = KIND_ICON[update.kind || ""] || "\u{1F6E0}\uFE0F";
-  const name = update.name || "Tool";
-  let text = `${si} ${ki} <b>${escapeHtml(name)}</b>`;
-  text += formatViewerLinks(update.viewerLinks, update.viewerFilePath);
-  if (!update.viewerLinks) {
-    const details = extractContentText(update.content);
-    if (details) {
-      text += `
-<pre>${escapeHtml(truncateContent(details))}</pre>`;
-    }
+  if (assistantTopicId === null) {
+    const topic = await bot.api.createForumTopic(chatId, "\u{1F916} Assistant");
+    assistantTopicId = topic.message_thread_id;
+    await saveConfig({ assistantTopicId });
   }
-  return text;
-}
-function formatViewerLinks(links, filePath) {
-  if (!links) return "";
-  const fileName = filePath ? filePath.split("/").pop() || filePath : "";
-  let text = "\n";
-  if (links.file) text += `
-\u{1F4C4} <a href="${escapeHtml(links.file)}">View ${escapeHtml(fileName || "file")}</a>`;
-  if (links.diff) text += `
-\u{1F4DD} <a href="${escapeHtml(links.diff)}">View diff${fileName ? ` \u2014 ${escapeHtml(fileName)}` : ""}</a>`;
-  return text;
-}
-function formatTokens(n) {
-  return n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
-}
-function progressBar(ratio) {
-  const filled = Math.round(Math.min(ratio, 1) * 10);
-  return "\u2593".repeat(filled) + "\u2591".repeat(10 - filled);
+  return { notificationTopicId, assistantTopicId };
 }
-function formatUsage(usage) {
-  const { tokensUsed, contextSize } = usage;
-  if (tokensUsed == null) return "\u{1F4CA} Usage data unavailable";
-  if (contextSize == null) return `\u{1F4CA} ${formatTokens(tokensUsed)} tokens`;
-  const ratio = tokensUsed / contextSize;
-  const pct = Math.round(ratio * 100);
-  const bar = progressBar(ratio);
-  const emoji = pct >= 85 ? "\u26A0\uFE0F" : "\u{1F4CA}";
-  return `${emoji} ${formatTokens(tokensUsed)} / ${formatTokens(contextSize)} tokens
-${bar} ${pct}%`;
+async function createSessionTopic(bot, chatId, name) {
+  const topic = await bot.api.createForumTopic(chatId, name);
+  return topic.message_thread_id;
 }
-function splitMessage(text, maxLength = 3800) {
-  if (text.length <= maxLength) return [text];
-  const chunks = [];
-  let remaining = text;
-  while (remaining.length > 0) {
-    if (remaining.length <= maxLength) {
-      chunks.push(remaining);
-      break;
-    }
-    let splitAt = remaining.lastIndexOf("\n\n", maxLength);
-    if (splitAt === -1 || splitAt < maxLength * 0.2) {
-      splitAt = remaining.lastIndexOf("\n", maxLength);
-    }
-    if (splitAt === -1 || splitAt < maxLength * 0.2) {
-      splitAt = maxLength;
-    }
-    const candidate = remaining.slice(0, splitAt);
-    const fences = candidate.match(/```/g);
-    if (fences && fences.length % 2 !== 0) {
-      const closingFence = remaining.indexOf("```", splitAt);
-      if (closingFence !== -1) {
-        const afterFence = remaining.indexOf("\n", closingFence + 3);
-        splitAt = afterFence !== -1 ? afterFence + 1 : closingFence + 3;
-      }
-    }
-    chunks.push(remaining.slice(0, splitAt));
-    remaining = remaining.slice(splitAt).replace(/^\n+/, "");
+async function renameSessionTopic(bot, chatId, threadId, name) {
+  try {
+    await bot.api.editForumTopic(chatId, threadId, { name });
+  } catch {
   }
-  return chunks;
+}
+function buildDeepLink(chatId, messageId) {
+  const cleanId = String(chatId).replace("-100", "");
+  return `https://t.me/c/${cleanId}/${messageId}`;
 }
 
-// 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 = "";
-  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(() => {
+// src/adapters/telegram/commands/new-session.ts
+import { InlineKeyboard as InlineKeyboard2 } from "grammy";
+
+// src/adapters/telegram/commands/admin.ts
+import { InlineKeyboard } from "grammy";
+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",
+    `d:${sessionId}`
+  );
+}
+function setupDangerousModeCallbacks(bot, core) {
+  bot.callbackQuery(/^d:/, async (ctx) => {
+    const sessionId = ctx.callbackQuery.data.slice(2);
+    const session = core.sessionManager.getSession(sessionId);
+    if (session) {
+      session.dangerousMode = !session.dangerousMode;
+      log9.info({ sessionId, dangerousMode: session.dangerousMode }, "Dangerous mode toggled via button");
+      core.sessionManager.patchRecord(sessionId, { dangerousMode: session.dangerousMode }).catch(() => {
       });
-    }, FLUSH_INTERVAL);
-  }
-  async flush() {
-    if (!this.buffer) return;
-    if (this.firstFlushPending) return;
-    let displayBuffer = this.buffer;
-    if (displayBuffer.length > 3800) {
-      let cutAt = displayBuffer.lastIndexOf("\n", 3800);
-      if (cutAt < 800) cutAt = 3800;
-      displayBuffer = displayBuffer.slice(0, cutAt) + "\n\u2026";
-    }
-    let html = markdownToTelegramHtml(displayBuffer);
-    if (!html) return;
-    if (html.length > 4096) {
-      html = html.slice(0, 4090) + "\n\u2026";
-    }
-    if (!this.messageId) {
-      this.firstFlushPending = true;
+      const toastText2 = session.dangerousMode ? "\u2620\uFE0F Dangerous mode enabled \u2014 permissions auto-approved" : "\u{1F510} Dangerous mode disabled \u2014 permissions shown normally";
       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;
-          this.lastSentBuffer = this.buffer;
-        }
+        await ctx.answerCallbackQuery({ text: toastText2 });
       } catch {
-      } finally {
-        this.firstFlushPending = false;
       }
-    } else {
       try {
-        await this.sendQueue.enqueue(
-          () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
-            parse_mode: "HTML"
-          }),
-          { type: "text", key: this.sessionId }
-        );
-        this.lastSentBuffer = this.buffer;
+        await ctx.editMessageReplyMarkup({
+          reply_markup: buildDangerousModeKeyboard(sessionId, session.dangerousMode)
+        });
       } catch {
       }
+      return;
     }
-  }
-  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) {
-      return this.messageId;
-    }
-    const mdChunks = splitMessage(this.buffer);
-    for (let i = 0; i < mdChunks.length; i++) {
-      const html = markdownToTelegramHtml(mdChunks[i]);
+    const record = core.sessionManager.getSessionRecord(sessionId);
+    if (!record || record.status === "cancelled" || record.status === "error") {
       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;
-          }
-        }
+        await ctx.answerCallbackQuery({ text: "\u26A0\uFE0F Session not found or already ended." });
       } 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;
     }
-    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.ts
-import { InlineKeyboard } from "grammy";
-var log8 = createChildLogger({ module: "telegram-commands" });
-var pendingNewSessions = /* @__PURE__ */ new Map();
-var PENDING_TIMEOUT_MS = 5 * 60 * 1e3;
-function cleanupPending(userId) {
-  const pending = pendingNewSessions.get(userId);
-  if (pending) {
-    clearTimeout(pending.timer);
-    pendingNewSessions.delete(userId);
-  }
-}
-function setupCommands(bot, core, chatId, assistant) {
-  bot.command("new", (ctx) => handleNew(ctx, core, chatId, assistant));
-  bot.command("newchat", (ctx) => handleNewChat(ctx, core, chatId));
-  bot.command("cancel", (ctx) => handleCancel(ctx, core, assistant));
-  bot.command("status", (ctx) => handleStatus(ctx, core));
-  bot.command("sessions", (ctx) => handleTopics(ctx, core));
-  bot.command("agents", (ctx) => handleAgents(ctx, core));
-  bot.command("help", (ctx) => handleHelp(ctx));
-  bot.command("menu", (ctx) => handleMenu(ctx));
-  bot.command("enable_dangerous", (ctx) => handleEnableDangerous(ctx, core));
-  bot.command("disable_dangerous", (ctx) => handleDisableDangerous(ctx, core));
-  bot.command("restart", (ctx) => handleRestart(ctx, core));
-  bot.command("update", (ctx) => handleUpdate(ctx, core));
-  bot.command("integrate", (ctx) => handleIntegrate(ctx, core));
-  bot.command("clear", (ctx) => handleClear(ctx, assistant));
-}
-function buildMenuKeyboard() {
-  return new InlineKeyboard().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");
-}
-function setupMenuCallbacks(bot, core, chatId, systemTopicIds) {
-  bot.callbackQuery(/^m:/, async (ctx) => {
-    const data = ctx.callbackQuery.data;
+    const newDangerousMode = !(record.dangerousMode ?? false);
+    core.sessionManager.patchRecord(sessionId, { dangerousMode: newDangerousMode }).catch(() => {
+    });
+    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();
+      await ctx.answerCallbackQuery({ text: toastText });
     } catch {
     }
-    if (data.startsWith("m:new:agent:")) {
-      const agentName = data.replace("m:new:agent:", "");
-      const userId = ctx.from?.id;
-      if (userId) await startWorkspaceStep(ctx, core, chatId, userId, agentName);
+    try {
+      await ctx.editMessageReplyMarkup({
+        reply_markup: buildDangerousModeKeyboard(sessionId, newDangerousMode)
+      });
+    } catch {
+    }
+  });
+}
+async function handleEnableDangerous(ctx, core) {
+  const threadId = ctx.message?.message_thread_id;
+  if (!threadId) {
+    await ctx.reply("\u26A0\uFE0F This command only works inside a session topic.", { parse_mode: "HTML" });
+    return;
+  }
+  const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
+  if (session) {
+    if (session.dangerousMode) {
+      await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
       return;
     }
-    if (data === "m:new:ws:default") {
-      const userId = ctx.from?.id;
-      if (!userId) return;
-      const pending = pendingNewSessions.get(userId);
-      if (!pending?.agentName) return;
-      const workspace = core.configManager.get().workspace.baseDir;
-      await startConfirmStep(ctx, chatId, userId, pending.agentName, workspace);
+    session.dangerousMode = true;
+    core.sessionManager.patchRecord(session.id, { dangerousMode: true }).catch(() => {
+    });
+  } else {
+    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
+    if (!record || record.status === "cancelled" || record.status === "error") {
+      await ctx.reply("\u26A0\uFE0F No active session in this topic.", { parse_mode: "HTML" });
       return;
     }
-    if (data === "m:new:ws:custom") {
-      const userId = ctx.from?.id;
-      if (!userId) return;
-      const pending = pendingNewSessions.get(userId);
-      if (!pending?.agentName) return;
-      try {
-        await ctx.api.editMessageText(
-          chatId,
-          pending.messageId,
-          `\u270F\uFE0F <b>Enter your project path:</b>
+    if (record.dangerousMode) {
+      await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
+      return;
+    }
+    core.sessionManager.patchRecord(record.sessionId, { dangerousMode: true }).catch(() => {
+    });
+  }
+  await ctx.reply(
+    `\u26A0\uFE0F <b>Dangerous mode enabled</b>
 
-Full path like <code>~/code/my-project</code>
-Or just the folder name like <code>my-project</code> (will use ${core.configManager.get().workspace.baseDir}/)`,
-          { parse_mode: "HTML" }
-        );
-      } catch {
-        await ctx.reply(
-          `\u270F\uFE0F <b>Enter your project path:</b>`,
-          { parse_mode: "HTML" }
-        );
-      }
-      clearTimeout(pending.timer);
-      pending.step = "workspace_input";
-      pending.timer = setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS);
+All permission requests will be auto-approved. Claude can run arbitrary commands without asking.
+
+Use /disable_dangerous to restore normal behaviour.`,
+    { parse_mode: "HTML" }
+  );
+}
+async function handleDisableDangerous(ctx, core) {
+  const threadId = ctx.message?.message_thread_id;
+  if (!threadId) {
+    await ctx.reply("\u26A0\uFE0F This command only works inside a session topic.", { parse_mode: "HTML" });
+    return;
+  }
+  const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
+  if (session) {
+    if (!session.dangerousMode) {
+      await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
       return;
     }
-    if (data === "m:new:confirm") {
-      const userId = ctx.from?.id;
-      if (!userId) return;
-      const pending = pendingNewSessions.get(userId);
-      if (!pending?.agentName || !pending?.workspace) return;
-      cleanupPending(userId);
-      const confirmMsgId = pending.messageId;
-      try {
-        await ctx.api.editMessageText(chatId, confirmMsgId, `\u23F3 Creating session...`, { parse_mode: "HTML" });
-      } catch {
-      }
-      const resultThreadId = await createSessionDirect(ctx, core, chatId, pending.agentName, pending.workspace);
-      try {
-        if (resultThreadId) {
-          const link = buildDeepLink(chatId, resultThreadId);
-          await ctx.api.editMessageText(chatId, confirmMsgId, `\u2705 Session created \u2192 <a href="${link}">Open topic</a>`, { parse_mode: "HTML" });
-        } else {
-          await ctx.api.editMessageText(chatId, confirmMsgId, `\u274C Session creation failed.`, { parse_mode: "HTML" });
-        }
-      } catch {
-      }
+    session.dangerousMode = false;
+    core.sessionManager.patchRecord(session.id, { dangerousMode: false }).catch(() => {
+    });
+  } else {
+    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
+    if (!record || record.status === "cancelled" || record.status === "error") {
+      await ctx.reply("\u26A0\uFE0F No active session in this topic.", { parse_mode: "HTML" });
       return;
     }
-    if (data === "m:new:cancel") {
-      const userId = ctx.from?.id;
-      if (userId) cleanupPending(userId);
-      try {
-        await ctx.editMessageText("\u274C Session creation cancelled.", { parse_mode: "HTML" });
-      } catch {
-      }
+    if (!record.dangerousMode) {
+      await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
       return;
     }
-    switch (data) {
-      case "m:new":
-        await handleNew(ctx, core, chatId);
-        break;
-      case "m:status":
-        await handleStatus(ctx, core);
-        break;
-      case "m:agents":
-        await handleAgents(ctx, core);
-        break;
-      case "m:help":
-        await handleHelp(ctx);
-        break;
-      case "m:restart":
-        await handleRestart(ctx, core);
-        break;
-      case "m:update":
-        await handleUpdate(ctx, core);
-        break;
-      case "m:integrate":
-        await handleIntegrate(ctx, core);
-        break;
-      case "m:topics":
-        await handleTopics(ctx, core);
-        break;
-      case "m:cleanup:finished":
-        await handleCleanup(ctx, core, chatId, ["finished"]);
-        break;
-      case "m:cleanup:errors":
-        await handleCleanup(ctx, core, chatId, ["error", "cancelled"]);
-        break;
-      case "m:cleanup:all":
-        await handleCleanup(ctx, core, chatId, ["finished", "error", "cancelled"]);
-        break;
-      case "m:cleanup:everything":
-        await handleCleanupEverything(ctx, core, chatId, systemTopicIds);
-        break;
-      case "m:cleanup:everything:confirm":
-        await handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicIds);
-        break;
-    }
-  });
+    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" });
 }
-async function handleMenu(ctx) {
-  await ctx.reply(`<b>OpenACP Menu</b>
-Choose an action:`, {
-    parse_mode: "HTML",
-    reply_markup: buildMenuKeyboard()
-  });
+async function handleUpdate(ctx, core) {
+  if (!core.requestRestart) {
+    await ctx.reply("\u26A0\uFE0F Update is not available (no restart handler registered).", { parse_mode: "HTML" });
+    return;
+  }
+  const { getCurrentVersion, getLatestVersion, compareVersions, runUpdate } = await import("./version-VC5CPXBX.js");
+  const current = getCurrentVersion();
+  const statusMsg = await ctx.reply(`\u{1F50D} Checking for updates... (current: v${escapeHtml(current)})`, { parse_mode: "HTML" });
+  const latest = await getLatestVersion();
+  if (!latest) {
+    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, "\u274C Could not check for updates.", { parse_mode: "HTML" });
+    return;
+  }
+  if (compareVersions(current, latest) >= 0) {
+    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, `\u2705 Already up to date (v${escapeHtml(current)}).`, { parse_mode: "HTML" });
+    return;
+  }
+  await ctx.api.editMessageText(
+    ctx.chat.id,
+    statusMsg.message_id,
+    `\u2B07\uFE0F Updating v${escapeHtml(current)} \u2192 v${escapeHtml(latest)}...`,
+    { parse_mode: "HTML" }
+  );
+  const ok = await runUpdate();
+  if (!ok) {
+    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, "\u274C Update failed. Try manually: <code>npm install -g @openacp/cli@latest</code>", { parse_mode: "HTML" });
+    return;
+  }
+  await ctx.api.editMessageText(
+    ctx.chat.id,
+    statusMsg.message_id,
+    `\u2705 Updated to v${escapeHtml(latest)}. Restarting...`,
+    { parse_mode: "HTML" }
+  );
+  await new Promise((r) => setTimeout(r, 500));
+  await core.requestRestart();
+}
+async function handleRestart(ctx, core) {
+  if (!core.requestRestart) {
+    await ctx.reply("\u26A0\uFE0F Restart is not available (no restart handler registered).", { parse_mode: "HTML" });
+    return;
+  }
+  await ctx.reply("\u{1F504} <b>Restarting OpenACP...</b>\nRebuilding and restarting. Be back shortly.", { parse_mode: "HTML" });
+  await new Promise((r) => setTimeout(r, 500));
+  await core.requestRestart();
+}
+
+// src/adapters/telegram/commands/new-session.ts
+var log10 = createChildLogger({ module: "telegram-cmd-new-session" });
+var pendingNewSessions = /* @__PURE__ */ new Map();
+var PENDING_TIMEOUT_MS = 5 * 60 * 1e3;
+function cleanupPending(userId) {
+  const pending = pendingNewSessions.get(userId);
+  if (pending) {
+    clearTimeout(pending.timer);
+    pendingNewSessions.delete(userId);
+  }
+}
+function botFromCtx(ctx) {
+  return { api: ctx.api };
 }
 async function handleNew(ctx, core, chatId, assistant) {
   const rawMatch = ctx.match;
@@ -2809,11 +2697,12 @@ async function handleNew(ctx, core, chatId, assistant) {
     await startWorkspaceStep(ctx, core, chatId, userId, selectedAgent);
     return;
   }
-  const keyboard = new InlineKeyboard();
+  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 }
@@ -2829,7 +2718,7 @@ async function handleNew(ctx, core, chatId, assistant) {
 async function startWorkspaceStep(ctx, core, chatId, userId, agentName) {
   const config = core.configManager.get();
   const baseDir = config.workspace.baseDir;
-  const keyboard = new InlineKeyboard().text(`\u{1F4C1} Use ${baseDir}`, "m:new:ws:default").row().text("\u270F\uFE0F Enter project path", "m:new:ws:custom");
+  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 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.
@@ -2860,7 +2749,7 @@ Or use the default directory below:`;
   });
 }
 async function startConfirmStep(ctx, chatId, userId, agentName, workspace) {
-  const keyboard = new InlineKeyboard().text("\u2705 Create", "m:new:confirm").text("\u274C Cancel", "m:new:cancel");
+  const keyboard = new InlineKeyboard2().text("\u2705 Create", "m:new:confirm").text("\u274C Cancel", "m:new:cancel");
   const text = `\u2705 <b>Ready to create session?</b>
 
 <b>Agent:</b> ${escapeHtml(agentName)}
@@ -2891,7 +2780,7 @@ async function startConfirmStep(ctx, chatId, userId, agentName, workspace) {
   });
 }
 async function createSessionDirect(ctx, core, chatId, agentName, workspace) {
-  log8.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`;
@@ -2902,7 +2791,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 });
@@ -2921,10 +2810,10 @@ This is your coding session \u2014 chat here to work with the agent.`,
         reply_markup: buildDangerousModeKeyboard(session.id, false)
       }
     );
-    session.warmup().catch((err) => log8.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log10.error({ err }, "Warm-up error"));
     return threadId ?? null;
   } catch (err) {
-    log8.error({ err }, "Session creation failed");
+    log10.error({ err }, "Session creation failed");
     if (threadId) {
       try {
         await ctx.api.deleteForumTopic(chatId, threadId);
@@ -2988,9 +2877,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)
@@ -3001,19 +2890,182 @@ async function handleNewChat(ctx, core, chatId) {
         parse_mode: "HTML",
         reply_markup: buildDangerousModeKeyboard(session.id, false)
       }
-    );
-    session.warmup().catch((err) => log8.error({ err }, "Warm-up error"));
-  } catch (err) {
-    if (newThreadId) {
+    );
+    session.warmup().catch((err) => log10.error({ err }, "Warm-up error"));
+  } catch (err) {
+    if (newThreadId) {
+      try {
+        await ctx.api.deleteForumTopic(chatId, newThreadId);
+      } catch {
+      }
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
+  }
+}
+async function executeNewSession(bot, core, chatId, agentName, workspace) {
+  const threadId = await createSessionTopic(bot, chatId, "\u{1F504} New Session");
+  const setupMsg = await bot.api.sendMessage(chatId, "\u23F3 Setting up session, please wait...", {
+    message_thread_id: threadId,
+    parse_mode: "HTML"
+  });
+  const firstMsgId = setupMsg.message_id;
+  try {
+    const session = await core.handleNewSession(
+      "telegram",
+      agentName,
+      workspace
+    );
+    session.threadId = String(threadId);
+    await core.sessionManager.patchRecord(session.id, { platform: {
+      topicId: threadId
+    } });
+    const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
+    await renameSessionTopic(bot, chatId, threadId, finalName);
+    session.warmup().catch((err) => log10.error({ err }, "Warm-up error"));
+    return { session, threadId, firstMsgId };
+  } catch (err) {
+    try {
+      await bot.api.deleteForumTopic(chatId, threadId);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function handlePendingWorkspaceInput(ctx, core, chatId, assistantTopicId) {
+  const userId = ctx.from?.id;
+  if (!userId) return false;
+  const pending = pendingNewSessions.get(userId);
+  if (!pending || !ctx.message?.text) return false;
+  if (pending.step !== "workspace_input" && pending.step !== "workspace") return false;
+  const threadId = ctx.message.message_thread_id;
+  if (threadId && threadId !== assistantTopicId) return false;
+  let workspace = ctx.message.text.trim();
+  if (!workspace || !pending.agentName) {
+    await ctx.reply("\u26A0\uFE0F Please enter a valid directory path.", { parse_mode: "HTML" });
+    return true;
+  }
+  if (!workspace.startsWith("/") && !workspace.startsWith("~")) {
+    const baseDir = core.configManager.get().workspace.baseDir;
+    workspace = `${baseDir.replace(/\/$/, "")}/${workspace}`;
+  }
+  await startConfirmStep(ctx, chatId, userId, pending.agentName, workspace);
+  return true;
+}
+async function startInteractiveNewSession(ctx, core, chatId, agentName) {
+  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: ctx.callbackQuery?.message?.message_thread_id,
+    timer: setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS)
+  });
+}
+function setupNewSessionCallbacks(bot, core, chatId) {
+  bot.callbackQuery(/^m:new:/, async (ctx) => {
+    const data = ctx.callbackQuery.data;
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    if (data.startsWith("m:new:agent:")) {
+      const agentName = data.replace("m:new:agent:", "");
+      const userId = ctx.from?.id;
+      if (userId) await startWorkspaceStep(ctx, core, chatId, userId, agentName);
+      return;
+    }
+    if (data === "m:new:ws:default") {
+      const userId = ctx.from?.id;
+      if (!userId) return;
+      const pending = pendingNewSessions.get(userId);
+      if (!pending?.agentName) return;
+      const workspace = core.configManager.get().workspace.baseDir;
+      await startConfirmStep(ctx, chatId, userId, pending.agentName, workspace);
+      return;
+    }
+    if (data === "m:new:ws:custom") {
+      const userId = ctx.from?.id;
+      if (!userId) return;
+      const pending = pendingNewSessions.get(userId);
+      if (!pending?.agentName) return;
+      try {
+        await ctx.api.editMessageText(
+          chatId,
+          pending.messageId,
+          `\u270F\uFE0F <b>Enter your project path:</b>
+
+Full path like <code>~/code/my-project</code>
+Or just the folder name like <code>my-project</code> (will use ${core.configManager.get().workspace.baseDir}/)`,
+          { parse_mode: "HTML" }
+        );
+      } catch {
+        await ctx.reply(
+          `\u270F\uFE0F <b>Enter your project path:</b>`,
+          { parse_mode: "HTML" }
+        );
+      }
+      clearTimeout(pending.timer);
+      pending.step = "workspace_input";
+      pending.timer = setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS);
+      return;
+    }
+    if (data === "m:new:confirm") {
+      const userId = ctx.from?.id;
+      if (!userId) return;
+      const pending = pendingNewSessions.get(userId);
+      if (!pending?.agentName || !pending?.workspace) return;
+      cleanupPending(userId);
+      const confirmMsgId = pending.messageId;
+      try {
+        await ctx.api.editMessageText(chatId, confirmMsgId, `\u23F3 Creating session...`, { parse_mode: "HTML" });
+      } catch {
+      }
+      const resultThreadId = await createSessionDirect(ctx, core, chatId, pending.agentName, pending.workspace);
+      try {
+        if (resultThreadId) {
+          const link = buildDeepLink(chatId, resultThreadId);
+          await ctx.api.editMessageText(chatId, confirmMsgId, `\u2705 Session created \u2192 <a href="${link}">Open topic</a>`, { parse_mode: "HTML" });
+        } else {
+          await ctx.api.editMessageText(chatId, confirmMsgId, `\u274C Session creation failed.`, { parse_mode: "HTML" });
+        }
+      } catch {
+      }
+      return;
+    }
+    if (data === "m:new:cancel") {
+      const userId = ctx.from?.id;
+      if (userId) cleanupPending(userId);
       try {
-        await ctx.api.deleteForumTopic(chatId, newThreadId);
+        await ctx.editMessageText("\u274C Session creation cancelled.", { parse_mode: "HTML" });
       } catch {
       }
+      return;
     }
-    const message = err instanceof Error ? err.message : String(err);
-    await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
-  }
+  });
 }
+
+// src/adapters/telegram/commands/session.ts
+import { InlineKeyboard as InlineKeyboard3 } from "grammy";
+var log11 = createChildLogger({ module: "telegram-cmd-session" });
 async function handleCancel(ctx, core, assistant) {
   const threadId = ctx.message?.message_thread_id;
   if (!threadId) return;
@@ -3031,14 +3083,14 @@ async function handleCancel(ctx, core, assistant) {
     String(threadId)
   );
   if (session) {
-    log8.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") {
-    log8.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" });
   }
@@ -3122,10 +3174,9 @@ 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 activeCount = records.filter((r) => r.status === "active" || r.status === "initializing").length;
-    const keyboard = new InlineKeyboard();
+    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();
     }
@@ -3135,7 +3186,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}
@@ -3144,17 +3195,14 @@ ${lines.join("\n")}${truncated}`,
       { parse_mode: "HTML", reply_markup: keyboard }
     );
   } catch (err) {
-    log8.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;
@@ -3168,13 +3216,13 @@ async function handleCleanup(ctx, core, chatId, statuses) {
         try {
           await ctx.api.deleteForumTopic(chatId, topicId);
         } catch (err) {
-          log8.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) {
-      log8.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
+      log11.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
       failed++;
     }
   }
@@ -3187,8 +3235,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) {
@@ -3211,357 +3258,104 @@ async function handleCleanupEverything(ctx, core, chatId, systemTopicIds) {
   const activeWarning = activeCount > 0 ? `
 
 \u26A0\uFE0F <b>${activeCount} active session(s) will be cancelled and their agents stopped!</b>` : "";
-  const keyboard = new InlineKeyboard().text("Yes, delete all", "m:cleanup:everything:confirm").text("Cancel", "m:topics");
+  const keyboard = new InlineKeyboard3().text("Yes, delete all", "m:cleanup:everything:confirm").text("Cancel", "m:topics");
   await ctx.reply(
     `<b>Delete ${cleanable.length} topics?</b>
-
-This will:
-\u2022 Delete all session topics from this group
-\u2022 Cancel any running agent sessions
-\u2022 Remove all session records
-
-<b>Breakdown:</b>
-${breakdown}${activeWarning}
-
-<i>Notifications and Assistant topics will NOT be deleted.</i>`,
-    { parse_mode: "HTML", reply_markup: keyboard }
-  );
-}
-async function handleCleanupEverythingConfirmed(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;
-    return true;
-  });
-  if (cleanable.length === 0) {
-    await ctx.reply("Nothing to clean up.", { parse_mode: "HTML" });
-    return;
-  }
-  let deleted = 0;
-  let failed = 0;
-  for (const record of cleanable) {
-    try {
-      if (record.status === "active" || record.status === "initializing") {
-        try {
-          await core.sessionManager.cancelSession(record.sessionId);
-        } catch (err) {
-          log8.warn({ err, sessionId: record.sessionId }, "Failed to cancel session during cleanup");
-        }
-      }
-      const topicId = record.platform?.topicId;
-      if (topicId) {
-        try {
-          await ctx.api.deleteForumTopic(chatId, topicId);
-        } catch (err) {
-          log8.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
-        }
-      }
-      await core.sessionManager.removeRecord(record.sessionId);
-      deleted++;
-    } catch (err) {
-      log8.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
-      failed++;
-    }
-  }
-  await ctx.reply(
-    `\u{1F5D1} Cleaned up <b>${deleted}</b> sessions${failed > 0 ? ` (${failed} failed)` : ""}.`,
-    { 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 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" });
-    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" });
-  }
-}
-function buildDangerousModeKeyboard(sessionId, enabled) {
-  return new InlineKeyboard().text(
-    enabled ? "\u{1F510} Disable Dangerous Mode" : "\u2620\uFE0F Enable Dangerous Mode",
-    `d:${sessionId}`
-  );
-}
-function setupDangerousModeCallbacks(bot, core) {
-  bot.callbackQuery(/^d:/, async (ctx) => {
-    const sessionId = ctx.callbackQuery.data.slice(2);
-    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(() => {
-      });
-      const toastText2 = session.dangerousMode ? "\u2620\uFE0F Dangerous mode enabled \u2014 permissions auto-approved" : "\u{1F510} Dangerous mode disabled \u2014 permissions shown normally";
-      try {
-        await ctx.answerCallbackQuery({ text: toastText2 });
-      } catch {
-      }
-      try {
-        await ctx.editMessageReplyMarkup({
-          reply_markup: buildDangerousModeKeyboard(sessionId, session.dangerousMode)
-        });
-      } catch {
-      }
-      return;
-    }
-    const record = core.sessionManager.getSessionRecord(sessionId);
-    if (!record || record.status === "cancelled" || record.status === "error") {
-      try {
-        await ctx.answerCallbackQuery({ text: "\u26A0\uFE0F Session not found or already ended." });
-      } catch {
-      }
-      return;
-    }
-    const newDangerousMode = !(record.dangerousMode ?? false);
-    core.sessionManager.updateSessionDangerousMode(sessionId, newDangerousMode).catch(() => {
-    });
-    log8.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 });
-    } catch {
-    }
-    try {
-      await ctx.editMessageReplyMarkup({
-        reply_markup: buildDangerousModeKeyboard(sessionId, newDangerousMode)
-      });
-    } catch {
-    }
-  });
-}
-async function handleEnableDangerous(ctx, core) {
-  const threadId = ctx.message?.message_thread_id;
-  if (!threadId) {
-    await ctx.reply("\u26A0\uFE0F This command only works inside a session topic.", { parse_mode: "HTML" });
-    return;
-  }
-  const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
-  if (session) {
-    if (session.dangerousMode) {
-      await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
-      return;
-    }
-    session.dangerousMode = true;
-    core.sessionManager.updateSessionDangerousMode(session.id, true).catch(() => {
-    });
-  } else {
-    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
-    if (!record || record.status === "cancelled" || record.status === "error") {
-      await ctx.reply("\u26A0\uFE0F No active session in this topic.", { parse_mode: "HTML" });
-      return;
-    }
-    if (record.dangerousMode) {
-      await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
-      return;
-    }
-    core.sessionManager.updateSessionDangerousMode(record.sessionId, true).catch(() => {
-    });
-  }
-  await ctx.reply(
-    `\u26A0\uFE0F <b>Dangerous mode enabled</b>
-
-All permission requests will be auto-approved. Claude can run arbitrary commands without asking.
-
-Use /disable_dangerous to restore normal behaviour.`,
-    { parse_mode: "HTML" }
-  );
-}
-async function handleUpdate(ctx, core) {
-  if (!core.requestRestart) {
-    await ctx.reply("\u26A0\uFE0F Update is not available (no restart handler registered).", { parse_mode: "HTML" });
-    return;
-  }
-  const { getCurrentVersion, getLatestVersion, compareVersions, runUpdate } = await import("./version-VC5CPXBX.js");
-  const current = getCurrentVersion();
-  const statusMsg = await ctx.reply(`\u{1F50D} Checking for updates... (current: v${escapeHtml(current)})`, { parse_mode: "HTML" });
-  const latest = await getLatestVersion();
-  if (!latest) {
-    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, "\u274C Could not check for updates.", { parse_mode: "HTML" });
-    return;
-  }
-  if (compareVersions(current, latest) >= 0) {
-    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, `\u2705 Already up to date (v${escapeHtml(current)}).`, { parse_mode: "HTML" });
-    return;
-  }
-  await ctx.api.editMessageText(
-    ctx.chat.id,
-    statusMsg.message_id,
-    `\u2B07\uFE0F Updating v${escapeHtml(current)} \u2192 v${escapeHtml(latest)}...`,
-    { parse_mode: "HTML" }
-  );
-  const ok = await runUpdate();
-  if (!ok) {
-    await ctx.api.editMessageText(ctx.chat.id, statusMsg.message_id, "\u274C Update failed. Try manually: <code>npm install -g @openacp/cli@latest</code>", { parse_mode: "HTML" });
-    return;
-  }
-  await ctx.api.editMessageText(
-    ctx.chat.id,
-    statusMsg.message_id,
-    `\u2705 Updated to v${escapeHtml(latest)}. Restarting...`,
-    { parse_mode: "HTML" }
-  );
-  await new Promise((r) => setTimeout(r, 500));
-  await core.requestRestart();
-}
-async function handleRestart(ctx, core) {
-  if (!core.requestRestart) {
-    await ctx.reply("\u26A0\uFE0F Restart is not available (no restart handler registered).", { parse_mode: "HTML" });
-    return;
-  }
-  await ctx.reply("\u{1F504} <b>Restarting OpenACP...</b>\nRebuilding and restarting. Be back shortly.", { parse_mode: "HTML" });
-  await new Promise((r) => setTimeout(r, 500));
-  await core.requestRestart();
-}
-async function handleDisableDangerous(ctx, core) {
-  const threadId = ctx.message?.message_thread_id;
-  if (!threadId) {
-    await ctx.reply("\u26A0\uFE0F This command only works inside a session topic.", { parse_mode: "HTML" });
-    return;
-  }
-  const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
-  if (session) {
-    if (!session.dangerousMode) {
-      await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
-      return;
-    }
-    session.dangerousMode = false;
-    core.sessionManager.updateSessionDangerousMode(session.id, false).catch(() => {
-    });
-  } else {
-    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
-    if (!record || record.status === "cancelled" || record.status === "error") {
-      await ctx.reply("\u26A0\uFE0F No active session in this topic.", { parse_mode: "HTML" });
-      return;
-    }
-    if (!record.dangerousMode) {
-      await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
-      return;
-    }
-    core.sessionManager.updateSessionDangerousMode(record.sessionId, false).catch(() => {
-    });
-  }
-  await ctx.reply("\u{1F510} <b>Dangerous mode disabled</b>\n\nPermission requests will be shown normally.", { parse_mode: "HTML" });
-}
-function botFromCtx(ctx) {
-  return { api: ctx.api };
-}
-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;
-    }
-  }
-  if (current) messages.push(current);
-  return messages;
+
+This will:
+\u2022 Delete all session topics from this group
+\u2022 Cancel any running agent sessions
+\u2022 Remove all session records
+
+<b>Breakdown:</b>
+${breakdown}${activeWarning}
+
+<i>Notifications and Assistant topics will NOT be deleted.</i>`,
+    { parse_mode: "HTML", reply_markup: keyboard }
+  );
 }
-async function executeNewSession(bot, core, chatId, agentName, workspace) {
-  const threadId = await createSessionTopic(bot, chatId, "\u{1F504} New Session");
-  const setupMsg = await bot.api.sendMessage(chatId, "\u23F3 Setting up session, please wait...", {
-    message_thread_id: threadId,
-    parse_mode: "HTML"
+async function handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicIds) {
+  const allRecords = core.sessionManager.listRecords();
+  const cleanable = allRecords.filter((r) => {
+    const platform = r.platform;
+    if (systemTopicIds && platform?.topicId && (platform.topicId === systemTopicIds.notificationTopicId || platform.topicId === systemTopicIds.assistantTopicId)) return false;
+    return true;
   });
-  const firstMsgId = setupMsg.message_id;
-  try {
-    const session = await core.handleNewSession(
-      "telegram",
-      agentName,
-      workspace
-    );
-    session.threadId = String(threadId);
-    await core.sessionManager.updateSessionPlatform(session.id, {
-      topicId: threadId
-    });
-    const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
-    await renameSessionTopic(bot, chatId, threadId, finalName);
-    session.warmup().catch((err) => log8.error({ err }, "Warm-up error"));
-    return { session, threadId, firstMsgId };
-  } catch (err) {
+  if (cleanable.length === 0) {
+    await ctx.reply("Nothing to clean up.", { parse_mode: "HTML" });
+    return;
+  }
+  let deleted = 0;
+  let failed = 0;
+  for (const record of cleanable) {
     try {
-      await bot.api.deleteForumTopic(chatId, threadId);
-    } catch {
+      if (record.status === "active" || record.status === "initializing") {
+        try {
+          await core.sessionManager.cancelSession(record.sessionId);
+        } catch (err) {
+          log11.warn({ err, sessionId: record.sessionId }, "Failed to cancel session during cleanup");
+        }
+      }
+      const topicId = record.platform?.topicId;
+      if (topicId) {
+        try {
+          await ctx.api.deleteForumTopic(chatId, topicId);
+        } catch (err) {
+          log11.warn({ err, sessionId: record.sessionId, topicId }, "Failed to delete forum topic during cleanup");
+        }
+      }
+      await core.sessionManager.removeRecord(record.sessionId);
+      deleted++;
+    } catch (err) {
+      log11.error({ err, sessionId: record.sessionId }, "Failed to cleanup session");
+      failed++;
     }
-    throw err;
   }
+  await ctx.reply(
+    `\u{1F5D1} Cleaned up <b>${deleted}</b> sessions${failed > 0 ? ` (${failed} failed)` : ""}.`,
+    { parse_mode: "HTML" }
+  );
 }
 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) {
+  bot.callbackQuery(/^m:cleanup/, async (ctx) => {
+    const data = ctx.callbackQuery.data;
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    switch (data) {
+      case "m:cleanup:finished":
+        await handleCleanup(ctx, core, chatId, ["finished"]);
+        break;
+      case "m:cleanup:errors":
+        await handleCleanup(ctx, core, chatId, ["error", "cancelled"]);
+        break;
+      case "m:cleanup:all":
+        await handleCleanup(ctx, core, chatId, ["finished", "error", "cancelled"]);
+        break;
+      case "m:cleanup:everything":
+        await handleCleanupEverything(ctx, core, chatId, systemTopicIds);
+        break;
+      case "m:cleanup:everything:confirm":
+        await handleCleanupEverythingConfirmed(ctx, core, chatId, systemTopicIds);
+        break;
+    }
+  });
+}
+
+// src/adapters/telegram/commands/integrate.ts
+import { InlineKeyboard as InlineKeyboard4 } from "grammy";
 async function handleIntegrate(ctx, _core) {
   const { listIntegrations } = await import("./integrate-WUPLRJD3.js");
   const agents = listIntegrations();
-  const keyboard = new InlineKeyboard();
+  const keyboard = new InlineKeyboard4();
   for (const agent of agents) {
     keyboard.text(`\u{1F916} ${agent}`, `i:agent:${agent}`).row();
   }
@@ -3573,7 +3367,7 @@ Select an agent to manage its integrations.`,
   );
 }
 function buildAgentItemsKeyboard(agentName, items) {
-  const keyboard = new InlineKeyboard();
+  const keyboard = new InlineKeyboard4();
   for (const item of items) {
     const installed = item.isInstalled();
     keyboard.text(
@@ -3594,7 +3388,7 @@ function setupIntegrateCallbacks(bot, core) {
     if (data === "i:back") {
       const { listIntegrations } = await import("./integrate-WUPLRJD3.js");
       const agents = listIntegrations();
-      const keyboard2 = new InlineKeyboard();
+      const keyboard2 = new InlineKeyboard4();
       for (const agent of agents) {
         keyboard2.text(`\u{1F916} ${agent}`, `i:agent:${agent}`).row();
       }
@@ -3673,51 +3467,357 @@ ${resultText}`,
     }
   });
 }
-async function handlePendingWorkspaceInput(ctx, core, chatId, assistantTopicId) {
-  const userId = ctx.from?.id;
-  if (!userId) return false;
-  const pending = pendingNewSessions.get(userId);
-  if (!pending || !ctx.message?.text) return false;
-  if (pending.step !== "workspace_input" && pending.step !== "workspace") return false;
-  const threadId = ctx.message.message_thread_id;
-  if (threadId && threadId !== assistantTopicId) return false;
-  let workspace = ctx.message.text.trim();
-  if (!workspace || !pending.agentName) {
-    await ctx.reply("\u26A0\uFE0F Please enter a valid directory path.", { parse_mode: "HTML" });
-    return true;
-  }
-  if (!workspace.startsWith("/") && !workspace.startsWith("~")) {
-    const baseDir = core.configManager.get().workspace.baseDir;
-    workspace = `${baseDir.replace(/\/$/, "")}/${workspace}`;
+
+// src/adapters/telegram/commands/settings.ts
+import { InlineKeyboard as InlineKeyboard5 } from "grammy";
+var log12 = createChildLogger({ module: "telegram-settings" });
+function buildSettingsKeyboard(core) {
+  const config = core.configManager.get();
+  const fields = getSafeFields();
+  const kb = new InlineKeyboard5();
+  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();
+    }
   }
-  await startConfirmStep(ctx, chatId, userId, pending.agentName, workspace);
-  return true;
+  kb.text("\u25C0\uFE0F Back to Menu", "s:back");
+  return kb;
 }
-async function startInteractiveNewSession(ctx, core, chatId, agentName) {
-  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;
+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"}`;
   }
-  const keyboard = new InlineKeyboard();
-  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();
+  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 InlineKeyboard5();
+    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-CARRTW2F.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 InlineKeyboard6 } 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 InlineKeyboard6();
+    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" }
+    );
   }
-  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: ctx.callbackQuery?.message?.message_thread_id,
-    timer: setTimeout(() => pendingNewSessions.delete(userId), PENDING_TIMEOUT_MS)
+}
+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));
+  bot.command("newchat", (ctx) => handleNewChat(ctx, core, chatId));
+  bot.command("cancel", (ctx) => handleCancel(ctx, core, assistant));
+  bot.command("status", (ctx) => handleStatus(ctx, core));
+  bot.command("sessions", (ctx) => handleTopics(ctx, core));
+  bot.command("agents", (ctx) => handleAgents(ctx, core));
+  bot.command("help", (ctx) => handleHelp(ctx));
+  bot.command("menu", (ctx) => handleMenu(ctx));
+  bot.command("enable_dangerous", (ctx) => handleEnableDangerous(ctx, core));
+  bot.command("disable_dangerous", (ctx) => handleDisableDangerous(ctx, core));
+  bot.command("restart", (ctx) => handleRestart(ctx, core));
+  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, getAssistantSession) {
+  setupNewSessionCallbacks(bot, core, chatId);
+  setupSessionCallbacks(bot, core, chatId, systemTopicIds);
+  setupSettingsCallbacks(bot, core, getAssistantSession ?? (() => void 0));
+  setupDoctorCallbacks(bot);
+  bot.callbackQuery(/^m:/, async (ctx) => {
+    const data = ctx.callbackQuery.data;
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    switch (data) {
+      case "m:new":
+        await handleNew(ctx, core, chatId);
+        break;
+      case "m:status":
+        await handleStatus(ctx, core);
+        break;
+      case "m:agents":
+        await handleAgents(ctx, core);
+        break;
+      case "m:help":
+        await handleHelp(ctx);
+        break;
+      case "m:restart":
+        await handleRestart(ctx, core);
+        break;
+      case "m:update":
+        await handleUpdate(ctx, core);
+        break;
+      case "m:integrate":
+        await handleIntegrate(ctx, core);
+        break;
+      case "m:topics":
+        await handleTopics(ctx, core);
+        break;
+      case "m:settings":
+        await handleSettings(ctx, core);
+        break;
+    }
   });
 }
 var STATIC_COMMANDS = [
@@ -3735,13 +3835,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 InlineKeyboard2 } from "grammy";
+import { InlineKeyboard as InlineKeyboard7 } from "grammy";
 import { nanoid as nanoid2 } from "nanoid";
-var log9 = createChildLogger({ module: "telegram-permissions" });
+var log14 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
   constructor(bot, chatId, getSession, sendNotification) {
     this.bot = bot;
@@ -3758,7 +3859,7 @@ var PermissionHandler = class {
       requestId: request.id,
       options: request.options.map((o) => ({ id: o.id, isAllow: o.isAllow }))
     });
-    const keyboard = new InlineKeyboard2();
+    const keyboard = new InlineKeyboard7();
     for (const option of request.options) {
       const emoji = option.isAllow ? "\u2705" : "\u274C";
       keyboard.text(`${emoji} ${option.label}`, `p:${callbackKey}:${option.id}`);
@@ -3801,7 +3902,7 @@ ${escapeHtml(request.description)}`,
       }
       const session = this.getSession(pending.sessionId);
       const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
-      log9.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);
       }
@@ -4183,20 +4284,19 @@ Session logs auto-cleanup: 30 days (configurable via \`logging.sessionLogRetenti
 `;
 
 // src/adapters/telegram/assistant.ts
-var log10 = createChildLogger({ module: "telegram-assistant" });
+var log15 = createChildLogger({ module: "telegram-assistant" });
 async function spawnAssistant(core, adapter, assistantTopicId) {
   const config = core.configManager.get();
-  log10.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";
-  log10.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();
@@ -4212,9 +4312,9 @@ async function spawnAssistant(core, adapter, assistantTopicId) {
   };
   const systemPrompt = buildAssistantSystemPrompt(ctx);
   const ready = session.enqueuePrompt(systemPrompt).then(() => {
-    log10.info({ sessionId: session.id }, "Assistant system prompt completed");
+    log15.info({ sessionId: session.id }, "Assistant system prompt completed");
   }).catch((err) => {
-    log10.warn({ err }, "Assistant system prompt failed");
+    log15.warn({ err }, "Assistant system prompt failed");
   });
   return { session, ready };
 }
@@ -4282,8 +4382,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
@@ -4313,8 +4415,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
@@ -4347,7 +4451,7 @@ function redirectToAssistant(chatId, assistantTopicId) {
 }
 
 // src/adapters/telegram/activity.ts
-var log11 = 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 {
@@ -4379,7 +4483,7 @@ var ThinkingIndicator = class {
         this.startRefreshTimer();
       }
     } catch (err) {
-      log11.warn({ err }, "ThinkingIndicator.show() failed");
+      log16.warn({ err }, "ThinkingIndicator.show() failed");
     } finally {
       this.sending = false;
     }
@@ -4452,7 +4556,7 @@ var UsageMessage = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log11.warn({ err }, "UsageMessage.send() failed");
+      log16.warn({ err }, "UsageMessage.send() failed");
     }
   }
   getMsgId() {
@@ -4465,7 +4569,7 @@ var UsageMessage = class {
     try {
       await this.sendQueue.enqueue(() => this.api.deleteMessage(this.chatId, id));
     } catch (err) {
-      log11.warn({ err }, "UsageMessage.delete() failed");
+      log16.warn({ err }, "UsageMessage.delete() failed");
     }
   }
 };
@@ -4551,7 +4655,7 @@ var PlanCard = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log11.warn({ err }, "PlanCard flush failed");
+      log16.warn({ err }, "PlanCard flush failed");
     }
   }
 };
@@ -4614,7 +4718,7 @@ var ActivityTracker = class {
           })
         );
       } catch (err) {
-        log11.warn({ err }, "ActivityTracker.onComplete() Done send failed");
+        log16.warn({ err }, "ActivityTracker.onComplete() Done send failed");
       }
     }
   }
@@ -4697,7 +4801,7 @@ var TelegramSendQueue = class {
 
 // src/adapters/telegram/action-detect.ts
 import { nanoid as nanoid3 } from "nanoid";
-import { InlineKeyboard as InlineKeyboard3 } from "grammy";
+import { InlineKeyboard as InlineKeyboard8 } 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;
@@ -4744,7 +4848,7 @@ function removeAction(id) {
   actionMap.delete(id);
 }
 function buildActionKeyboard(actionId, action) {
-  const keyboard = new InlineKeyboard3();
+  const keyboard = new InlineKeyboard8();
   if (action.action === "new_session") {
     keyboard.text("\u2705 Create session", `a:${actionId}`);
     keyboard.text("\u274C Cancel", `a:dismiss:${actionId}`);
@@ -4807,52 +4911,492 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
             });
           } catch {
           }
-          await startInteractiveNewSession(ctx, core, chatId, action.agent);
+          await startInteractiveNewSession(ctx, core, chatId, action.agent);
+        }
+      } else if (action.action === "cancel_session") {
+        const assistantId = getAssistantSessionId();
+        const cancelled = await executeCancelSession(core, assistantId);
+        if (cancelled) {
+          await ctx.answerCallbackQuery({ text: "\u26D4 Session cancelled" });
+          const originalText = ctx.callbackQuery.message?.text ?? "";
+          try {
+            await ctx.editMessageText(
+              originalText + `
+
+\u26D4 Session "${cancelled.name ?? cancelled.id}" cancelled`,
+              { parse_mode: "HTML" }
+            );
+          } catch {
+            await ctx.editMessageReplyMarkup({
+              reply_markup: { inline_keyboard: [] }
+            });
+          }
+        } else {
+          await ctx.answerCallbackQuery({
+            text: "No active session"
+          });
+          try {
+            await ctx.editMessageReplyMarkup({
+              reply_markup: { inline_keyboard: [] }
+            });
+          } catch {
+          }
+        }
+      }
+    } catch {
+      await ctx.answerCallbackQuery({ text: "\u274C Error, try again later" });
+      try {
+        await ctx.editMessageReplyMarkup({
+          reply_markup: { inline_keyboard: [] }
+        });
+      } catch {
+      }
+    }
+  });
+}
+
+// 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;
+  }
+  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"
+      );
+    }
+  }
+  cleanup(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+};
+
+// 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 {
         }
-      } else if (action.action === "cancel_session") {
-        const assistantId = getAssistantSessionId();
-        const cancelled = await executeCancelSession(core, assistantId);
-        if (cancelled) {
-          await ctx.answerCallbackQuery({ text: "\u26D4 Session cancelled" });
-          const originalText = ctx.callbackQuery.message?.text ?? "";
-          try {
-            await ctx.editMessageText(
-              originalText + `
+      }
+    }
+    return this.messageId;
+  }
+  getMessageId() {
+    return this.messageId;
+  }
+};
 
-\u26D4 Session "${cancelled.name ?? cancelled.id}" cancelled`,
-              { parse_mode: "HTML" }
-            );
-          } catch {
-            await ctx.editMessageReplyMarkup({
-              reply_markup: { inline_keyboard: [] }
-            });
-          }
-        } else {
-          await ctx.answerCallbackQuery({
-            text: "No active session"
-          });
+// 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 ctx.editMessageReplyMarkup({
-              reply_markup: { inline_keyboard: [] }
-            });
+            await this.bot.api.editMessageReplyMarkup(
+              this.chatId,
+              finalMsgId,
+              { reply_markup: keyboard }
+            );
           } catch {
           }
         }
       }
-    } catch {
-      await ctx.answerCallbackQuery({ text: "\u274C Error, try again later" });
+    } 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 ctx.editMessageReplyMarkup({
-          reply_markup: { inline_keyboard: [] }
+        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 }
         });
-      } catch {
       }
+      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 log12 = createChildLogger({ module: "telegram" });
+var log19 = createChildLogger({ module: "telegram" });
 function patchedFetch(input, init) {
   if (init?.signal && !(init.signal instanceof AbortSignal)) {
     const nativeController = new AbortController();
@@ -4869,18 +5413,16 @@ function patchedFetch(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);
+  // Extracted managers
+  toolTracker;
+  draftManager;
+  skillManager;
   sessionTrackers = /* @__PURE__ */ new Map();
   getOrCreateTracker(sessionId, threadId) {
     let tracker = this.sessionTrackers.get(sessionId);
@@ -4901,9 +5443,17 @@ var TelegramAdapter = class extends ChannelAdapter {
   }
   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;
-      log12.error({ err: rootCause }, "Telegram bot error");
+      log19.error({ err: rootCause }, "Telegram bot error");
     });
     this.bot.api.config.use(async (prev, method, payload, signal) => {
       const maxRetries = 3;
@@ -4917,7 +5467,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         if (rateLimitedMethods.includes(method)) {
           this.sendQueue.onRateLimited();
         }
-        log12.warn(
+        log19.warn(
           { method, retryAfter, attempt: attempt + 1 },
           "Rate limited by Telegram, retrying"
         );
@@ -4969,11 +5519,18 @@ var TelegramAdapter = class extends ChannelAdapter {
       () => this.assistantSession?.id
     );
     setupIntegrateCallbacks(this.bot, this.core);
-    setupMenuCallbacks(
+    setupAllCallbacks(
       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,
@@ -5042,7 +5599,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log12.info(
+      onStart: () => log19.info(
         { chatId: this.telegramConfig.chatId },
         "Telegram bot started"
       )
@@ -5064,10 +5621,10 @@ var TelegramAdapter = class extends ChannelAdapter {
         reply_markup: buildMenuKeyboard()
       });
     } catch (err) {
-      log12.warn({ err }, "Failed to send welcome message");
+      log19.warn({ err }, "Failed to send welcome message");
     }
     try {
-      log12.info("Spawning assistant session...");
+      log19.info("Spawning assistant session...");
       const { session, ready } = await spawnAssistant(
         this.core,
         this,
@@ -5075,13 +5632,13 @@ var TelegramAdapter = class extends ChannelAdapter {
       );
       this.assistantSession = session;
       this.assistantInitializing = true;
-      log12.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;
-        log12.info({ sessionId: session.id }, "Assistant ready for user messages");
+        log19.info({ sessionId: session.id }, "Assistant ready for user messages");
       });
     } catch (err) {
-      log12.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>
@@ -5097,7 +5654,7 @@ var TelegramAdapter = class extends ChannelAdapter {
       await this.assistantSession.destroy();
     }
     await this.bot.stop();
-    log12.info("Telegram bot stopped");
+    log19.info("Telegram bot stopped");
   }
   setupRoutes() {
     this.bot.on("message:text", async (ctx) => {
@@ -5119,16 +5676,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) => log12.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();
@@ -5140,19 +5697,17 @@ var TelegramAdapter = class extends ChannelAdapter {
         threadId: String(threadId),
         userId: String(ctx.from.id),
         text: ctx.message.text
-      }).catch((err) => log12.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)) {
-      log12.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) {
@@ -5162,105 +5717,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;
-            log12.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 && !meta.viewerLinks) break;
-          await toolState.ready;
-          log12.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) {
-            log12.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": {
@@ -5277,7 +5759,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) {
@@ -5303,10 +5785,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();
@@ -5328,7 +5810,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();
@@ -5350,15 +5832,13 @@ Task completed.
     }
   }
   async sendPermissionRequest(sessionId, request) {
-    log12.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) {
-        log12.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;
@@ -5366,7 +5846,7 @@ Task completed.
     if (session.dangerousMode) {
       const allowOption = request.options.find((o) => o.isAllow);
       if (allowOption && session.permissionGate.requestId === request.id) {
-        log12.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;
@@ -5377,7 +5857,7 @@ Task completed.
   }
   async sendNotification(notification) {
     if (notification.sessionId === this.assistantSession?.id) return;
-    log12.info(
+    log19.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -5413,15 +5893,13 @@ Task completed.
     );
   }
   async createSessionThread(sessionId, name) {
-    log12.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,
@@ -5429,10 +5907,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);
@@ -5442,7 +5917,7 @@ Task completed.
     try {
       await this.bot.api.deleteForumTopic(this.telegramConfig.chatId, topicId);
     } catch (err) {
-      log12.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) {
@@ -5451,119 +5926,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) {
-      log12.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);
   }
 };
 
@@ -5578,6 +5944,7 @@ export {
   PermissionGate,
   Session,
   SessionManager,
+  SessionBridge,
   NotificationManager,
   MessageTransformer,
   OpenACPCore,
@@ -5586,4 +5953,4 @@ export {
   TopicManager,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-45DFYWJT.js.map
+//# sourceMappingURL=chunk-66RVSUAR.js.map