@openacp/cli 0.4.5 → 0.4.8

package/dist/{chunk-V5P3K4A5.js → chunk-BBPWAWE3.js}

@@ -1,3 +1,6 @@
+import {
+  getAgentCapabilities
+} from "./chunk-VA2M52CM.js";
 import {
   createChildLogger,
   createSessionLogger
@@ -7,10 +10,10 @@ import {
 function nodeToWebWritable(nodeStream) {
   return new WritableStream({
     write(chunk) {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         nodeStream.write(Buffer.from(chunk), (err) => {
           if (err) reject(err);
-          else resolve();
+          else resolve2();
         });
       });
     }
@@ -142,7 +145,7 @@ var AgentInstance = class _AgentInstance {
         env: { ...process.env, ...agentDef.env }
       }
     );
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       instance.child.on("error", (err) => {
         reject(
           new Error(
@@ -150,7 +153,7 @@ var AgentInstance = class _AgentInstance {
           )
         );
       });
-      instance.child.on("spawn", () => resolve());
+      instance.child.on("spawn", () => resolve2());
     });
     instance.stderrCapture = new StderrCapture(50);
     instance.child.stderr.on("data", (chunk) => {
@@ -428,9 +431,9 @@ ${stderr}`
             signal: state.exitStatus.signal
           };
         }
-        return new Promise((resolve) => {
+        return new Promise((resolve2) => {
           state.process.on("exit", (code, signal) => {
-            resolve({ exitCode: code, signal });
+            resolve2({ exitCode: code, signal });
           });
         });
       },
@@ -588,8 +591,8 @@ var PromptQueue = class {
   processing = false;
   async enqueue(text) {
     if (this.processing) {
-      return new Promise((resolve) => {
-        this.queue.push({ text, resolve });
+      return new Promise((resolve2) => {
+        this.queue.push({ text, resolve: resolve2 });
       });
     }
     await this.process(text);
@@ -634,8 +637,8 @@ var PermissionGate = class {
   setPending(request) {
     this.request = request;
     this.settled = false;
-    return new Promise((resolve, reject) => {
-      this.resolveFn = resolve;
+    return new Promise((resolve2, reject) => {
+      this.resolveFn = resolve2;
       this.rejectFn = reject;
     });
   }
@@ -827,6 +830,7 @@ var SessionManager = class {
         createdAt: session.createdAt.toISOString(),
         lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
         name: session.name,
+        dangerousMode: false,
         platform: {}
       });
     }
@@ -843,6 +847,17 @@ var SessionManager = class {
     }
     return void 0;
   }
+  getSessionByAgentSessionId(agentSessionId) {
+    for (const session of this.sessions.values()) {
+      if (session.agentSessionId === agentSessionId) {
+        return session;
+      }
+    }
+    return void 0;
+  }
+  getRecordByAgentSessionId(agentSessionId) {
+    return this.store?.findByAgentSessionId(agentSessionId);
+  }
   getRecordByThread(channelId, threadId) {
     return this.store?.findByPlatform(
       channelId,
@@ -910,6 +925,18 @@ var SessionManager = class {
     if (channelId) return all.filter((s) => s.channelId === channelId);
     return all;
   }
+  listRecords(filter) {
+    if (!this.store) return [];
+    let records = this.store.list();
+    if (filter?.statuses?.length) {
+      records = records.filter((r) => filter.statuses.includes(r.status));
+    }
+    return records;
+  }
+  async removeRecord(sessionId) {
+    if (!this.store) return;
+    await this.store.remove(sessionId);
+  }
   async destroyAll() {
     if (this.store) {
       for (const session of this.sessions.values()) {
@@ -1189,6 +1216,11 @@ var JsonFileSessionStore = class {
     }
     return void 0;
   }
+  findByAgentSessionId(agentSessionId) {
+    return [...this.records.values()].find(
+      (r) => r.agentSessionId === agentSessionId || r.originalAgentSessionId === agentSessionId
+    );
+  }
   list(channelId) {
     const all = [...this.records.values()];
     if (channelId) return all.filter((r) => r.channelId === channelId);
@@ -1392,6 +1424,95 @@ var OpenACPCore = class {
     }
     return session;
   }
+  async adoptSession(agentName, agentSessionId, cwd) {
+    const caps = getAgentCapabilities(agentName);
+    if (!caps.supportsResume) {
+      return { ok: false, error: "agent_not_supported", message: `Agent '${agentName}' does not support session resume` };
+    }
+    const agentDef = this.agentManager.getAgent(agentName);
+    if (!agentDef) {
+      return { ok: false, error: "agent_not_supported", message: `Agent '${agentName}' not found` };
+    }
+    const { existsSync } = await import("fs");
+    if (!existsSync(cwd)) {
+      return { ok: false, error: "invalid_cwd", message: `Directory does not exist: ${cwd}` };
+    }
+    const maxSessions = this.configManager.get().security.maxConcurrentSessions;
+    if (this.sessionManager.listSessions().length >= maxSessions) {
+      return { ok: false, error: "session_limit", message: "Maximum concurrent sessions reached" };
+    }
+    const existingRecord = this.sessionManager.getRecordByAgentSessionId(agentSessionId);
+    if (existingRecord) {
+      const platform = existingRecord.platform;
+      if (platform?.topicId) {
+        const adapter2 = this.adapters.values().next().value;
+        if (adapter2) {
+          try {
+            await adapter2.sendMessage(existingRecord.sessionId, {
+              type: "text",
+              text: "Session resumed from CLI."
+            });
+          } catch {
+          }
+        }
+        return {
+          ok: true,
+          sessionId: existingRecord.sessionId,
+          threadId: String(platform.topicId),
+          status: "existing"
+        };
+      }
+    }
+    let agentInstance;
+    try {
+      agentInstance = await this.agentManager.resume(agentName, cwd, agentSessionId);
+    } catch (err) {
+      return {
+        ok: false,
+        error: "resume_failed",
+        message: `Failed to resume session: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const session = new Session({
+      channelId: "api",
+      agentName,
+      workingDirectory: cwd,
+      agentInstance
+    });
+    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,
+      status: "adopted"
+    };
+  }
   async handleNewChat(channelId, currentThreadId) {
     const currentSession = this.sessionManager.getSessionByThread(
       channelId,
@@ -1548,6 +1669,8 @@ var ChannelAdapter = class {
     this.core = core;
     this.config = config;
   }
+  async deleteSessionThread(_sessionId) {
+  }
   // Skill commands — override in adapters that support dynamic commands
   async sendSkillCommands(_sessionId, _commands) {
   }
@@ -1560,25 +1683,56 @@ import * as http from "http";
 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 DEFAULT_PORT_FILE = path4.join(os2.homedir(), ".openacp", "api.port");
+var cachedVersion;
+function getVersion() {
+  if (cachedVersion) return cachedVersion;
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const pkgPath = path4.resolve(path4.dirname(__filename), "../../package.json");
+    const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    cachedVersion = pkg.version ?? "0.0.0-dev";
+  } catch {
+    cachedVersion = "0.0.0-dev";
+  }
+  return cachedVersion;
+}
+var SENSITIVE_KEYS = ["botToken", "token", "apiKey", "secret", "password", "webhookSecret"];
+function redactConfig(config) {
+  const redacted = structuredClone(config);
+  redactDeep(redacted);
+  return redacted;
+}
+function redactDeep(obj) {
+  for (const [key, value] of Object.entries(obj)) {
+    if (SENSITIVE_KEYS.includes(key) && typeof value === "string") {
+      obj[key] = "***";
+    } else if (value && typeof value === "object" && !Array.isArray(value)) {
+      redactDeep(value);
+    }
+  }
+}
 var ApiServer = class {
-  constructor(core, config, portFilePath) {
+  constructor(core, config, portFilePath, topicManager) {
     this.core = core;
     this.config = config;
+    this.topicManager = topicManager;
     this.portFilePath = portFilePath ?? DEFAULT_PORT_FILE;
   }
   server = null;
   actualPort = 0;
   portFilePath;
+  startedAt = Date.now();
   async start() {
     this.server = http.createServer((req, res) => this.handleRequest(req, res));
-    await new Promise((resolve, reject) => {
+    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");
           this.server = null;
-          resolve();
+          resolve2();
         } else {
           reject(err);
         }
@@ -1590,15 +1744,15 @@ var ApiServer = class {
         }
         this.writePortFile();
         log5.info({ host: this.config.host, port: this.actualPort }, "API server listening");
-        resolve();
+        resolve2();
       });
     });
   }
   async stop() {
     this.removePortFile();
     if (this.server) {
-      await new Promise((resolve) => {
-        this.server.close(() => resolve());
+      await new Promise((resolve2) => {
+        this.server.close(() => resolve2());
       });
       this.server = null;
     }
@@ -1621,15 +1775,49 @@ var ApiServer = class {
     const method = req.method?.toUpperCase();
     const url = req.url || "";
     try {
-      if (method === "POST" && url === "/api/sessions") {
+      if (method === "POST" && url === "/api/sessions/adopt") {
+        await this.handleAdoptSession(req, res);
+      } else if (method === "POST" && url === "/api/sessions") {
         await this.handleCreateSession(req, res);
-      } else if (method === "DELETE" && url.match(/^\/api\/sessions\/(.+)$/)) {
-        const sessionId = url.match(/^\/api\/sessions\/(.+)$/)[1];
+      } else if (method === "POST" && url.match(/^\/api\/sessions\/([^/]+)\/prompt$/)) {
+        const sessionId = decodeURIComponent(url.match(/^\/api\/sessions\/([^/]+)\/prompt$/)[1]);
+        await this.handleSendPrompt(sessionId, req, res);
+      } else if (method === "PATCH" && url.match(/^\/api\/sessions\/([^/]+)\/dangerous$/)) {
+        const sessionId = decodeURIComponent(url.match(/^\/api\/sessions\/([^/]+)\/dangerous$/)[1]);
+        await this.handleToggleDangerous(sessionId, req, res);
+      } else if (method === "GET" && url.match(/^\/api\/sessions\/([^/]+)$/)) {
+        const sessionId = decodeURIComponent(url.match(/^\/api\/sessions\/([^/]+)$/)[1]);
+        await this.handleGetSession(sessionId, res);
+      } else if (method === "DELETE" && url.match(/^\/api\/sessions\/([^/]+)$/)) {
+        const sessionId = decodeURIComponent(url.match(/^\/api\/sessions\/([^/]+)$/)[1]);
         await this.handleCancelSession(sessionId, res);
       } else if (method === "GET" && url === "/api/sessions") {
         await this.handleListSessions(res);
       } else if (method === "GET" && url === "/api/agents") {
         await this.handleListAgents(res);
+      } else if (method === "GET" && url === "/api/health") {
+        await this.handleHealth(res);
+      } else if (method === "GET" && url === "/api/version") {
+        await this.handleVersion(res);
+      } else if (method === "GET" && url === "/api/config") {
+        await this.handleGetConfig(res);
+      } else if (method === "PATCH" && url === "/api/config") {
+        await this.handleUpdateConfig(req, res);
+      } else if (method === "GET" && url === "/api/adapters") {
+        await this.handleListAdapters(res);
+      } else if (method === "GET" && url === "/api/tunnel") {
+        await this.handleTunnelStatus(res);
+      } else if (method === "POST" && url === "/api/notify") {
+        await this.handleNotify(req, res);
+      } else if (method === "POST" && url === "/api/restart") {
+        await this.handleRestart(res);
+      } else if (method === "GET" && url.match(/^\/api\/topics(\?.*)?$/)) {
+        await this.handleListTopics(url, res);
+      } else if (method === "POST" && url === "/api/topics/cleanup") {
+        await this.handleCleanupTopics(req, res);
+      } else if (method === "DELETE" && url.match(/^\/api\/topics\/([^/?]+)/)) {
+        const match = url.match(/^\/api\/topics\/([^/?]+)/);
+        await this.handleDeleteTopic(decodeURIComponent(match[1]), url, res);
       } else {
         this.sendJson(res, 404, { error: "Not found" });
       }
@@ -1687,6 +1875,222 @@ var ApiServer = class {
       workspace: session.workingDirectory
     });
   }
+  async handleSendPrompt(sessionId, req, res) {
+    const session = this.core.sessionManager.getSession(sessionId);
+    if (!session) {
+      this.sendJson(res, 404, { error: `Session "${sessionId}" not found` });
+      return;
+    }
+    if (session.status === "cancelled" || session.status === "finished" || session.status === "error") {
+      this.sendJson(res, 400, { error: `Session is ${session.status}` });
+      return;
+    }
+    const body = await this.readBody(req);
+    let prompt;
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        prompt = parsed.prompt;
+      } catch {
+        this.sendJson(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+    }
+    if (!prompt) {
+      this.sendJson(res, 400, { error: "Missing prompt" });
+      return;
+    }
+    session.enqueuePrompt(prompt).catch(() => {
+    });
+    this.sendJson(res, 200, { ok: true, sessionId, queueDepth: session.queueDepth });
+  }
+  async handleGetSession(sessionId, res) {
+    const session = this.core.sessionManager.getSession(sessionId);
+    if (!session) {
+      this.sendJson(res, 404, { error: `Session "${sessionId}" not found` });
+      return;
+    }
+    this.sendJson(res, 200, {
+      session: {
+        id: session.id,
+        agent: session.agentName,
+        status: session.status,
+        name: session.name ?? null,
+        workspace: session.workingDirectory,
+        createdAt: session.createdAt.toISOString(),
+        dangerousMode: session.dangerousMode,
+        queueDepth: session.queueDepth,
+        promptRunning: session.promptRunning,
+        threadId: session.threadId,
+        channelId: session.channelId,
+        agentSessionId: session.agentSessionId
+      }
+    });
+  }
+  async handleToggleDangerous(sessionId, req, res) {
+    const session = this.core.sessionManager.getSession(sessionId);
+    if (!session) {
+      this.sendJson(res, 404, { error: `Session "${sessionId}" not found` });
+      return;
+    }
+    const body = await this.readBody(req);
+    let enabled;
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        enabled = parsed.enabled;
+      } catch {
+        this.sendJson(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+    }
+    if (typeof enabled !== "boolean") {
+      this.sendJson(res, 400, { error: "Missing enabled boolean" });
+      return;
+    }
+    session.dangerousMode = enabled;
+    await this.core.sessionManager.updateSessionDangerousMode(sessionId, enabled);
+    this.sendJson(res, 200, { ok: true, dangerousMode: enabled });
+  }
+  async handleHealth(res) {
+    const activeSessions = this.core.sessionManager.listSessions();
+    const allRecords = this.core.sessionManager.listRecords();
+    const mem = process.memoryUsage();
+    const tunnel = this.core.tunnelService;
+    this.sendJson(res, 200, {
+      status: "ok",
+      uptime: Date.now() - this.startedAt,
+      version: getVersion(),
+      memory: {
+        rss: mem.rss,
+        heapUsed: mem.heapUsed,
+        heapTotal: mem.heapTotal
+      },
+      sessions: {
+        active: activeSessions.filter((s) => s.status === "active" || s.status === "initializing").length,
+        total: allRecords.length
+      },
+      adapters: Array.from(this.core.adapters.keys()),
+      tunnel: tunnel ? { enabled: true, url: tunnel.getPublicUrl() } : { enabled: false }
+    });
+  }
+  async handleVersion(res) {
+    this.sendJson(res, 200, { version: getVersion() });
+  }
+  async handleGetConfig(res) {
+    const config = this.core.configManager.get();
+    this.sendJson(res, 200, { config: redactConfig(config) });
+  }
+  async handleUpdateConfig(req, res) {
+    const body = await this.readBody(req);
+    let configPath;
+    let value;
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        configPath = parsed.path;
+        value = parsed.value;
+      } catch {
+        this.sendJson(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+    }
+    if (!configPath) {
+      this.sendJson(res, 400, { error: "Missing path" });
+      return;
+    }
+    const currentConfig = this.core.configManager.get();
+    const cloned = structuredClone(currentConfig);
+    const parts = configPath.split(".");
+    let target = cloned;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (target[parts[i]] && typeof target[parts[i]] === "object" && !Array.isArray(target[parts[i]])) {
+        target = target[parts[i]];
+      } else {
+        this.sendJson(res, 400, { error: "Invalid config path" });
+        return;
+      }
+    }
+    const lastKey = parts[parts.length - 1];
+    if (!(lastKey in target)) {
+      this.sendJson(res, 400, { error: "Invalid config path" });
+      return;
+    }
+    target[lastKey] = value;
+    const { ConfigSchema } = await import("./config-H2DSEHNW.js");
+    const result = ConfigSchema.safeParse(cloned);
+    if (!result.success) {
+      this.sendJson(res, 400, {
+        error: "Validation failed",
+        details: result.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+      return;
+    }
+    const updates = {};
+    let updateTarget = updates;
+    for (let i = 0; i < parts.length - 1; i++) {
+      updateTarget[parts[i]] = {};
+      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
+    );
+    this.sendJson(res, 200, {
+      ok: true,
+      needsRestart,
+      config: redactConfig(this.core.configManager.get())
+    });
+  }
+  async handleListAdapters(res) {
+    const adapters = Array.from(this.core.adapters.entries()).map(([name]) => ({
+      name,
+      type: "built-in"
+    }));
+    this.sendJson(res, 200, { adapters });
+  }
+  async handleTunnelStatus(res) {
+    const tunnel = this.core.tunnelService;
+    if (tunnel) {
+      this.sendJson(res, 200, { enabled: true, url: tunnel.getPublicUrl(), provider: this.core.configManager.get().tunnel.provider });
+    } else {
+      this.sendJson(res, 200, { enabled: false });
+    }
+  }
+  async handleNotify(req, res) {
+    const body = await this.readBody(req);
+    let message;
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        message = parsed.message;
+      } catch {
+        this.sendJson(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+    }
+    if (!message) {
+      this.sendJson(res, 400, { error: "Missing message" });
+      return;
+    }
+    await this.core.notificationManager.notifyAll({
+      sessionId: "system",
+      type: "completed",
+      summary: message
+    });
+    this.sendJson(res, 200, { ok: true });
+  }
+  async handleRestart(res) {
+    if (!this.core.requestRestart) {
+      this.sendJson(res, 501, { error: "Restart not available" });
+      return;
+    }
+    this.sendJson(res, 200, { ok: true, message: "Restarting..." });
+    setImmediate(() => this.core.requestRestart());
+  }
   async handleCancelSession(sessionId, res) {
     const session = this.core.sessionManager.getSession(sessionId);
     if (!session) {
@@ -1708,34 +2112,180 @@ var ApiServer = class {
       }))
     });
   }
+  async handleAdoptSession(req, res) {
+    const body = await this.readBody(req);
+    if (!body) {
+      return this.sendJson(res, 400, { error: "bad_request", message: "Empty request body" });
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      return this.sendJson(res, 400, { error: "bad_request", message: "Invalid JSON" });
+    }
+    const { agent, agentSessionId, cwd } = parsed;
+    if (!agent || !agentSessionId) {
+      return this.sendJson(res, 400, { error: "bad_request", message: "Missing required fields: agent, agentSessionId" });
+    }
+    const result = await this.core.adoptSession(agent, agentSessionId, cwd ?? process.cwd());
+    if (result.ok) {
+      return this.sendJson(res, 200, result);
+    } else {
+      const status = result.error === "session_limit" ? 429 : result.error === "agent_not_supported" ? 400 : 500;
+      return this.sendJson(res, status, result);
+    }
+  }
   async handleListAgents(res) {
     const agents = this.core.agentManager.getAvailableAgents();
     const defaultAgent = this.core.configManager.get().defaultAgent;
-    this.sendJson(res, 200, {
-      agents: agents.map((a) => ({
-        name: a.name,
-        command: a.command,
-        args: a.args
-      })),
-      default: defaultAgent
-    });
+    const agentsWithCaps = agents.map((a) => ({
+      ...a,
+      capabilities: getAgentCapabilities(a.name)
+    }));
+    this.sendJson(res, 200, { agents: agentsWithCaps, default: defaultAgent });
   }
   sendJson(res, status, data) {
     res.writeHead(status, { "Content-Type": "application/json" });
     res.end(JSON.stringify(data));
   }
+  async handleListTopics(url, res) {
+    if (!this.topicManager) {
+      this.sendJson(res, 501, { error: "Topic management not available" });
+      return;
+    }
+    const params = new URL(url, "http://localhost").searchParams;
+    const statusParam = params.get("status");
+    const filter = statusParam ? { statuses: statusParam.split(",") } : void 0;
+    const topics = this.topicManager.listTopics(filter);
+    this.sendJson(res, 200, { topics });
+  }
+  async handleDeleteTopic(sessionId, url, res) {
+    if (!this.topicManager) {
+      this.sendJson(res, 501, { error: "Topic management not available" });
+      return;
+    }
+    const params = new URL(url, "http://localhost").searchParams;
+    const force = params.get("force") === "true";
+    const result = await this.topicManager.deleteTopic(sessionId, force ? { confirmed: true } : void 0);
+    if (result.ok) {
+      this.sendJson(res, 200, result);
+    } else if (result.needsConfirmation) {
+      this.sendJson(res, 409, { error: "Session is active", needsConfirmation: true, session: result.session });
+    } else if (result.error === "Cannot delete system topic") {
+      this.sendJson(res, 403, { error: result.error });
+    } else {
+      this.sendJson(res, 404, { error: result.error ?? "Not found" });
+    }
+  }
+  async handleCleanupTopics(req, res) {
+    if (!this.topicManager) {
+      this.sendJson(res, 501, { error: "Topic management not available" });
+      return;
+    }
+    const body = await this.readBody(req);
+    let statuses;
+    if (body) {
+      try {
+        statuses = JSON.parse(body).statuses;
+      } catch {
+      }
+    }
+    const result = await this.topicManager.cleanup(statuses);
+    this.sendJson(res, 200, result);
+  }
   readBody(req) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let data = "";
       req.on("data", (chunk) => {
         data += chunk;
       });
-      req.on("end", () => resolve(data));
-      req.on("error", () => resolve(""));
+      req.on("end", () => resolve2(data));
+      req.on("error", () => resolve2(""));
     });
   }
 };
 
+// src/core/topic-manager.ts
+var log6 = createChildLogger({ module: "topic-manager" });
+var TopicManager = class {
+  constructor(sessionManager, adapter, systemTopicIds) {
+    this.sessionManager = sessionManager;
+    this.adapter = adapter;
+    this.systemTopicIds = systemTopicIds;
+  }
+  listTopics(filter) {
+    const records = this.sessionManager.listRecords(filter);
+    return records.filter((r) => !this.isSystemTopic(r)).filter((r) => !filter?.statuses?.length || filter.statuses.includes(r.status)).map((r) => ({
+      sessionId: r.sessionId,
+      topicId: r.platform?.topicId ?? null,
+      name: r.name ?? null,
+      status: r.status,
+      agentName: r.agentName,
+      lastActiveAt: r.lastActiveAt
+    }));
+  }
+  async deleteTopic(sessionId, options) {
+    const records = this.sessionManager.listRecords();
+    const record = records.find((r) => r.sessionId === sessionId);
+    if (!record) return { ok: false, error: "Session not found" };
+    if (this.isSystemTopic(record)) return { ok: false, error: "Cannot delete system topic" };
+    const isActive = record.status === "active" || record.status === "initializing";
+    if (isActive && !options?.confirmed) {
+      return {
+        ok: false,
+        needsConfirmation: true,
+        session: { id: record.sessionId, name: record.name ?? null, status: record.status }
+      };
+    }
+    if (isActive) {
+      await this.sessionManager.cancelSession(sessionId);
+    }
+    const topicId = record.platform?.topicId ?? null;
+    if (this.adapter && topicId) {
+      try {
+        await this.adapter.deleteSessionThread(sessionId);
+      } catch (err) {
+        log6.warn({ err, sessionId, topicId }, "Failed to delete platform thread, removing record anyway");
+      }
+    }
+    await this.sessionManager.removeRecord(sessionId);
+    return { ok: true, topicId };
+  }
+  async cleanup(statuses) {
+    const targetStatuses = statuses?.length ? statuses : ["finished", "error", "cancelled"];
+    const records = this.sessionManager.listRecords({ statuses: targetStatuses });
+    const targets = records.filter((r) => !this.isSystemTopic(r)).filter((r) => targetStatuses.includes(r.status));
+    const deleted = [];
+    const failed = [];
+    for (const record of targets) {
+      try {
+        const isActive = record.status === "active" || record.status === "initializing";
+        if (isActive) {
+          await this.sessionManager.cancelSession(record.sessionId);
+        }
+        const topicId = record.platform?.topicId;
+        if (this.adapter && topicId) {
+          try {
+            await this.adapter.deleteSessionThread(record.sessionId);
+          } catch (err) {
+            log6.warn({ err, sessionId: record.sessionId }, "Failed to delete platform thread during cleanup");
+          }
+        }
+        await this.sessionManager.removeRecord(record.sessionId);
+        deleted.push(record.sessionId);
+      } catch (err) {
+        failed.push({ sessionId: record.sessionId, error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    return { deleted, failed };
+  }
+  isSystemTopic(record) {
+    const topicId = record.platform?.topicId;
+    if (!topicId) return false;
+    return topicId === this.systemTopicIds.notificationTopicId || topicId === this.systemTopicIds.assistantTopicId;
+  }
+};
+
 // src/adapters/telegram/adapter.ts
 import { Bot } from "grammy";
 
@@ -1869,7 +2419,7 @@ function formatUsage(usage) {
   return `${emoji} ${formatTokens(tokensUsed)} / ${formatTokens(contextSize)} tokens
 ${bar} ${pct}%`;
 }
-function splitMessage(text, maxLength = 4096) {
+function splitMessage(text, maxLength = 3800) {
   if (text.length <= maxLength) return [text];
   const chunks = [];
   let remaining = text;
@@ -1879,14 +2429,23 @@ function splitMessage(text, maxLength = 4096) {
       break;
     }
     let splitAt = remaining.lastIndexOf("\n\n", maxLength);
-    if (splitAt === -1 || splitAt < maxLength * 0.5) {
+    if (splitAt === -1 || splitAt < maxLength * 0.2) {
       splitAt = remaining.lastIndexOf("\n", maxLength);
     }
-    if (splitAt === -1 || splitAt < maxLength * 0.5) {
+    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).trimStart();
+    remaining = remaining.slice(splitAt).replace(/^\n+/, "");
   }
   return chunks;
 }
@@ -1923,14 +2482,22 @@ var MessageDraft = class {
   async flush() {
     if (!this.buffer) return;
     if (this.firstFlushPending) return;
-    const html = markdownToTelegramHtml(this.buffer);
-    const truncated = html.length > 4096 ? html.slice(0, 4090) + "\n..." : html;
-    if (!truncated) 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;
       try {
         const result = await this.sendQueue.enqueue(
-          () => this.bot.api.sendMessage(this.chatId, truncated, {
+          () => this.bot.api.sendMessage(this.chatId, html, {
             message_thread_id: this.threadId,
             parse_mode: "HTML",
             disable_notification: true
@@ -1948,7 +2515,7 @@ var MessageDraft = class {
     } else {
       try {
         await this.sendQueue.enqueue(
-          () => this.bot.api.editMessageText(this.chatId, this.messageId, truncated, {
+          () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
             parse_mode: "HTML"
           }),
           { type: "text", key: this.sessionId }
@@ -1968,21 +2535,20 @@ var MessageDraft = class {
     if (this.messageId && this.buffer === this.lastSentBuffer) {
       return this.messageId;
     }
-    const html = markdownToTelegramHtml(this.buffer);
-    const chunks = splitMessage(html);
-    try {
-      for (let i = 0; i < chunks.length; i++) {
-        const chunk = chunks[i];
+    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, chunk, {
+            () => 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, chunk, {
+            () => this.bot.api.sendMessage(this.chatId, html, {
               message_thread_id: this.threadId,
               parse_mode: "HTML",
               disable_notification: true
@@ -1993,17 +2559,25 @@ var MessageDraft = class {
             this.messageId = msg.message_id;
           }
         }
-      }
-    } catch {
-      if (this.buffer !== this.lastSentBuffer) {
+      } catch {
         try {
-          await this.sendQueue.enqueue(
-            () => this.bot.api.sendMessage(this.chatId, this.buffer.slice(0, 4096), {
-              message_thread_id: this.threadId,
-              disable_notification: true
-            }),
-            { type: "other" }
-          );
+          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 {
         }
       }
@@ -2048,12 +2622,13 @@ function buildDeepLink(chatId, messageId) {
 
 // src/adapters/telegram/commands.ts
 import { InlineKeyboard } from "grammy";
-var log7 = createChildLogger({ module: "telegram-commands" });
+var log8 = createChildLogger({ module: "telegram-commands" });
 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));
@@ -2061,11 +2636,12 @@ function setupCommands(bot, core, chatId, assistant) {
   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));
 }
 function buildMenuKeyboard() {
-  return new InlineKeyboard().text("\u{1F195} New Session", "m:new").text("\u{1F4AC} New Chat", "m:newchat").row().text("\u26D4 Cancel", "m:cancel").text("\u{1F4CA} Status", "m:status").row().text("\u{1F916} Agents", "m:agents").text("\u2753 Help", "m:help").row().text("\u{1F504} Restart", "m:restart").text("\u2B06\uFE0F Update", "m:update");
+  return new InlineKeyboard().text("\u{1F195} New Session", "m:new").text("\u{1F4AC} New Chat", "m:newchat").row().text("\u26D4 Cancel", "m:cancel").text("\u{1F4CA} Status", "m:status").row().text("\u{1F4CB} Sessions", "m:topics").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) {
+function setupMenuCallbacks(bot, core, chatId, systemTopicIds) {
   bot.callbackQuery(/^m:/, async (ctx) => {
     const data = ctx.callbackQuery.data;
     try {
@@ -2097,6 +2673,27 @@ function setupMenuCallbacks(bot, core, chatId) {
       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;
     }
   });
 }
@@ -2122,7 +2719,7 @@ async function handleNew(ctx, core, chatId, assistant) {
       return;
     }
   }
-  log7.info({ userId: ctx.from?.id, agentName }, "New session command");
+  log8.info({ userId: ctx.from?.id, agentName }, "New session command");
   let threadId;
   try {
     const topicName = `\u{1F504} New Session`;
@@ -2156,9 +2753,9 @@ async function handleNew(ctx, core, chatId, assistant) {
         reply_markup: buildDangerousModeKeyboard(session.id, false)
       }
     );
-    session.warmup().catch((err) => log7.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log8.error({ err }, "Warm-up error"));
   } catch (err) {
-    log7.error({ err }, "Session creation failed");
+    log8.error({ err }, "Session creation failed");
     if (threadId) {
       try {
         await ctx.api.deleteForumTopic(chatId, threadId);
@@ -2235,7 +2832,7 @@ async function handleNewChat(ctx, core, chatId) {
         reply_markup: buildDangerousModeKeyboard(session.id, false)
       }
     );
-    session.warmup().catch((err) => log7.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log8.error({ err }, "Warm-up error"));
   } catch (err) {
     if (newThreadId) {
       try {
@@ -2264,14 +2861,14 @@ async function handleCancel(ctx, core, assistant) {
     String(threadId)
   );
   if (session) {
-    log7.info({ sessionId: session.id }, "Cancel session command");
+    log8.info({ sessionId: session.id }, "Cancel session command");
     await session.cancel();
     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") {
-    log7.info({ sessionId: record.sessionId }, "Cancel session command (from store)");
+    log8.info({ sessionId: record.sessionId }, "Cancel session command (from store)");
     await core.sessionManager.cancelSession(record.sessionId);
     await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
   }
@@ -2321,6 +2918,188 @@ Total sessions: ${sessions.length}`,
     );
   }
 }
+async function handleTopics(ctx, core) {
+  try {
+    const allRecords = core.sessionManager.listRecords();
+    const records = allRecords.filter((r) => {
+      const platform = r.platform;
+      return !!platform?.topicId;
+    });
+    const headlessCount = allRecords.length - records.length;
+    if (records.length === 0) {
+      const extra = headlessCount > 0 ? ` (${headlessCount} headless hidden)` : "";
+      await ctx.reply(`No sessions with topics found.${extra}`, { parse_mode: "HTML" });
+      return;
+    }
+    const statusEmoji = {
+      active: "\u{1F7E2}",
+      initializing: "\u{1F7E1}",
+      finished: "\u2705",
+      error: "\u274C",
+      cancelled: "\u26D4"
+    };
+    const statusOrder = { active: 0, initializing: 1, error: 2, finished: 3, cancelled: 4 };
+    records.sort((a, b) => (statusOrder[a.status] ?? 5) - (statusOrder[b.status] ?? 5));
+    const MAX_DISPLAY = 30;
+    const displayed = records.slice(0, MAX_DISPLAY);
+    const lines = displayed.map((r) => {
+      const emoji = statusEmoji[r.status] || "\u26AA";
+      const name = r.name?.trim();
+      const label = name ? escapeHtml(name) : `<i>${escapeHtml(r.agentName)} session</i>`;
+      return `${emoji} ${label}  <code>[${r.status}]</code>`;
+    });
+    const header = `<b>Sessions: ${records.length}</b>` + (headlessCount > 0 ? ` (${headlessCount} headless hidden)` : "");
+    const truncated = records.length > MAX_DISPLAY ? `
+
+<i>...and ${records.length - MAX_DISPLAY} more</i>` : "";
+    const finishedCount = 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();
+    if (finishedCount > 0) {
+      keyboard.text(`Cleanup finished (${finishedCount})`, "m:cleanup:finished").row();
+    }
+    if (errorCount > 0) {
+      keyboard.text(`Cleanup errors (${errorCount})`, "m:cleanup:errors").row();
+    }
+    if (finishedCount + errorCount > 0) {
+      keyboard.text(`Cleanup all non-active (${finishedCount + errorCount})`, "m:cleanup:all").row();
+    }
+    keyboard.text(`\u26A0\uFE0F Cleanup ALL (${records.length})`, "m:cleanup:everything").row();
+    keyboard.text("Refresh", "m:topics");
+    await ctx.reply(
+      `${header}
+
+${lines.join("\n")}${truncated}`,
+      { parse_mode: "HTML", reply_markup: keyboard }
+    );
+  } catch (err) {
+    log8.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);
+  });
+  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 {
+      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 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;
+    return true;
+  });
+  if (cleanable.length === 0) {
+    await ctx.reply("Nothing to clean up.", { parse_mode: "HTML" });
+    return;
+  }
+  const statusCounts = /* @__PURE__ */ new Map();
+  for (const r of cleanable) {
+    statusCounts.set(r.status, (statusCounts.get(r.status) ?? 0) + 1);
+  }
+  const statusEmoji = {
+    active: "\u{1F7E2}",
+    initializing: "\u{1F7E1}",
+    finished: "\u2705",
+    error: "\u274C",
+    cancelled: "\u26D4"
+  };
+  const breakdown = Array.from(statusCounts.entries()).map(([status, count]) => `${statusEmoji[status] ?? "\u26AA"} ${status}: ${count}`).join("\n");
+  const activeCount = (statusCounts.get("active") ?? 0) + (statusCounts.get("initializing") ?? 0);
+  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");
+  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;
@@ -2365,7 +3144,7 @@ function setupDangerousModeCallbacks(bot, core) {
     const session = core.sessionManager.getSession(sessionId);
     if (session) {
       session.dangerousMode = !session.dangerousMode;
-      log7.info({ sessionId, dangerousMode: session.dangerousMode }, "Dangerous mode toggled via button");
+      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";
@@ -2392,7 +3171,7 @@ function setupDangerousModeCallbacks(bot, core) {
     const newDangerousMode = !(record.dangerousMode ?? false);
     core.sessionManager.updateSessionDangerousMode(sessionId, newDangerousMode).catch(() => {
     });
-    log7.info({ sessionId, dangerousMode: newDangerousMode }, "Dangerous mode toggled via button (store-only, session not in memory)");
+    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 });
@@ -2560,7 +3339,7 @@ async function executeNewSession(bot, core, chatId, agentName, workspace) {
     });
     const finalName = `\u{1F504} ${session.agentName} \u2014 New Session`;
     await renameSessionTopic(bot, chatId, threadId, finalName);
-    session.warmup().catch((err) => log7.error({ err }, "Warm-up error"));
+    session.warmup().catch((err) => log8.error({ err }, "Warm-up error"));
     return { session, threadId, firstMsgId };
   } catch (err) {
     try {
@@ -2577,16 +3356,134 @@ async function executeCancelSession(core, excludeSessionId) {
   await session.cancel();
   return session;
 }
+async function handleIntegrate(ctx, _core) {
+  const { listIntegrations } = await import("./integrate-WUPLRJD3.js");
+  const agents = listIntegrations();
+  const keyboard = new InlineKeyboard();
+  for (const agent of agents) {
+    keyboard.text(`\u{1F916} ${agent}`, `i:agent:${agent}`).row();
+  }
+  await ctx.reply(
+    `<b>\u{1F517} Integrations</b>
+
+Select an agent to manage its integrations.`,
+    { parse_mode: "HTML", reply_markup: keyboard }
+  );
+}
+function buildAgentItemsKeyboard(agentName, items) {
+  const keyboard = new InlineKeyboard();
+  for (const item of items) {
+    const installed = item.isInstalled();
+    keyboard.text(
+      installed ? `\u2705 ${item.name} \u2014 Uninstall` : `\u{1F4E6} ${item.name} \u2014 Install`,
+      installed ? `i:uninstall:${agentName}:${item.id}` : `i:install:${agentName}:${item.id}`
+    ).row();
+  }
+  keyboard.text("\u2190 Back", "i:back").row();
+  return keyboard;
+}
+function setupIntegrateCallbacks(bot, core) {
+  bot.callbackQuery(/^i:/, async (ctx) => {
+    const data = ctx.callbackQuery.data;
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    if (data === "i:back") {
+      const { listIntegrations } = await import("./integrate-WUPLRJD3.js");
+      const agents = listIntegrations();
+      const keyboard2 = new InlineKeyboard();
+      for (const agent of agents) {
+        keyboard2.text(`\u{1F916} ${agent}`, `i:agent:${agent}`).row();
+      }
+      try {
+        await ctx.editMessageText(
+          `<b>\u{1F517} Integrations</b>
+
+Select an agent to manage its integrations.`,
+          { parse_mode: "HTML", reply_markup: keyboard2 }
+        );
+      } catch {
+      }
+      return;
+    }
+    const agentMatch = data.match(/^i:agent:(.+)$/);
+    if (agentMatch) {
+      const agentName2 = agentMatch[1];
+      const { getIntegration: getIntegration2 } = await import("./integrate-WUPLRJD3.js");
+      const integration2 = getIntegration2(agentName2);
+      if (!integration2) {
+        await ctx.reply(`\u274C No integration available for '${escapeHtml(agentName2)}'.`, { parse_mode: "HTML" });
+        return;
+      }
+      const keyboard2 = buildAgentItemsKeyboard(agentName2, integration2.items);
+      try {
+        await ctx.editMessageText(
+          `<b>\u{1F517} ${escapeHtml(agentName2)} Integrations</b>
+
+${integration2.items.map((i) => `\u2022 <b>${escapeHtml(i.name)}</b> \u2014 ${escapeHtml(i.description)}`).join("\n")}`,
+          { parse_mode: "HTML", reply_markup: keyboard2 }
+        );
+      } catch {
+        await ctx.reply(
+          `<b>\u{1F517} ${escapeHtml(agentName2)} Integrations</b>`,
+          { parse_mode: "HTML", reply_markup: keyboard2 }
+        );
+      }
+      return;
+    }
+    const actionMatch = data.match(/^i:(install|uninstall):([^:]+):(.+)$/);
+    if (!actionMatch) return;
+    const action = actionMatch[1];
+    const agentName = actionMatch[2];
+    const itemId = actionMatch[3];
+    const { getIntegration } = await import("./integrate-WUPLRJD3.js");
+    const integration = getIntegration(agentName);
+    if (!integration) return;
+    const item = integration.items.find((i) => i.id === itemId);
+    if (!item) return;
+    const result = action === "install" ? await item.install() : await item.uninstall();
+    const installed = action === "install" && result.success;
+    await core.configManager.save({
+      integrations: {
+        [agentName]: {
+          installed,
+          installedAt: installed ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+        }
+      }
+    });
+    const statusEmoji = result.success ? "\u2705" : "\u274C";
+    const actionLabel = action === "install" ? "installed" : "uninstalled";
+    const logsText = result.logs.map((l) => `<code>${escapeHtml(l)}</code>`).join("\n");
+    const resultText = `${statusEmoji} <b>${escapeHtml(item.name)}</b> ${actionLabel}.
+
+${logsText}`;
+    const keyboard = buildAgentItemsKeyboard(agentName, integration.items);
+    try {
+      await ctx.editMessageText(
+        `<b>\u{1F517} ${escapeHtml(agentName)} Integrations</b>
+
+${resultText}`,
+        { parse_mode: "HTML", reply_markup: keyboard }
+      );
+    } catch {
+      await ctx.reply(resultText, { parse_mode: "HTML" });
+    }
+  });
+}
 var STATIC_COMMANDS = [
   { command: "new", description: "Create new session" },
   { command: "newchat", description: "New chat, same agent & workspace" },
   { command: "cancel", description: "Cancel current session" },
   { command: "status", description: "Show status" },
+  { command: "sessions", description: "List all sessions" },
   { command: "agents", description: "List available agents" },
   { command: "help", description: "Help" },
   { command: "menu", description: "Show menu" },
   { command: "enable_dangerous", description: "Auto-approve all permission requests (session only)" },
   { command: "disable_dangerous", description: "Restore normal permission prompts (session only)" },
+  { command: "integrate", description: "Manage agent integrations" },
+  { command: "handoff", description: "Continue this session in your terminal" },
   { command: "restart", description: "Restart OpenACP" },
   { command: "update", description: "Update to latest version and restart" }
 ];
@@ -2594,7 +3491,7 @@ var STATIC_COMMANDS = [
 // src/adapters/telegram/permissions.ts
 import { InlineKeyboard as InlineKeyboard2 } from "grammy";
 import { nanoid as nanoid2 } from "nanoid";
-var log8 = createChildLogger({ module: "telegram-permissions" });
+var log9 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
   constructor(bot, chatId, getSession, sendNotification) {
     this.bot = bot;
@@ -2654,7 +3551,7 @@ ${escapeHtml(request.description)}`,
       }
       const session = this.getSession(pending.sessionId);
       const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
-      log8.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
+      log9.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
       if (session?.permissionGate.requestId === pending.requestId) {
         session.permissionGate.resolve(optionId);
       }
@@ -2672,10 +3569,10 @@ ${escapeHtml(request.description)}`,
 };
 
 // src/adapters/telegram/assistant.ts
-var log9 = createChildLogger({ module: "telegram-assistant" });
+var log10 = createChildLogger({ module: "telegram-assistant" });
 async function spawnAssistant(core, adapter, assistantTopicId) {
   const config = core.configManager.get();
-  log9.info({ agent: config.defaultAgent }, "Creating assistant session...");
+  log10.info({ agent: config.defaultAgent }, "Creating assistant session...");
   const session = await core.sessionManager.createSession(
     "telegram",
     config.defaultAgent,
@@ -2684,30 +3581,44 @@ async function spawnAssistant(core, adapter, assistantTopicId) {
   );
   session.threadId = String(assistantTopicId);
   session.name = "Assistant";
-  log9.info({ sessionId: session.id }, "Assistant agent spawned");
+  log10.info({ sessionId: session.id }, "Assistant agent spawned");
   core.wireSessionEvents(session, adapter);
-  const systemPrompt = buildAssistantSystemPrompt(config);
+  const allRecords = core.sessionManager.listRecords();
+  const activeCount = allRecords.filter((r) => r.status === "active" || r.status === "initializing").length;
+  const statusCounts = /* @__PURE__ */ new Map();
+  for (const r of allRecords) {
+    statusCounts.set(r.status, (statusCounts.get(r.status) ?? 0) + 1);
+  }
+  const topicSummary = Array.from(statusCounts.entries()).map(([status, count]) => ({ status, count }));
+  const ctx = {
+    config,
+    activeSessionCount: activeCount,
+    totalSessionCount: allRecords.length,
+    topicSummary
+  };
+  const systemPrompt = buildAssistantSystemPrompt(ctx);
   const ready = session.enqueuePrompt(systemPrompt).then(() => {
-    log9.info({ sessionId: session.id }, "Assistant system prompt completed");
+    log10.info({ sessionId: session.id }, "Assistant system prompt completed");
   }).catch((err) => {
-    log9.warn({ err }, "Assistant system prompt failed");
+    log10.warn({ err }, "Assistant system prompt failed");
   });
   return { session, ready };
 }
-function buildAssistantSystemPrompt(config) {
+function buildAssistantSystemPrompt(ctx) {
+  const { config, activeSessionCount, totalSessionCount, topicSummary } = ctx;
   const agentNames = Object.keys(config.agents).join(", ");
-  return `You are the OpenACP Assistant. Help users manage their AI coding sessions.
+  const topicBreakdown = topicSummary.map((s) => `${s.status}: ${s.count}`).join(", ") || "none";
+  return `You are the OpenACP Assistant. Help users manage their AI coding sessions and topics.
 
-Available agents: ${agentNames}
-Default agent: ${config.defaultAgent}
-Workspace base: ${config.workspace.baseDir}
+## Current State
+- Active sessions: ${activeSessionCount} / ${totalSessionCount} total
+- Topics by status: ${topicBreakdown}
+- Available agents: ${agentNames}
+- Default agent: ${config.defaultAgent}
+- Workspace base: ${config.workspace.baseDir}
 
-When a user wants to create a session, guide them through:
-1. Which agent to use
-2. Which workspace/project
-3. Confirm and create
-
-Commands reference:
+## Session Management Commands
+These are Telegram bot commands (type directly in chat):
 - /new [agent] [workspace] \u2014 Create new session
 - /newchat \u2014 New chat with same agent & workspace
 - /cancel \u2014 Cancel current session
@@ -2715,7 +3626,48 @@ Commands reference:
 - /agents \u2014 List agents
 - /help \u2014 Show help
 
-Be concise and helpful. When the user confirms session creation, tell them you'll create it now.`;
+## Management Commands (via CLI)
+You have access to bash. Use these commands to manage OpenACP:
+
+### Session management
+\`\`\`bash
+openacp api status                       # List active sessions
+openacp api session <id>                 # Session detail
+openacp api send <id> "prompt text"      # Send prompt to session
+openacp api cancel <id>                  # Cancel session
+openacp api dangerous <id> on|off        # Toggle dangerous mode
+\`\`\`
+
+### Topic management
+\`\`\`bash
+openacp api topics                       # List topics
+openacp api topics --status finished,error
+openacp api delete-topic <id>            # Delete topic
+openacp api delete-topic <id> --force    # Force delete active
+openacp api cleanup                      # Cleanup finished topics
+openacp api cleanup --status finished,error
+\`\`\`
+
+### System
+\`\`\`bash
+openacp api health                       # System health
+openacp api config                       # Show config
+openacp api config set <key> <value>     # Update config
+openacp api adapters                     # List adapters
+openacp api tunnel                       # Tunnel status
+openacp api notify "message"             # Send notification
+openacp api version                      # Daemon version
+openacp api restart                      # Restart daemon
+\`\`\`
+
+## Guidelines
+- When a user asks about sessions or topics, run \`openacp api topics\` or \`openacp api status\` to get current data.
+- When deleting: if the session is active/initializing, warn the user first. Only use --force if they confirm.
+- Use \`openacp api health\` to check system status.
+- Use \`openacp api config\` to check configuration, \`openacp api config set\` to update values.
+- Format responses nicely for Telegram (use bold, code blocks).
+- Be concise and helpful. Respond in the same language the user uses.
+- When creating sessions, guide through: agent selection \u2192 workspace \u2192 confirm.`;
 }
 async function handleAssistantMessage(session, text) {
   if (!session) return;
@@ -2728,7 +3680,7 @@ function redirectToAssistant(chatId, assistantTopicId) {
 }
 
 // src/adapters/telegram/activity.ts
-var log10 = createChildLogger({ module: "telegram:activity" });
+var log11 = createChildLogger({ module: "telegram:activity" });
 var THINKING_REFRESH_MS = 15e3;
 var THINKING_MAX_MS = 3 * 60 * 1e3;
 var ThinkingIndicator = class {
@@ -2760,7 +3712,7 @@ var ThinkingIndicator = class {
         this.startRefreshTimer();
       }
     } catch (err) {
-      log10.warn({ err }, "ThinkingIndicator.show() failed");
+      log11.warn({ err }, "ThinkingIndicator.show() failed");
     } finally {
       this.sending = false;
     }
@@ -2833,7 +3785,7 @@ var UsageMessage = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log10.warn({ err }, "UsageMessage.send() failed");
+      log11.warn({ err }, "UsageMessage.send() failed");
     }
   }
   getMsgId() {
@@ -2846,7 +3798,7 @@ var UsageMessage = class {
     try {
       await this.sendQueue.enqueue(() => this.api.deleteMessage(this.chatId, id));
     } catch (err) {
-      log10.warn({ err }, "UsageMessage.delete() failed");
+      log11.warn({ err }, "UsageMessage.delete() failed");
     }
   }
 };
@@ -2881,6 +3833,7 @@ var PlanCard = class {
   msgId;
   flushPromise = Promise.resolve();
   latestEntries;
+  lastSentText;
   flushTimer;
   update(entries) {
     this.latestEntries = entries;
@@ -2911,6 +3864,8 @@ var PlanCard = class {
   async _flush() {
     if (!this.latestEntries) return;
     const text = formatPlanCard(this.latestEntries);
+    if (this.msgId && text === this.lastSentText) return;
+    this.lastSentText = text;
     try {
       if (this.msgId) {
         await this.sendQueue.enqueue(
@@ -2929,7 +3884,7 @@ var PlanCard = class {
         if (result) this.msgId = result.message_id;
       }
     } catch (err) {
-      log10.warn({ err }, "PlanCard flush failed");
+      log11.warn({ err }, "PlanCard flush failed");
     }
   }
 };
@@ -2992,7 +3947,7 @@ var ActivityTracker = class {
           })
         );
       } catch (err) {
-        log10.warn({ err }, "ActivityTracker.onComplete() Done send failed");
+        log11.warn({ err }, "ActivityTracker.onComplete() Done send failed");
       }
     }
   }
@@ -3019,19 +3974,19 @@ var TelegramSendQueue = class {
   enqueue(fn, opts) {
     const type = opts?.type ?? "other";
     const key = opts?.key;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (type === "text" && key) {
         const idx = this.items.findIndex(
           (item) => item.type === "text" && item.key === key
         );
         if (idx !== -1) {
           this.items[idx].resolve(void 0);
-          this.items[idx] = { fn, type, key, resolve, reject };
+          this.items[idx] = { fn, type, key, resolve: resolve2, reject };
           this.scheduleProcess();
           return;
         }
       }
-      this.items.push({ fn, type, key, resolve, reject });
+      this.items.push({ fn, type, key, resolve: resolve2, reject });
       this.scheduleProcess();
     });
   }
@@ -3219,7 +4174,7 @@ function setupActionCallbacks(bot, core, chatId, getAssistantSessionId) {
 }
 
 // src/adapters/telegram/adapter.ts
-var log11 = createChildLogger({ module: "telegram" });
+var log12 = createChildLogger({ module: "telegram" });
 function patchedFetch(input, init) {
   if (init?.signal && !(init.signal instanceof AbortSignal)) {
     const nativeController = new AbortController();
@@ -3270,7 +4225,7 @@ var TelegramAdapter = class extends ChannelAdapter {
     this.bot = new Bot(this.telegramConfig.botToken, { client: { fetch: patchedFetch } });
     this.bot.catch((err) => {
       const rootCause = err.error instanceof Error ? err.error : err;
-      log11.error({ err: rootCause }, "Telegram bot error");
+      log12.error({ err: rootCause }, "Telegram bot error");
     });
     this.bot.api.config.use(async (prev, method, payload, signal) => {
       const maxRetries = 3;
@@ -3284,7 +4239,7 @@ var TelegramAdapter = class extends ChannelAdapter {
         if (rateLimitedMethods.includes(method)) {
           this.sendQueue.onRateLimited();
         }
-        log11.warn(
+        log12.warn(
           { method, retryAfter, attempt: attempt + 1 },
           "Rate limited by Telegram, retrying"
         );
@@ -3335,10 +4290,12 @@ var TelegramAdapter = class extends ChannelAdapter {
       this.telegramConfig.chatId,
       () => this.assistantSession?.id
     );
+    setupIntegrateCallbacks(this.bot, this.core);
     setupMenuCallbacks(
       this.bot,
       this.core,
-      this.telegramConfig.chatId
+      this.telegramConfig.chatId,
+      { notificationTopicId: this.notificationTopicId, assistantTopicId: this.assistantTopicId }
     );
     setupCommands(
       this.bot,
@@ -3350,10 +4307,48 @@ var TelegramAdapter = class extends ChannelAdapter {
       }
     );
     this.permissionHandler.setupCallbackHandler();
+    this.bot.command("handoff", async (ctx) => {
+      const threadId = ctx.message?.message_thread_id;
+      if (!threadId) return;
+      if (threadId === this.notificationTopicId || threadId === this.assistantTopicId) {
+        await ctx.reply("This command only works in session topics.", {
+          message_thread_id: threadId
+        });
+        return;
+      }
+      const session = this.core.sessionManager.getSessionByThread("telegram", String(threadId));
+      const record = session ? void 0 : this.core.sessionManager.getRecordByThread("telegram", String(threadId));
+      const agentName = session?.agentName ?? record?.agentName;
+      const agentSessionId = session?.agentSessionId ?? record?.agentSessionId;
+      if (!agentName || !agentSessionId) {
+        await ctx.reply("No session found for this topic.", {
+          message_thread_id: threadId
+        });
+        return;
+      }
+      const { getAgentCapabilities: getAgentCapabilities2 } = await import("./agent-registry-7HC6D4CH.js");
+      const caps = getAgentCapabilities2(agentName);
+      if (!caps.supportsResume || !caps.resumeCommand) {
+        await ctx.reply("This agent does not support session transfer.", {
+          message_thread_id: threadId
+        });
+        return;
+      }
+      const command = caps.resumeCommand(agentSessionId);
+      await ctx.reply(
+        `Run this in your terminal to continue the session:
+
+<code>${command}</code>`,
+        {
+          message_thread_id: threadId,
+          parse_mode: "HTML"
+        }
+      );
+    });
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log11.info(
+      onStart: () => log12.info(
         { chatId: this.telegramConfig.chatId },
         "Telegram bot started"
       )
@@ -3363,10 +4358,13 @@ var TelegramAdapter = class extends ChannelAdapter {
       const agents = this.core.agentManager.getAvailableAgents();
       const agentList = agents.map((a) => `${escapeHtml(a.name)}${a.name === config.defaultAgent ? " (default)" : ""}`).join(", ");
       const workspace = escapeHtml(config.workspace.baseDir);
+      const allRecords = this.core.sessionManager.listRecords();
+      const activeCount = allRecords.filter((r) => r.status === "active" || r.status === "initializing").length;
       const welcomeText = `\u{1F44B} <b>OpenACP Assistant</b> is online.
 
 Available agents: ${agentList}
 Workspace: <code>${workspace}</code>
+Sessions: ${activeCount} active / ${allRecords.length} total
 
 <b>Select an action:</b>`;
       await this.bot.api.sendMessage(this.telegramConfig.chatId, welcomeText, {
@@ -3375,10 +4373,10 @@ Workspace: <code>${workspace}</code>
         reply_markup: buildMenuKeyboard()
       });
     } catch (err) {
-      log11.warn({ err }, "Failed to send welcome message");
+      log12.warn({ err }, "Failed to send welcome message");
     }
     try {
-      log11.info("Spawning assistant session...");
+      log12.info("Spawning assistant session...");
       const { session, ready } = await spawnAssistant(
         this.core,
         this,
@@ -3386,13 +4384,13 @@ Workspace: <code>${workspace}</code>
       );
       this.assistantSession = session;
       this.assistantInitializing = true;
-      log11.info({ sessionId: session.id }, "Assistant session ready, system prompt running in background");
+      log12.info({ sessionId: session.id }, "Assistant session ready, system prompt running in background");
       ready.then(() => {
         this.assistantInitializing = false;
-        log11.info({ sessionId: session.id }, "Assistant ready for user messages");
+        log12.info({ sessionId: session.id }, "Assistant ready for user messages");
       });
     } catch (err) {
-      log11.error({ err }, "Failed to spawn assistant");
+      log12.error({ err }, "Failed to spawn assistant");
       this.bot.api.sendMessage(
         this.telegramConfig.chatId,
         `\u26A0\uFE0F <b>Failed to start assistant session.</b>
@@ -3408,7 +4406,7 @@ Workspace: <code>${workspace}</code>
       await this.assistantSession.destroy();
     }
     await this.bot.stop();
-    log11.info("Telegram bot stopped");
+    log12.info("Telegram bot stopped");
   }
   setupRoutes() {
     this.bot.on("message:text", async (ctx) => {
@@ -3431,7 +4429,7 @@ Workspace: <code>${workspace}</code>
         ctx.replyWithChatAction("typing").catch(() => {
         });
         handleAssistantMessage(this.assistantSession, ctx.message.text).catch(
-          (err) => log11.error({ err }, "Assistant error")
+          (err) => log12.error({ err }, "Assistant error")
         );
         return;
       }
@@ -3448,7 +4446,7 @@ Workspace: <code>${workspace}</code>
         threadId: String(threadId),
         userId: String(ctx.from.id),
         text: ctx.message.text
-      }).catch((err) => log11.error({ err }, "handleMessage error"));
+      }).catch((err) => log12.error({ err }, "handleMessage error"));
     });
   }
   // --- ChannelAdapter implementations ---
@@ -3528,7 +4526,7 @@ Workspace: <code>${workspace}</code>
         if (toolState) {
           if (meta.viewerLinks) {
             toolState.viewerLinks = meta.viewerLinks;
-            log11.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated viewerLinks");
+            log12.debug({ toolId: meta.id, viewerLinks: meta.viewerLinks }, "Accumulated viewerLinks");
           }
           const viewerFilePath = content.metadata?.viewerFilePath;
           if (viewerFilePath) toolState.viewerFilePath = viewerFilePath;
@@ -3537,7 +4535,7 @@ Workspace: <code>${workspace}</code>
           const isTerminal = meta.status === "completed" || meta.status === "failed";
           if (!isTerminal && !meta.viewerLinks) break;
           await toolState.ready;
-          log11.debug(
+          log12.debug(
             { toolId: meta.id, status: meta.status, hasViewerLinks: !!toolState.viewerLinks, viewerLinks: toolState.viewerLinks, name: toolState.name, msgId: toolState.msgId },
             "Tool completed, preparing edit"
           );
@@ -3559,7 +4557,7 @@ Workspace: <code>${workspace}</code>
               )
             );
           } catch (err) {
-            log11.warn(
+            log12.warn(
               { err, msgId: toolState.msgId, textLen: formattedText.length, hasViewerLinks: !!merged.viewerLinks },
               "Tool update edit failed"
             );
@@ -3654,15 +4652,23 @@ Task completed.
     }
   }
   async sendPermissionRequest(sessionId, request) {
-    log11.info({ sessionId, requestId: request.id }, "Permission request sent");
+    log12.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");
+        session.permissionGate.resolve(allowOption.id);
+      }
+      return;
+    }
     if (session.dangerousMode) {
       const allowOption = request.options.find((o) => o.isAllow);
       if (allowOption && session.permissionGate.requestId === request.id) {
-        log11.info({ sessionId, requestId: request.id, optionId: allowOption.id }, "Dangerous mode: auto-approving permission");
+        log12.info({ sessionId, requestId: request.id, optionId: allowOption.id }, "Dangerous mode: auto-approving permission");
         session.permissionGate.resolve(allowOption.id);
       }
       return;
@@ -3673,7 +4679,7 @@ Task completed.
   }
   async sendNotification(notification) {
     if (notification.sessionId === this.assistantSession?.id) return;
-    log11.info(
+    log12.info(
       { sessionId: notification.sessionId, type: notification.type },
       "Notification sent"
     );
@@ -3709,7 +4715,7 @@ Task completed.
     );
   }
   async createSessionThread(sessionId, name) {
-    log11.info({ sessionId, name }, "Session topic created");
+    log12.info({ sessionId, name }, "Session topic created");
     return String(
       await createSessionTopic(this.bot, this.telegramConfig.chatId, name)
     );
@@ -3730,6 +4736,17 @@ Task completed.
       newName
     );
   }
+  async deleteSessionThread(sessionId) {
+    const record = this.core.sessionManager.getSessionRecord(sessionId);
+    const platform = record?.platform;
+    const topicId = platform?.topicId;
+    if (!topicId) return;
+    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)");
+    }
+  }
   async sendSkillCommands(sessionId, commands) {
     if (sessionId === this.assistantSession?.id) return;
     const session = this.core.sessionManager.getSession(sessionId);
@@ -3800,7 +4817,7 @@ Task completed.
         { disable_notification: true }
       );
     } catch (err) {
-      log11.error({ err, sessionId }, "Failed to send skill commands");
+      log12.error({ err, sessionId }, "Failed to send skill commands");
     }
   }
   async cleanupSkillCommands(sessionId) {
@@ -3868,6 +4885,7 @@ export {
   OpenACPCore,
   ChannelAdapter,
   ApiServer,
+  TopicManager,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-V5P3K4A5.js.map
+//# sourceMappingURL=chunk-BBPWAWE3.js.map