@openacp/cli 0.2.11 → 0.2.12

package/dist/{chunk-I6KXISAR.js → chunk-TZGP3JSE.js}

@@ -1,6 +1,7 @@
 import {
-  log
-} from "./chunk-KADEDKIM.js";
+  createChildLogger,
+  createSessionLogger
+} from "./chunk-5KBEVENA.js";
 
 // src/core/streams.ts
 function nodeToWebWritable(nodeStream) {
@@ -46,10 +47,12 @@ var StderrCapture = class {
 
 // src/core/agent-instance.ts
 import { spawn, execSync } from "child_process";
+import { Transform } from "stream";
 import fs from "fs";
 import path from "path";
 import { randomUUID } from "crypto";
 import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+var log = createChildLogger({ module: "agent-instance" });
 function resolveAgentCommand(cmd) {
   const packageDirs = [
     path.resolve(process.cwd(), "node_modules", "@zed-industries", cmd, "dist", "index.js"),
@@ -103,7 +106,8 @@ var AgentInstance = class _AgentInstance {
   static async spawn(agentDef, workingDirectory) {
     const instance = new _AgentInstance(agentDef.name);
     const resolved = resolveAgentCommand(agentDef.command);
-    log.debug(`Spawning agent "${agentDef.name}" \u2192 ${resolved.command} ${resolved.args.join(" ")}`);
+    log.debug({ agentName: agentDef.name, command: resolved.command, args: resolved.args }, "Spawning agent");
+    const spawnStart = Date.now();
     instance.child = spawn(resolved.command, [...resolved.args, ...agentDef.args], {
       stdio: ["pipe", "pipe", "pipe"],
       cwd: workingDirectory,
@@ -119,8 +123,22 @@ var AgentInstance = class _AgentInstance {
     instance.child.stderr.on("data", (chunk) => {
       instance.stderrCapture.append(chunk.toString());
     });
-    const toAgent = nodeToWebWritable(instance.child.stdin);
-    const fromAgent = nodeToWebReadable(instance.child.stdout);
+    const stdinLogger = new Transform({
+      transform(chunk, _enc, cb) {
+        log.debug({ direction: "send", raw: chunk.toString().trimEnd() }, "ACP raw");
+        cb(null, chunk);
+      }
+    });
+    stdinLogger.pipe(instance.child.stdin);
+    const stdoutLogger = new Transform({
+      transform(chunk, _enc, cb) {
+        log.debug({ direction: "recv", raw: chunk.toString().trimEnd() }, "ACP raw");
+        cb(null, chunk);
+      }
+    });
+    instance.child.stdout.pipe(stdoutLogger);
+    const toAgent = nodeToWebWritable(stdinLogger);
+    const fromAgent = nodeToWebReadable(stdoutLogger);
     const stream = ndJsonStream(toAgent, fromAgent);
     instance.connection = new ClientSideConnection(
       (_agent) => instance.createClient(_agent),
@@ -139,6 +157,7 @@ var AgentInstance = class _AgentInstance {
     });
     instance.sessionId = response.sessionId;
     instance.child.on("exit", (code, signal) => {
+      log.info({ sessionId: instance.sessionId, exitCode: code, signal }, "Agent process exited");
       if (code !== 0 && code !== null) {
         const stderr = instance.stderrCapture.getLastLines();
         instance.onSessionUpdate({
@@ -149,9 +168,9 @@ ${stderr}`
       }
     });
     instance.connection.closed.then(() => {
-      log.debug("ACP connection closed for", instance.agentName);
+      log.debug({ sessionId: instance.sessionId }, "ACP connection closed");
     });
-    log.info(`Agent "${agentDef.name}" spawned with session ${response.sessionId}`);
+    log.info({ sessionId: response.sessionId, durationMs: Date.now() - spawnStart }, "Agent spawn complete");
     return instance;
   }
   // createClient — implemented in Task 6b
@@ -366,6 +385,7 @@ var AgentManager = class {
 
 // src/core/session.ts
 import { nanoid } from "nanoid";
+var moduleLog = createChildLogger({ module: "session" });
 var Session = class {
   id;
   channelId;
@@ -381,17 +401,20 @@ var Session = class {
   adapter;
   // Set by wireSessionEvents for renaming
   pendingPermission;
+  log;
   constructor(opts) {
     this.id = opts.id || nanoid(12);
     this.channelId = opts.channelId;
     this.agentName = opts.agentName;
     this.workingDirectory = opts.workingDirectory;
     this.agentInstance = opts.agentInstance;
+    this.log = createSessionLogger(this.id, moduleLog);
+    this.log.info({ agentName: this.agentName }, "Session created");
   }
   async enqueuePrompt(text) {
     if (this.promptRunning) {
       this.promptQueue.push(text);
-      log.debug(`Prompt queued for session ${this.id} (${this.promptQueue.length} in queue)`);
+      this.log.debug({ queueDepth: this.promptQueue.length }, "Prompt queued");
       return;
     }
     await this.runPrompt(text);
@@ -399,14 +422,17 @@ var Session = class {
   async runPrompt(text) {
     this.promptRunning = true;
     this.status = "active";
+    const promptStart = Date.now();
+    this.log.debug("Prompt execution started");
     try {
       await this.agentInstance.prompt(text);
+      this.log.info({ durationMs: Date.now() - promptStart }, "Prompt execution completed");
       if (!this.name) {
         await this.autoName();
       }
     } catch (err) {
       this.status = "error";
-      log.error(`Prompt failed for session ${this.id}:`, err);
+      this.log.error({ err }, "Prompt execution failed");
     } finally {
       this.promptRunning = false;
       if (this.promptQueue.length > 0) {
@@ -428,6 +454,7 @@ var Session = class {
         "Summarize this conversation in max 5 words for a topic title. Reply ONLY with the title, nothing else."
       );
       this.name = title.trim().slice(0, 50);
+      this.log.info({ name: this.name }, "Session auto-named");
       if (this.adapter && this.name) {
         await this.adapter.renameSessionThread(this.id, this.name);
       }
@@ -437,11 +464,34 @@ var Session = class {
       this.agentInstance.onSessionUpdate = prevHandler;
     }
   }
+  /** Fire-and-forget warm-up: primes model cache while user types their first message */
+  async warmup() {
+    this.promptRunning = true;
+    const prevHandler = this.agentInstance.onSessionUpdate;
+    this.agentInstance.onSessionUpdate = () => {
+    };
+    try {
+      const start = Date.now();
+      await this.agentInstance.prompt('Reply with only "ready".');
+      this.log.info({ durationMs: Date.now() - start }, "Warm-up complete");
+    } catch (err) {
+      this.log.error({ err }, "Warm-up failed");
+    } finally {
+      this.agentInstance.onSessionUpdate = prevHandler;
+      this.promptRunning = false;
+      if (this.promptQueue.length > 0) {
+        const next = this.promptQueue.shift();
+        await this.runPrompt(next);
+      }
+    }
+  }
   async cancel() {
     this.status = "cancelled";
+    this.log.info("Session cancelled");
     await this.agentInstance.cancel();
   }
   async destroy() {
+    this.log.info("Session destroyed");
     await this.agentInstance.destroy();
   }
 };
@@ -502,6 +552,7 @@ var NotificationManager = class {
 };
 
 // src/core/core.ts
+var log2 = createChildLogger({ module: "core" });
 var OpenACPCore = class {
   configManager;
   agentManager;
@@ -540,11 +591,16 @@ var OpenACPCore = class {
   // --- Message Routing ---
   async handleMessage(message) {
     const config = this.configManager.get();
+    log2.debug({ channelId: message.channelId, threadId: message.threadId, userId: message.userId }, "Incoming message");
     if (config.security.allowedUserIds.length > 0) {
-      if (!config.security.allowedUserIds.includes(message.userId)) return;
+      if (!config.security.allowedUserIds.includes(message.userId)) {
+        log2.warn({ userId: message.userId }, "Rejected message from unauthorized user");
+        return;
+      }
     }
     const activeSessions = this.sessionManager.listSessions().filter((s) => s.status === "active" || s.status === "initializing");
     if (activeSessions.length >= config.security.maxConcurrentSessions) {
+      log2.warn({ userId: message.userId, currentCount: activeSessions.length, max: config.security.maxConcurrentSessions }, "Session limit reached");
       const adapter = this.adapters.get(message.channelId);
       if (adapter) {
         await adapter.sendMessage("system", {
@@ -561,6 +617,7 @@ var OpenACPCore = class {
   async handleNewSession(channelId, agentName, workspacePath) {
     const config = this.configManager.get();
     const resolvedAgent = agentName || config.defaultAgent;
+    log2.info({ channelId, agentName: resolvedAgent }, "New session request");
     const resolvedWorkspace = this.configManager.resolveWorkspace(
       workspacePath || config.agents[resolvedAgent]?.workingDirectory
     );
@@ -600,10 +657,6 @@ var OpenACPCore = class {
         return { type: "plan", text: "", metadata: { entries: event.entries } };
       case "usage":
         return { type: "usage", text: "", metadata: { tokensUsed: event.tokensUsed, contextSize: event.contextSize, cost: event.cost } };
-      case "commands_update":
-        log.debug("Commands update:", event.commands);
-        return { type: "text", text: "" };
-      // no-op for now
       default:
         return { type: "text", text: "" };
     }
@@ -623,6 +676,7 @@ var OpenACPCore = class {
           break;
         case "session_end":
           session.status = "finished";
+          adapter.cleanupSkillCommands(session.id);
           adapter.sendMessage(session.id, { type: "session_end", text: `Done (${event.reason})` });
           this.notificationManager.notify(session.channelId, {
             sessionId: session.id,
@@ -632,6 +686,7 @@ var OpenACPCore = class {
           });
           break;
         case "error":
+          adapter.cleanupSkillCommands(session.id);
           adapter.sendMessage(session.id, { type: "error", text: event.message });
           this.notificationManager.notify(session.channelId, {
             sessionId: session.id,
@@ -641,7 +696,8 @@ var OpenACPCore = class {
           });
           break;
         case "commands_update":
-          log.debug("Commands available:", event.commands);
+          log2.debug({ commands: event.commands }, "Commands available");
+          adapter.sendSkillCommands(session.id, event.commands);
           break;
       }
     };
@@ -661,6 +717,11 @@ var ChannelAdapter = class {
     this.core = core;
     this.config = config;
   }
+  // Skill commands — override in adapters that support dynamic commands
+  async sendSkillCommands(_sessionId, _commands) {
+  }
+  async cleanupSkillCommands(_sessionId) {
+  }
 };
 
 // src/adapters/telegram/adapter.ts
@@ -937,6 +998,8 @@ function buildDeepLink(chatId, messageId) {
 
 // src/adapters/telegram/commands.ts
 import { InlineKeyboard } from "grammy";
+import { nanoid as nanoid2 } from "nanoid";
+var log4 = createChildLogger({ module: "telegram-commands" });
 function setupCommands(bot, core, chatId) {
   bot.command("new", (ctx) => handleNew(ctx, core, chatId));
   bot.command("new_chat", (ctx) => handleNewChat(ctx, core, chatId));
@@ -949,6 +1012,35 @@ function setupCommands(bot, core, chatId) {
 function buildMenuKeyboard() {
   return new InlineKeyboard().text("\u{1F195} New Session", "m:new").text("\u{1F4AC} New Chat", "m:new_chat").row().text("\u26D4 Cancel", "m:cancel").text("\u{1F4CA} Status", "m:status").row().text("\u{1F916} Agents", "m:agents").text("\u2753 Help", "m:help");
 }
+function setupMenuCallbacks(bot, core, chatId) {
+  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:new_chat":
+        await handleNewChat(ctx, core, chatId);
+        break;
+      case "m:cancel":
+        await handleCancel(ctx, core);
+        break;
+      case "m:status":
+        await handleStatus(ctx, core);
+        break;
+      case "m:agents":
+        await handleAgents(ctx, core);
+        break;
+      case "m:help":
+        await handleHelp(ctx);
+        break;
+    }
+  });
+}
 async function handleMenu(ctx) {
   await ctx.reply(`<b>OpenACP Menu</b>
 Choose an action:`, {
@@ -962,10 +1054,15 @@ async function handleNew(ctx, core, chatId) {
   const args = matchStr.split(" ").filter(Boolean);
   const agentName = args[0];
   const workspace = args[1];
+  log4.info({ userId: ctx.from?.id, agentName }, "New session command");
   let threadId;
   try {
     const topicName = `\u{1F504} New Session`;
     threadId = await createSessionTopic(botFromCtx(ctx), chatId, topicName);
+    await ctx.api.sendMessage(chatId, `\u23F3 Setting up session, please wait...`, {
+      message_thread_id: threadId,
+      parse_mode: "HTML"
+    });
     const session = await core.handleNewSession(
       "telegram",
       agentName,
@@ -987,6 +1084,7 @@ async function handleNew(ctx, core, chatId) {
         parse_mode: "HTML"
       }
     );
+    session.warmup().catch((err) => log4.error({ err }, "Warm-up error"));
   } catch (err) {
     if (threadId) {
       try {
@@ -1021,6 +1119,10 @@ async function handleNewChat(ctx, core, chatId) {
       chatId,
       topicName
     );
+    await ctx.api.sendMessage(chatId, `\u23F3 Setting up session, please wait...`, {
+      message_thread_id: newThreadId,
+      parse_mode: "HTML"
+    });
     session.threadId = String(newThreadId);
     await ctx.api.sendMessage(
       chatId,
@@ -1032,6 +1134,7 @@ async function handleNewChat(ctx, core, chatId) {
         parse_mode: "HTML"
       }
     );
+    session.warmup().catch((err) => log4.error({ err }, "Warm-up error"));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     await ctx.reply(`\u274C ${escapeHtml(message)}`, { parse_mode: "HTML" });
@@ -1045,6 +1148,7 @@ async function handleCancel(ctx, core) {
     String(threadId)
   );
   if (session) {
+    log4.info({ sessionId: session.id }, "Cancel session command");
     await session.cancel();
     await ctx.reply("\u26D4 Session cancelled.", { parse_mode: "HTML" });
   }
@@ -1116,10 +1220,56 @@ Or just chat in the \u{1F916} Assistant topic for help!`,
 function botFromCtx(ctx) {
   return { api: ctx.api };
 }
+var skillCallbackMap = /* @__PURE__ */ new Map();
+function buildSkillKeyboard(sessionId, commands) {
+  const keyboard = new InlineKeyboard();
+  const sorted = [...commands].sort((a, b) => a.name.localeCompare(b.name));
+  for (let i = 0; i < sorted.length; i++) {
+    const cmd = sorted[i];
+    const key = nanoid2(8);
+    skillCallbackMap.set(key, { sessionId, commandName: cmd.name });
+    keyboard.text(`/${cmd.name}`, `s:${key}`);
+    if (i % 2 === 1 && i < sorted.length - 1) {
+      keyboard.row();
+    }
+  }
+  return keyboard;
+}
+function clearSkillCallbacks(sessionId) {
+  for (const [key, entry] of skillCallbackMap) {
+    if (entry.sessionId === sessionId) {
+      skillCallbackMap.delete(key);
+    }
+  }
+}
+function setupSkillCallbacks(bot, core) {
+  bot.callbackQuery(/^s:/, async (ctx) => {
+    try {
+      await ctx.answerCallbackQuery();
+    } catch {
+    }
+    const key = ctx.callbackQuery.data.slice(2);
+    const entry = skillCallbackMap.get(key);
+    if (!entry) return;
+    const session = core.sessionManager.getSession(entry.sessionId);
+    if (!session || session.status !== "active") return;
+    await session.enqueuePrompt(`/${entry.commandName}`);
+  });
+}
+var STATIC_COMMANDS = [
+  { command: "new", description: "Create new session" },
+  { command: "new_chat", description: "New chat, same agent & workspace" },
+  { command: "cancel", description: "Cancel current session" },
+  { command: "status", description: "Show status" },
+  { command: "agents", description: "List available agents" },
+  { command: "help", description: "Help" },
+  { command: "menu", description: "Show menu" }
+];
 
 // src/adapters/telegram/permissions.ts
 import { InlineKeyboard as InlineKeyboard2 } from "grammy";
-import { nanoid as nanoid2 } from "nanoid";
+import { nanoid as nanoid3 } from "nanoid";
+var log5 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
   constructor(bot, chatId, getSession, sendNotification) {
     this.bot = bot;
@@ -1130,8 +1280,12 @@ var PermissionHandler = class {
   pending = /* @__PURE__ */ new Map();
   async sendPermissionRequest(session, request) {
     const threadId = Number(session.threadId);
-    const callbackKey = nanoid2(8);
-    this.pending.set(callbackKey, { sessionId: session.id, requestId: request.id });
+    const callbackKey = nanoid3(8);
+    this.pending.set(callbackKey, {
+      sessionId: session.id,
+      requestId: request.id,
+      options: request.options.map((o) => ({ id: o.id, isAllow: o.isAllow }))
+    });
     const keyboard = new InlineKeyboard2();
     for (const option of request.options) {
       const emoji = option.isAllow ? "\u2705" : "\u274C";
@@ -1174,6 +1328,8 @@ ${escapeHtml(request.description)}`,
         return;
       }
       const session = this.getSession(pending.sessionId);
+      const isAllow = pending.options.find((o) => o.id === optionId)?.isAllow ?? false;
+      log5.info({ requestId: pending.requestId, optionId, isAllow }, "Permission responded");
       if (session?.pendingPermission?.requestId === pending.requestId) {
         session.pendingPermission.resolve(optionId);
         session.pendingPermission = void 0;
@@ -1240,6 +1396,7 @@ function redirectToAssistant(chatId, assistantTopicId) {
 }
 
 // src/adapters/telegram/adapter.ts
+var log6 = createChildLogger({ module: "telegram" });
 var TelegramAdapter = class extends ChannelAdapter {
   bot;
   telegramConfig;
@@ -1250,6 +1407,8 @@ var TelegramAdapter = class extends ChannelAdapter {
   assistantSession = null;
   notificationTopicId;
   assistantTopicId;
+  skillMessages = /* @__PURE__ */ new Map();
+  // sessionId → pinned messageId
   constructor(core, config) {
     super(core, config);
     this.telegramConfig = config;
@@ -1257,14 +1416,20 @@ var TelegramAdapter = class extends ChannelAdapter {
   async start() {
     this.bot = new Bot(this.telegramConfig.botToken);
     this.bot.catch((err) => {
-      log.error("Bot error:", err.message || err);
+      log6.error({ err }, "Telegram bot error");
     });
     this.bot.api.config.use((prev, method, payload, signal) => {
       if (method === "getUpdates") {
-        payload.allowed_updates = payload.allowed_updates ?? ["message", "callback_query"];
+        payload.allowed_updates = payload.allowed_updates ?? [
+          "message",
+          "callback_query"
+        ];
       }
       return prev(method, payload, signal);
     });
+    await this.bot.api.setMyCommands(STATIC_COMMANDS, {
+      scope: { type: "chat", chat_id: this.telegramConfig.chatId }
+    });
     this.bot.use((ctx, next) => {
       const chatId = ctx.chat?.id ?? ctx.callbackQuery?.message?.chat?.id;
       if (chatId !== this.telegramConfig.chatId) return;
@@ -1288,12 +1453,25 @@ var TelegramAdapter = class extends ChannelAdapter {
       (sessionId) => this.core.sessionManager.getSession(sessionId),
       (notification) => this.sendNotification(notification)
     );
+    setupSkillCallbacks(this.bot, this.core);
+    setupMenuCallbacks(
+      this.bot,
+      this.core,
+      this.telegramConfig.chatId
+    );
+    setupCommands(
+      this.bot,
+      this.core,
+      this.telegramConfig.chatId
+    );
     this.permissionHandler.setupCallbackHandler();
-    setupCommands(this.bot, this.core, this.telegramConfig.chatId);
     this.setupRoutes();
     this.bot.start({
       allowed_updates: ["message", "callback_query"],
-      onStart: () => log.info("Telegram bot started")
+      onStart: () => log6.info(
+        { chatId: this.telegramConfig.chatId },
+        "Telegram bot started"
+      )
     });
     try {
       this.assistantSession = await spawnAssistant(
@@ -1302,7 +1480,28 @@ var TelegramAdapter = class extends ChannelAdapter {
         this.assistantTopicId
       );
     } catch (err) {
-      log.error("Failed to spawn assistant:", err);
+      log6.error({ err }, "Failed to spawn assistant");
+    }
+    try {
+      const config = this.core.configManager.get();
+      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 welcomeText = `\u{1F44B} <b>OpenACP Assistant</b> is online.
+
+Available agents: ${agentList}
+Workspace: <code>${workspace}</code>
+
+<b>Select an action:</b>`;
+      await this.bot.api.sendMessage(this.telegramConfig.chatId, welcomeText, {
+        message_thread_id: this.assistantTopicId,
+        parse_mode: "HTML",
+        reply_markup: buildMenuKeyboard()
+      });
+    } catch (err) {
+      log6.warn({ err }, "Failed to send welcome message");
     }
   }
   async stop() {
@@ -1310,32 +1509,43 @@ var TelegramAdapter = class extends ChannelAdapter {
       await this.assistantSession.destroy();
     }
     await this.bot.stop();
+    log6.info("Telegram bot stopped");
   }
   setupRoutes() {
     this.bot.on("message:text", async (ctx) => {
       const threadId = ctx.message.message_thread_id;
       if (!threadId) {
-        const html = redirectToAssistant(this.telegramConfig.chatId, this.assistantTopicId);
+        const html = redirectToAssistant(
+          this.telegramConfig.chatId,
+          this.assistantTopicId
+        );
         await ctx.reply(html, { parse_mode: "HTML" });
         return;
       }
       if (threadId === this.notificationTopicId) return;
       if (threadId === this.assistantTopicId) {
-        handleAssistantMessage(this.assistantSession, ctx.message.text).catch((err) => log.error("Assistant error:", err));
+        ctx.replyWithChatAction("typing").catch(() => {
+        });
+        handleAssistantMessage(this.assistantSession, ctx.message.text).catch(
+          (err) => log6.error({ err }, "Assistant error")
+        );
         return;
       }
-      ;
+      ctx.replyWithChatAction("typing").catch(() => {
+      });
       this.core.handleMessage({
         channelId: "telegram",
         threadId: String(threadId),
         userId: String(ctx.from.id),
         text: ctx.message.text
-      }).catch((err) => log.error("handleMessage error:", err));
+      }).catch((err) => log6.error({ err }, "handleMessage error"));
     });
   }
   // --- ChannelAdapter implementations ---
   async sendMessage(sessionId, content) {
-    const session = this.core.sessionManager.getSession(sessionId);
+    const session = this.core.sessionManager.getSession(
+      sessionId
+    );
     if (!session) return;
     const threadId = Number(session.threadId);
     switch (content.type) {
@@ -1345,7 +1555,11 @@ var TelegramAdapter = class extends ChannelAdapter {
       case "text": {
         let draft = this.sessionDrafts.get(sessionId);
         if (!draft) {
-          draft = new MessageDraft(this.bot, this.telegramConfig.chatId, threadId);
+          draft = new MessageDraft(
+            this.bot,
+            this.telegramConfig.chatId,
+            threadId
+          );
           this.sessionDrafts.set(sessionId, draft);
         }
         draft.append(content.text);
@@ -1357,19 +1571,31 @@ var TelegramAdapter = class extends ChannelAdapter {
         const msg = await this.bot.api.sendMessage(
           this.telegramConfig.chatId,
           formatToolCall(meta),
-          { message_thread_id: threadId, parse_mode: "HTML", disable_notification: true }
+          {
+            message_thread_id: threadId,
+            parse_mode: "HTML",
+            disable_notification: true
+          }
         );
         if (!this.toolCallMessages.has(sessionId)) {
           this.toolCallMessages.set(sessionId, /* @__PURE__ */ new Map());
         }
-        this.toolCallMessages.get(sessionId).set(meta.id, { msgId: msg.message_id, name: meta.name, kind: meta.kind });
+        this.toolCallMessages.get(sessionId).set(meta.id, {
+          msgId: msg.message_id,
+          name: meta.name,
+          kind: meta.kind
+        });
         break;
       }
       case "tool_update": {
         const meta = content.metadata;
         const toolState = this.toolCallMessages.get(sessionId)?.get(meta.id);
         if (toolState) {
-          const merged = { ...meta, name: meta.name || toolState.name, kind: meta.kind || toolState.kind };
+          const merged = {
+            ...meta,
+            name: meta.name || toolState.name,
+            kind: meta.kind || toolState.kind
+          };
           try {
             await this.bot.api.editMessageText(
               this.telegramConfig.chatId,
@@ -1387,7 +1613,11 @@ var TelegramAdapter = class extends ChannelAdapter {
         await this.bot.api.sendMessage(
           this.telegramConfig.chatId,
           formatPlan(content.metadata),
-          { message_thread_id: threadId, parse_mode: "HTML", disable_notification: true }
+          {
+            message_thread_id: threadId,
+            parse_mode: "HTML",
+            disable_notification: true
+          }
         );
         break;
       }
@@ -1395,7 +1625,11 @@ var TelegramAdapter = class extends ChannelAdapter {
         await this.bot.api.sendMessage(
           this.telegramConfig.chatId,
           formatUsage(content.metadata),
-          { message_thread_id: threadId, parse_mode: "HTML", disable_notification: true }
+          {
+            message_thread_id: threadId,
+            parse_mode: "HTML",
+            disable_notification: true
+          }
         );
         break;
       }
@@ -1403,10 +1637,15 @@ var TelegramAdapter = class extends ChannelAdapter {
         await this.finalizeDraft(sessionId);
         this.sessionDrafts.delete(sessionId);
         this.toolCallMessages.delete(sessionId);
+        await this.cleanupSkillCommands(sessionId);
         await this.bot.api.sendMessage(
           this.telegramConfig.chatId,
           `\u2705 <b>Done</b>`,
-          { message_thread_id: threadId, parse_mode: "HTML", disable_notification: true }
+          {
+            message_thread_id: threadId,
+            parse_mode: "HTML",
+            disable_notification: true
+          }
         );
         break;
       }
@@ -1415,18 +1654,29 @@ var TelegramAdapter = class extends ChannelAdapter {
         await this.bot.api.sendMessage(
           this.telegramConfig.chatId,
           `\u274C <b>Error:</b> ${escapeHtml(content.text)}`,
-          { message_thread_id: threadId, parse_mode: "HTML", disable_notification: true }
+          {
+            message_thread_id: threadId,
+            parse_mode: "HTML",
+            disable_notification: true
+          }
         );
         break;
       }
     }
   }
   async sendPermissionRequest(sessionId, request) {
-    const session = this.core.sessionManager.getSession(sessionId);
+    log6.info({ sessionId, requestId: request.id }, "Permission request sent");
+    const session = this.core.sessionManager.getSession(
+      sessionId
+    );
     if (!session) return;
     await this.permissionHandler.sendPermissionRequest(session, request);
   }
   async sendNotification(notification) {
+    log6.info(
+      { sessionId: notification.sessionId, type: notification.type },
+      "Notification sent"
+    );
     if (!this.notificationTopicId) return;
     const emoji = {
       completed: "\u2705",
@@ -1449,12 +1699,99 @@ var TelegramAdapter = class extends ChannelAdapter {
     });
   }
   async createSessionThread(sessionId, name) {
-    return String(await createSessionTopic(this.bot, this.telegramConfig.chatId, name));
+    log6.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
+    );
+    if (!session) return;
+    await renameSessionTopic(
+      this.bot,
+      this.telegramConfig.chatId,
+      Number(session.threadId),
+      newName
+    );
+  }
+  async sendSkillCommands(sessionId, commands) {
     const session = this.core.sessionManager.getSession(sessionId);
     if (!session) return;
-    await renameSessionTopic(this.bot, this.telegramConfig.chatId, Number(session.threadId), newName);
+    const threadId = Number(session.threadId);
+    if (!threadId) return;
+    if (commands.length === 0) {
+      await this.cleanupSkillCommands(sessionId);
+      return;
+    }
+    clearSkillCallbacks(sessionId);
+    const keyboard = buildSkillKeyboard(sessionId, commands);
+    const text = "\u{1F6E0} <b>Available commands:</b>";
+    const existingMsgId = this.skillMessages.get(sessionId);
+    if (existingMsgId) {
+      try {
+        await this.bot.api.editMessageText(
+          this.telegramConfig.chatId,
+          existingMsgId,
+          text,
+          { parse_mode: "HTML", reply_markup: keyboard }
+        );
+        return;
+      } catch {
+      }
+    }
+    try {
+      const msg = await this.bot.api.sendMessage(
+        this.telegramConfig.chatId,
+        text,
+        {
+          message_thread_id: threadId,
+          parse_mode: "HTML",
+          reply_markup: keyboard,
+          disable_notification: true
+        }
+      );
+      this.skillMessages.set(sessionId, msg.message_id);
+      await this.bot.api.pinChatMessage(this.telegramConfig.chatId, msg.message_id, {
+        disable_notification: true
+      });
+    } catch (err) {
+      log6.error({ err, sessionId }, "Failed to send skill commands");
+    }
+    await this.updateCommandAutocomplete(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);
+    clearSkillCallbacks(sessionId);
+    await this.updateCommandAutocomplete([]);
+  }
+  async updateCommandAutocomplete(skillCommands) {
+    const validSkills = skillCommands.map((c) => ({
+      command: c.name.toLowerCase().replace(/[^a-z0-9_]/g, "_").slice(0, 32),
+      description: (c.description || c.name).replace(/\n/g, " ").slice(0, 256)
+    })).filter((c) => c.command.length > 0);
+    const all = [...STATIC_COMMANDS, ...validSkills];
+    try {
+      await this.bot.api.setMyCommands(all, {
+        scope: { type: "chat", chat_id: this.telegramConfig.chatId }
+      });
+      log6.info({ count: all.length, skills: validSkills.length }, "Updated command autocomplete");
+    } catch (err) {
+      log6.error({ err, commands: all }, "Failed to update command autocomplete");
+    }
   }
   async finalizeDraft(sessionId) {
     const draft = this.sessionDrafts.get(sessionId);
@@ -1478,4 +1815,4 @@ export {
   ChannelAdapter,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-I6KXISAR.js.map
+//# sourceMappingURL=chunk-TZGP3JSE.js.map