agentp 0.8.0 → 0.10.0

package/bin/tgagentp

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+const http = require('http');
 const https = require('https');
 const fs = require('fs');
 const path = require('path');
@@ -15,8 +16,65 @@ const log = {
 };
 
 const STARTUP_CHAT_FILE = '/tmp/tgagentp-startup-chat';
+const TGAGENTP_PORT = parseInt(process.env.TGAGENTP_PORT || '0', 10);
+const PORT_FILE = '/tmp/tgagentp-port';
+const TGAGENTP_DEBOUNCE_MS = parseInt(process.env.TGAGENTP_DEBOUNCE_MS || '5000', 10);
 const { listServers, activateServer } = require('../lib/ocmux.js');
 
+// Agentp gateway message queue, keyed by server URL
+const agentpQueues = {};
+
+function validateAgentpAuth(req) {
+  const password = process.env.OPENCODE_SERVER_PASSWORD;
+  if (!password) return true;
+  const username = process.env.OPENCODE_SERVER_USERNAME || 'opencode';
+  const expected = 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64');
+  return req.headers.authorization === expected;
+}
+
+function flushAgentpQueue(server, token, chatId) {
+  if (!chatId) return;
+  const q = agentpQueues[server];
+  if (!q || q.messages.length === 0) return;
+  const msgs = q.messages.splice(0);
+  q.notified = false;
+  if (q.notifyTimer) { clearTimeout(q.notifyTimer); q.notifyTimer = null; }
+  sendLongMessage(token, chatId,
+    `📨 Delivering ${msgs.length} queued agentp message(s):`)
+    .then(() => {
+      for (const msg of msgs) {
+        sendLongMessage(token, chatId, msg.trim()).catch(() => {});
+      }
+    })
+    .catch(() => {});
+}
+
+// ---------------------------------------------------------------------------
+// /record — ring buffer for Telegram conversation context
+// ---------------------------------------------------------------------------
+
+const MAX_RECORDED_MSGS = 100;
+const MAX_RECORDED_BYTES = 100 * 1024;
+
+const recorder = { active: false, messages: [], bytes: 0 };
+
+function bufferMessage(role, text) {
+  if (!recorder.active) return;
+  recorder.messages.push({ role, text });
+  recorder.bytes += Buffer.byteLength(text, 'utf8');
+  while (recorder.messages.length > MAX_RECORDED_MSGS || recorder.bytes > MAX_RECORDED_BYTES) {
+    const oldest = recorder.messages.shift();
+    recorder.bytes -= Buffer.byteLength(oldest.text, 'utf8');
+  }
+}
+
+function flushRecorded() {
+  if (!recorder.active) return [];
+  const msgs = recorder.messages.splice(0);
+  recorder.bytes = 0;
+  return msgs;
+}
+
 // ---------------------------------------------------------------------------
 // Telegram Bot API helpers
 // ---------------------------------------------------------------------------
@@ -72,7 +130,7 @@ function convertMarkdownToHtml(text) {
 
   return parts.map((part, i) => {
     if (i % 2 === 1) {
-      // Code block — strip language tag, escape entities, wrap in <pre>
+      // Code block ─ strip language tag, escape entities, wrap in <pre>
       const nl = part.indexOf('\n');
       const inner = nl >= 0 ? part.slice(nl + 1) : part;
       return '<pre>' + inner
@@ -194,7 +252,7 @@ function quoteReply(msg) {
     if (rm.text[i] === '`') { cur++; maxBackticks = Math.max(maxBackticks, cur); }
     else cur = 0;
   }
-  const fence = '`'.repeat(maxBackticks + 1);
+  const fence = '`'.repeat(Math.max(3, maxBackticks + 1));
   return `In response to ${replyFrom} (${senderType}):\n\n${fence}\n${rm.text}\n${fence}\n\n`;
 }
 
@@ -207,25 +265,25 @@ async function cmdHelp(token, chatId, args) {
     const topic = args[0].toLowerCase();
     if (topic === 'servers') {
       await sendLongMessage(token, chatId,
-        '`/servers` — list all opencode servers (ocmux sessions)\n' +
-        '`/servers switch <name>` — switch target server\n\n' +
+        '`/servers` ─ list all opencode servers (ocmux sessions)\n' +
+        '`/servers switch <name>` ─ switch target server\n\n' +
         '`<name>` can be a full path or basename of the project directory.');
       return;
     }
     if (topic === 'sessions') {
       await sendLongMessage(token, chatId,
-        '`/sessions` — list active sessions (numbered, newest first, max 50)\n' +
-        '`/sessions switch <number-or-name>` — send messages to a specific session\n' +
-        '`/sessions new [name]` — create a new session\n' +
-        '`/sessions rename <name>` — rename the active session\n\n' +
+        '`/sessions` ─ list active sessions (numbered, newest first, max 50)\n' +
+        '`/sessions switch <number-or-name>` ─ send messages to a specific session\n' +
+        '`/sessions new [name]` ─ create a new session\n' +
+        '`/sessions rename <name>` ─ rename the active session\n\n' +
         'Switch by number (from the list) or by case-insensitive partial name match.\n' +
         'Use `/sessions` to find session numbers.');
       return;
     }
     if (topic === 'shutdown') {
       await sendLongMessage(token, chatId,
-        '`/shutdown` — stop tgagentp process\n' +
-        '`/shutdown force` — force shutdown even if busy (in-flight work will be lost)\n\n' +
+        '`/shutdown` ─ stop tgagentp process\n' +
+        '`/shutdown force` ─ force shutdown even if busy (in-flight work will be lost)\n\n' +
         'Only available when tgagentp is started with `--dev` flag.\n' +
         'Useful when running tgagentp in a restart loop:\n' +
         '`while true; do tgagentp --dev; done`');
@@ -233,32 +291,32 @@ async function cmdHelp(token, chatId, args) {
     }
     if (topic === 'agents') {
       await sendLongMessage(token, chatId,
-        '`/agents` — list all available agents (name, mode, assigned model, description).\n' +
-        '`/agents switch <name>` — switch the active agent. Subsequent messages will use this agent.\n\n' +
+        '`/agents` ─ list primary agents (with ▶ marker for the active one).\n' +
+        '`/agents switch <name>` ─ switch the active agent. Subsequent messages will use this agent.\n\n' +
         'Agent switching requires an active session (`/sessions switch` or `/sessions new`).');
       return;
     }
     if (topic === 'session') {
       await sendLongMessage(token, chatId,
         '`/session` is an alias for `/sessions`.\n\n' +
-        '`/sessions` — list active sessions\n' +
-        '`/sessions switch <number-or-name>` — switch to a session\n' +
-        '`/sessions new [name]` — create a new session\n' +
-        '`/sessions rename <name>` — rename the active session');
+        '`/sessions` ─ list active sessions\n' +
+        '`/sessions switch <number-or-name>` ─ switch to a session\n' +
+        '`/sessions new [name]` ─ create a new session\n' +
+        '`/sessions rename <name>` ─ rename the active session');
       return;
     }
     if (topic === 'models') {
       await sendLongMessage(token, chatId,
-        '`/models` — list all providers and their models.\n' +
+        '`/models` ─ list all providers and their models.\n' +
         'Shows provider name, connection status, default model, and up to 5 models per provider\n' +
         'with status, context limit, and input/output costs.');
       return;
     }
     if (topic === 'allow' || topic === 'reject' || topic === 'always') {
       await sendLongMessage(token, chatId,
-        '`/allow` — approve a permission request once\n' +
-        '`/reject` — deny a permission request\n' +
-        '`/always` — approve and remember for the session\n\n' +
+        '`/allow` ─ approve a permission request once\n' +
+        '`/reject` ─ deny a permission request\n' +
+        '`/always` ─ approve and remember for the session\n\n' +
         'These commands respond to OpenCode permission prompts forwarded by tgagentp.\n' +
         'When OpenCode needs approval (e.g. to run a shell command), tgagentp sends a\n' +
         '🔐 notification to the chat. Use one of these commands to answer.');
@@ -266,37 +324,59 @@ async function cmdHelp(token, chatId, args) {
     }
     if (topic === 'think') {
       await sendLongMessage(token, chatId,
-        '`/think` — toggle thinking message forwarding\n' +
-        '`/think on` — forward model thinking to the chat in real-time\n' +
-        '`/think off` — stop forwarding thinking messages (default)\n' +
-        '`/think switch` — toggle current state\n\n' +
+        '`/think` ─ toggle thinking message forwarding\n' +
+        '`/think on` ─ forward model thinking to the chat in real-time\n' +
+        '`/think off` ─ stop forwarding thinking messages (default)\n' +
+        '`/think switch` ─ toggle current state\n\n' +
         'When enabled, the model\'s internal reasoning steps are sent to the chat\n' +
         'as they are generated, prefixed with 💭.\n' +
         'Can also be enabled at startup with `--think` flag.');
       return;
     }
+    if (topic === 'queue') {
+      await sendLongMessage(token, chatId,
+        '`/queue <message>` ─ queue a message when the server is busy\n\n' +
+        'When the server is processing a previous message, queuing allows you to\n' +
+        'continue working without waiting. Once the current task finishes, the next\n' +
+        'queued message is automatically sent and the answer will reply to the\n' +
+        'original queued message.');
+      return;
+    }
+    if (topic === 'record') {
+      await sendLongMessage(token, chatId,
+        '`/record` ─ toggle recording of messages for agentp context\n' +
+        '`/record stop` ─ stop recording and clear buffer\n\n' +
+        'When recording is active, all user and assistant messages are buffered in memory\n' +
+        '(max 100 messages / 100KB). The next `agentp` invocation retrieves the buffered\n' +
+        'conversation and prepends it to its `--qa` stdout output, so OpenCode can\n' +
+        'see the full conversation context.\n\n' +
+        'Buffered messages are NOT sent back to Telegram (they are already there).');
+      return;
+    }
     await sendLongMessage(token, chatId,
-      'Unknown topic. Try `/help servers`, `/help sessions`, `/help session`, `/help agents`, `/help models`, `/help allow`, `/help think`, or just `/help`.');
+      'Unknown topic. Try `/help servers`, `/help sessions`, `/help session`, `/help agents`, `/help models`, `/help allow`, `/help think`, `/help record`, `/help queue`, or just `/help`.');
     return;
   }
   await sendLongMessage(token, chatId,
-    '`/help` — show this message\n' +
-    '`/help <topic>` — detailed help\n' +
-    '`/status` — show current server and session\n' +
-    '`/cancel` — cancel the running prompt\n' +
-    '`/servers` — list running opencode servers\n' +
-    '`/servers switch <name>` — switch to a different server\n' +
-    '`/sessions` — list/create/switch/rename sessions\n' +
-    '`/sessions switch <number-or-name>` — switch to a session\n' +
-    '`/sessions new [name]` — create a new session\n' +
-    '`/sessions rename <name>` — rename the active session\n' +
-    '`/session` — alias for `/sessions`\n' +
-    '`/agents` — list available agents\n' +
-    '`/agents switch <name>` — switch active agent\n' +
-    '`/models` — list providers and models\n' +
-    '`/think` — toggle thinking message forwarding\n' +
-    '`/allow` / `/reject` / `/always` — respond to permission requests\n' +
-    '`/shutdown` — stop tgagentp (only with `--dev` flag)\n\n' +
+    '`/help` ─ show this message\n' +
+    '`/help <topic>` ─ detailed help\n' +
+    '`/status` ─ show current server and session\n' +
+    '`/cancel` ─ cancel the running prompt\n' +
+    '`/servers` ─ list running opencode servers\n' +
+    '`/servers switch <name>` ─ switch to a different server\n' +
+    '`/sessions` ─ list/create/switch/rename sessions\n' +
+    '`/sessions switch <number-or-name>` ─ switch to a session\n' +
+    '`/sessions new [name]` ─ create a new session\n' +
+    '`/sessions rename <name>` ─ rename the active session\n' +
+    '`/session` ─ alias for `/sessions`\n' +
+    '`/agents` ─ list available agents\n' +
+    '`/agents switch <name>` ─ switch active agent\n' +
+    '`/models` ─ list providers and models\n' +
+    '`/think` ─ toggle thinking message forwarding\n' +
+    '`/record` ─ record Telegram conversation for agentp context\n' +
+    '`/queue <message>` ─ queue a message when server is busy\n' +
+    '`/allow` / `/reject` / `/always` ─ respond to permission requests\n' +
+    '`/shutdown` ─ stop tgagentp (only with `--dev` flag)\n\n' +
     'Everything else is forwarded to the active server as `[Telegram] <text>`.');
 }
 
@@ -493,10 +573,10 @@ async function cmdSessions(token, chatId, args, setServer, setActiveSession, ser
     await sendLongMessage(token, chatId,
       `Unknown subcommand: /sessions ${sub}\n\n` +
       'Usage:\n' +
-      '  `/sessions` — list sessions\n' +
-      '  `/sessions switch <number-or-name>` — switch to a session\n' +
-      '  `/sessions new [name]` — create a new session\n' +
-      '  `/sessions rename <name>` — rename the active session');
+      '  `/sessions` ─ list sessions\n' +
+      '  `/sessions switch <number-or-name>` ─ switch to a session\n' +
+      '  `/sessions new [name]` ─ create a new session\n' +
+      '  `/sessions rename <name>` ─ rename the active session');
     return;
   }
 
@@ -596,10 +676,14 @@ async function cmdAgents(token, chatId, args, setServer, setActiveSession, serve
       }
       const target = matches[0];
       getState(server).activeAgentName = target.name;
-      const mode = target.mode === 'primary' ? '' : ` (${target.mode})`;
-      const model = target.model ? ` — \`${target.model.providerID}/${target.model.modelID}\`` : '';
+      const st = getState(server);
+      if (st.activeSessionId) {
+        updateSession(server, st.activeSessionId, undefined, target.name);
+        selectSession(server, st.activeSessionId);
+      }
+      const model = target.model ? ` ─ \`${target.model.providerID}/${target.model.modelID}\`` : '';
       await sendLongMessage(token, chatId,
-        `Switched to agent: **${target.name}**${mode}${model}\nSubsequent messages will use this agent.`);
+        `Switched to agent: **${target.name}**${model}\nSubsequent messages will use this agent.`);
     } catch (err) {
       await sendLongMessage(token, chatId, `Error switching agent: ${err.message}`);
     }
@@ -612,13 +696,19 @@ async function cmdAgents(token, chatId, args, setServer, setActiveSession, serve
       await sendLongMessage(token, chatId, 'No agents available.');
       return;
     }
-    const lines = agents.map(a => {
-      const mode = a.mode === 'primary' ? '' : ` (${a.mode})`;
-      const model = a.model ? ` — \`${a.model.providerID}/${a.model.modelID}\`` : '';
+    const primary = agents.filter(a => a.mode === 'primary');
+    if (primary.length === 0) {
+      await sendLongMessage(token, chatId, 'No primary agents available.');
+      return;
+    }
+    const activeAgentName = getState(server).activeAgentName;
+    const lines = primary.map(a => {
+      const bullet = a.name === activeAgentName ? '▶ ' : ' · ';
+      const model = a.model ? ` ─ \`${a.model.providerID}/${a.model.modelID}\`` : '';
       const desc = a.description ? `. ${a.description}` : '';
-      return '**' + a.name + '**' + mode + model + desc;
+      return bullet + '**' + a.name + '**' + model + desc;
     });
-    await sendLongMessage(token, chatId, 'Agents:\n' + lines.join('\n'));
+    await sendLongMessage(token, chatId, 'Primary agents:\n' + lines.join('\n'));
   } catch (err) {
     await sendLongMessage(token, chatId, `Error listing agents: ${err.message}`);
   }
@@ -664,6 +754,91 @@ async function cmdModels(token, chatId, args, setServer, setActiveSession, serve
 
 const PERM_RESPONSE_HELP = ' No pending permission. Use `/status` to check the current state.';
 
+// ---------------------------------------------------------------------------
+// Agentp gateway ─ tiny HTTP server for agentp --tg
+// ---------------------------------------------------------------------------
+
+function startAgentpGateway(token, chatIdResolver, serverBaseResolver) {
+  return new Promise((resolve) => {
+    const server = http.createServer((req, res) => {
+      try {
+        if (req.method !== 'POST' || req.url !== '/send') {
+          res.writeHead(405);
+          res.end('Method Not Allowed');
+          return;
+        }
+        if (!validateAgentpAuth(req)) {
+          res.writeHead(401);
+          res.end('Unauthorized');
+          return;
+        }
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', () => {
+          try {
+            let data;
+            try { data = JSON.parse(body); } catch {
+              res.writeHead(400);
+              res.end('Bad Request');
+              return;
+            }
+            const { text, server } = data;
+            if (typeof text !== 'string' || typeof server !== 'string') {
+              res.writeHead(400);
+              res.end('Bad Request: text and server are required');
+              return;
+            }
+            const chatId = chatIdResolver();
+
+            // Return recorded conversation buffer before forwarding
+            const buffered = flushRecorded();
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ buffered }));
+
+            if (!chatId) return;
+            const activeUrl = normalizeUrl(serverBaseResolver());
+            const targetUrl = normalizeUrl(server);
+
+            if (targetUrl === activeUrl) {
+              sendLongMessage(token, chatId, text.trim()).catch(() => {});
+            } else {
+              if (!agentpQueues[server]) {
+                agentpQueues[server] = { messages: [], notifyTimer: null, notified: false };
+              }
+              const q = agentpQueues[server];
+              q.messages.push(text);
+              if (!q.notifyTimer) {
+                q.notifyTimer = setTimeout(() => {
+                  q.notifyTimer = null;
+                  if (q.messages.length > 0 && !q.notified) {
+                    q.notified = true;
+                    sendLongMessage(token, chatId,
+                      `📥 ${q.messages.length} agentp message(s) queued for server \`${server}\`. Switch servers to view them.`)
+                      .catch(() => {});
+                  }
+                }, TGAGENTP_DEBOUNCE_MS);
+              }
+            }
+          } catch (err) {
+            log.error(`Agentp gateway handler error: ${err.message}`);
+          }
+        });
+      } catch (err) {
+        log.error(`Agentp gateway handler error: ${err.message}`);
+      }
+    });
+    server.on('error', (err) => {
+      log.error(`Agentp gateway server error: ${err.message}`);
+    });
+    server.listen(TGAGENTP_PORT, '127.0.0.1', () => {
+      const port = server.address().port;
+      try { fs.writeFileSync(PORT_FILE, String(port)); } catch (_) {}
+      log.info(`Agentp gateway listening on port ${port}`);
+      resolve(port);
+    });
+  });
+}
+
 async function cmdAllow(token, chatId, args, setServer, setActiveSession, server) {
   const st = getState(server);
   if (!st.pendingPermission) {
@@ -730,6 +905,39 @@ async function cmdThink(token, chatId, args, setServer, setActiveSession, server
   }
 }
 
+async function cmdQueue(token, chatId, args, _, __, serverBase, replyTo) {
+  const st = getState(serverBase);
+  if (!st.busy) {
+    await sendLongMessage(token, chatId, 'Server is not busy. No need to queue — send your message directly.');
+    return;
+  }
+  const text = args.join(' ').trim();
+  if (!text) {
+    await sendLongMessage(token, chatId, 'Usage: `/queue <message>` — queue a message for when the server is idle.');
+    return;
+  }
+  if (!st.messageQueue) st.messageQueue = [];
+  st.messageQueue.push({ text, replyTo });
+  await sendLongMessage(token, chatId, `📥 Queued. ${st.messageQueue.length} message(s) in queue. Will be sent when the current task finishes.`);
+}
+
+async function cmdRecord(token, chatId, args) {
+  if (args.length > 0 && args[0].toLowerCase() === 'stop') {
+    recorder.active = false;
+    recorder.messages = [];
+    recorder.bytes = 0;
+    await sendLongMessage(token, chatId, '⏹ Recording stopped. Buffer cleared.');
+    return;
+  }
+  recorder.active = !recorder.active;
+  if (!recorder.active) {
+    recorder.messages = [];
+    recorder.bytes = 0;
+  }
+  await sendLongMessage(token, chatId,
+    recorder.active ? '🔴 Recording started. Messages will be cached for agentp.' : '⏹ Recording stopped. Buffer cleared.');
+}
+
 const COMMANDS = {
   'help': cmdHelp,
   'servers': cmdServers,
@@ -738,6 +946,8 @@ const COMMANDS = {
   'agents': cmdAgents,
   'models': cmdModels,
   'think': cmdThink,
+  'record': cmdRecord,
+  'queue': cmdQueue,
   'allow': cmdAllow,
   'reject': cmdReject,
   'always': cmdAlways,
@@ -749,7 +959,7 @@ const COMMANDS = {
 
 const serverState = {};
 function getState(url) {
-  return serverState[url] = serverState[url] || { busy: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, thinkingEnabled: false };
+  return serverState[url] = serverState[url] || { busy: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, thinkingEnabled: false, messageQueue: [] };
 }
 
 function sessionLabel(st) {
@@ -797,10 +1007,15 @@ async function main() {
       console.error('');
       console.error('Environment variables:');
       console.error('  TELEGRAM_BOT_TOKEN         Telegram bot token (required)');
-      console.error('  OPENCODE_SERVER_PASSWORD    OpenCode server password (optional)');
+      console.error('  OPENCODE_SERVER_PASSWORD    OpenCode server password (optional, also used for agentp gateway auth)');
       console.error('  OPENCODE_SERVER_USERNAME    OpenCode server username (optional, default: opencode)');
       console.error('  TGAGENTP_ALLOWED_CHAT_IDS   Comma-separated Telegram chat IDs (optional)');
       console.error('                               Example: "123456,-789012"');
+      console.error('  TGAGENTP_PORT               Agentp gateway listen port (optional, default: random)');
+      console.error('  TGAGENTP_DEBOUNCE_MS        Debounce interval for queued agentp messages (optional, default: 5000)');
+      console.error('');
+      console.error('Also starts an agentp gateway (tiny HTTP server on localhost) that');
+      console.error('accepts POST /send from agentp --tg and forwards answers to Telegram.');
       console.error('');
       console.error('See also: agentp, ocmux');
       console.error('');
@@ -859,10 +1074,19 @@ async function main() {
 
   log.info('Waiting for Telegram messages... (Ctrl+C to stop)');
 
+  // Start agentp gateway (tiny HTTP server for agentp --tg)
+  const chatIdResolver = () => lockedChatId;
+  const serverBaseResolver = () => serverBase;
+  startAgentpGateway(token, chatIdResolver, serverBaseResolver);
+
   const setServer = async (url) => {
     serverBase = url;
     getState(url);
     log.info(`Switched to server: ${url}`);
+
+    // Flush agentp queue for the new active server
+    flushAgentpQueue(url, token, lockedChatId);
+
     const [discovered, agents] = await Promise.all([
       discoverActiveSession(url),
       listAgents(url).catch(() => []),
@@ -894,18 +1118,27 @@ async function main() {
     const st = getState(url);
     const isCancelled = () => getState(url).taskId !== myTaskId;
     const cancelRef = { current: null };
+    const sessionCancelRef = { current: null };
     st._cancelRef = cancelRef;
+    st._sessionReq = sessionCancelRef;
     try {
       let answer;
       if (useSession) {
-        // Event-driven flow: start SSE listener first, then send message async
+        // Dual approach:
+        // 1. SSE for permissions/thinking events (connected before sending)
+        // 2. Synchronous sendToSession (POST /session/:id/message) for reliable answer
         const notifiedPerms = new Set();
         let thinkingBuf = '';
-        const ssePromise = listenForSessionEvents(url, sessionId, {
+        let sseConnected;
+        const onConnected = Promise.race([
+          new Promise((resolve) => { sseConnected = resolve; }),
+          new Promise((resolve) => setTimeout(resolve, 5000)),
+        ]);
+        listenForSessionEvents(url, sessionId, {
           onText: null,
+          onConnected: sseConnected,
           onThinking: (chunk) => {
             if (!getState(url).thinkingEnabled) { thinkingBuf = ''; return; }
-            // Forward thinking chunks in real-time
             thinkingBuf += chunk;
             if (thinkingBuf.length >= 50 || chunk.endsWith('\n')) {
               const html = '💭 ' + thinkingBuf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
@@ -942,23 +1175,18 @@ async function main() {
             log.debug(`  → permission_replied: clearing pendingPermission`);
             getState(url).pendingPermission = null;
           },
-        }, cancelRef);
-        // Send message (SSE is already listening — no race)
-        try {
-          await sendToSessionAsync(url, sessionId, `[Telegram] ${text}`, st.activeAgentName);
-        } catch (err) {
-          // Abort SSE listener on send failure to avoid resource leak
-          if (cancelRef.current) { cancelRef.current.destroy(); cancelRef.current = null; }
-          throw err;
-        }
-        // Wait for the SSE listener to collect the full answer
-        answer = await ssePromise;
+        }, cancelRef).catch(() => {});
+        // Wait for SSE to connect, then send synchronously
+        await onConnected;
+        answer = await sendToSession(url, sessionId, `[Telegram] ${text}`, st.activeAgentName, sessionCancelRef);
         // Flush any remaining thinking buffer
         if (thinkingBuf) {
           const html = '💭 ' + thinkingBuf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
           sendLongMessage(token, chatId, html, replyTo).catch(() => {});
           thinkingBuf = '';
         }
+        // Clean up SSE listener
+        if (cancelRef.current) { cancelRef.current.destroy(); cancelRef.current = null; }
       } else {
         await sendText(url, `[Telegram] ${text}`);
         answer = await listenForFinalAnswer(url, null, cancelRef);
@@ -971,13 +1199,18 @@ async function main() {
       st.pendingPermission = null;
       if (url === serverBase) {
         if (answer && answer.trim()) {
-          await sendLongMessage(token, chatId, answer.trim(), replyTo);
+          const trimmed = answer.trim();
+          await sendLongMessage(token, chatId, trimmed, replyTo);
+          bufferMessage('assistant', trimmed);
         }
       } else {
         getState(url).pendingResponse = answer;
         await sendLongMessage(token, chatId, `✅ Server \`${url}\` finished processing. Switch back to see the response.`, replyTo);
+        if (answer && answer.trim()) bufferMessage('assistant', answer.trim());
       }
     } catch (err) {
+      // Clean up SSE listener if it's still active
+      if (cancelRef.current) { cancelRef.current.destroy(); cancelRef.current = null; }
       if (isCancelled()) {
         log.debug(`  → cancelled, ignoring error from ${url}: ${err.message}`);
         st.pendingPermission = null;
@@ -990,8 +1223,24 @@ async function main() {
     } finally {
       st.pendingPermission = null;
       if (st._cancelRef === cancelRef) st._cancelRef = null;
+      if (st._sessionReq === sessionCancelRef) st._sessionReq = null;
       if (!isCancelled()) {
         getState(url).busy = false;
+        // Drain message queue for this server
+        const q = st.messageQueue || [];
+        st.messageQueue = [];
+        if (q.length > 0) {
+          const next = q[0];
+          // Re-queue remaining items (if any) for the next round
+          st.messageQueue = q.slice(1);
+          const nextText = next.text;
+          const nextReplyTo = next.replyTo;
+          // Mark busy again and process
+          getState(url).busy = true;
+          const nextTaskId = ++st.taskId;
+          log.debug(`  → processing queued message (task ${nextTaskId})`);
+          processMessageAsync(chatId, nextText, url, !!st.activeSessionId, st.activeSessionId, nextTaskId, nextReplyTo);
+        }
       }
     }
   }
@@ -1009,6 +1258,11 @@ async function main() {
       st._cancelRef.current.destroy();
       st._cancelRef.current = null;
     }
+    // Abort the synchronous session request if in progress
+    if (st._sessionReq && st._sessionReq.current) {
+      st._sessionReq.current.destroy();
+      st._sessionReq.current = null;
+    }
     await sendLongMessage(token, chatId, '✅ Cancelled.');
     log.debug(`  → /cancel on ${serverBase}`);
   }
@@ -1062,6 +1316,7 @@ async function main() {
     lines.push('**Session:** ' + sessionLabel(st));
     lines.push('**Agent:** ' + (st.activeAgentName ? '`' + st.activeAgentName + '`' : '*default*'));
     try { await sendLongMessage(token, savedChatId, lines.join('\n')); } catch (_) {}
+    lockedChatId = savedChatId;
     try { fs.unlinkSync(STARTUP_CHAT_FILE); } catch (_) {}
   }
 
@@ -1134,15 +1389,18 @@ async function main() {
           }
         } else {
           await sendLongMessage(token, chatId,
-            `Unknown command: /${cmd}\n\nAvailable commands: /help, /status, /servers, /sessions, /agents, /models`);
+            `Unknown command: /${cmd}\n\nAvailable commands: /help, /status, /servers, /sessions, /agents, /models, /think, /record, /queue`);
         }
         continue;
       }
 
-      // Non-command message — process in background
+      // Buffer user messages for /record
+      bufferMessage('user', replyContext + text);
+
+      // Non-command message ─ process in background
       const st = getState(serverBase);
       if (st.busy) {
-        await sendLongMessage(token, chatId, '⏳ Server is busy processing a previous message. Please wait for it to finish, or use /cancel to cancel it.');
+        await sendLongMessage(token, chatId, '⏳ Server is busy. Use `/cancel` to cancel or `/queue <message>` to queue your message.');
         continue;
       }
       st.busy = true;