agentp 0.7.0 → 0.9.0

package/bin/tgagentp

@@ -1,26 +1,54 @@
 #!/usr/bin/env node
 
+const http = require('http');
 const https = require('https');
 const fs = require('fs');
 const path = require('path');
 const { version } = require('../package.json');
 const { sendText, listenForFinalAnswer, listSessions, createSession, updateSession, selectSession, sendToSession, sendToSessionAsync, respondToPermission, listenForSessionEvents, listAgents, listProviders } = require('../lib/opencode.js');
 
-// Monkey-patch stderr to prefix all output with timestamps
-{
-  const origWrite = process.stderr.write.bind(process.stderr);
-  process.stderr.write = function (chunk, encoding, cb) {
-    const ts = new Date().toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, '');
-    const str = typeof chunk === 'string' ? chunk : chunk.toString(encoding || 'utf8');
-    const lines = str.split('\n');
-    const prefixed = lines.map(l => l ? `[${ts}] ${l}` : l).join('\n');
-    return origWrite(prefixed, encoding, cb);
-  };
-}
+// Logger: info→stdout, error→stderr (always), debug→stderr (--verbose only)
+const log = {
+  verbose: false,
+  info(msg) { process.stdout.write(`${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, '')} ${msg}\n`); },
+  error(msg) { process.stderr.write(`${msg}\n`); },
+  debug(msg) { if (this.verbose) process.stderr.write(`${msg}\n`); },
+};
 
 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(() => {});
+}
+
 // ---------------------------------------------------------------------------
 // Telegram Bot API helpers
 // ---------------------------------------------------------------------------
@@ -63,9 +91,10 @@ function getUpdates(token, offset, timeout) {
   });
 }
 
-function sendTelegramMessage(token, chatId, text, parseMode) {
+function sendTelegramMessage(token, chatId, text, parseMode, replyTo) {
   const params = { chat_id: chatId, text };
   if (parseMode) params.parse_mode = parseMode;
+  if (replyTo) params.reply_to_message_id = replyTo;
   return telegramRequest(token, 'sendMessage', params);
 }
 
@@ -75,7 +104,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
@@ -173,12 +202,32 @@ function splitMessage(text, maxLength = 4096) {
 // Converts Markdown to Telegram HTML formatting.
 // Splits the raw text first, then converts each chunk independently
 // to avoid broken HTML tags across messages.
-async function sendLongMessage(token, chatId, text) {
+async function sendLongMessage(token, chatId, text, replyTo) {
   const chunks = splitMessage(text);
-  for (const chunk of chunks) {
-    const html = convertMarkdownToHtml(chunk);
-    await sendTelegramMessage(token, chatId, html, 'HTML');
+  for (let i = 0; i < chunks.length; i++) {
+    const html = convertMarkdownToHtml(chunks[i]);
+    await sendTelegramMessage(token, chatId, html, 'HTML', i === 0 ? replyTo : undefined);
+  }
+}
+
+// Build a quoted reply context from a Telegram reply_to_message.
+// Returns empty string if the message isn't a reply or has no text.
+// Uses a dynamic code-fence length (max consecutive backticks + 1)
+// so nested backticks never break the structure.
+function quoteReply(msg) {
+  const rm = msg.reply_to_message;
+  if (!rm || !rm.text) return '';
+  const replyFrom = rm.from?.username
+    ? `@${rm.from.username}`
+    : [rm.from?.first_name, rm.from?.last_name].filter(Boolean).join(' ') || 'unknown';
+  const senderType = rm.from?.is_bot ? 'assistant' : 'user';
+  let maxBackticks = 0;
+  for (let i = 0, cur = 0; i < rm.text.length; i++) {
+    if (rm.text[i] === '`') { cur++; maxBackticks = Math.max(maxBackticks, cur); }
+    else cur = 0;
   }
+  const fence = '`'.repeat(maxBackticks + 1);
+  return `In response to ${replyFrom} (${senderType}):\n\n${fence}\n${rm.text}\n${fence}\n\n`;
 }
 
 // ---------------------------------------------------------------------------
@@ -190,24 +239,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\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`');
@@ -215,62 +265,74 @@ 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.');
       return;
     }
+    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' +
+        '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;
+    }
     await sendLongMessage(token, chatId,
-      'Unknown topic. Try `/help servers`, `/help sessions`, `/help session`, `/help agents`, `/help models`, `/help allow`, or just `/help`.');
+      'Unknown topic. Try `/help servers`, `/help sessions`, `/help session`, `/help agents`, `/help models`, `/help allow`, `/help think`, 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' +
-    '`/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' +
+    '`/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>`.');
 }
 
-async function cmdServers(token, chatId, args, setServer) {
+async function cmdServers(token, chatId, args, setServer, setActiveSession, serverBase) {
   if (args.length > 0 && args[0].toLowerCase() === 'switch') {
     if (args.length < 2) {
       await sendLongMessage(token, chatId,
@@ -463,10 +525,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;
   }
 
@@ -566,10 +628,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}`);
     }
@@ -582,13 +648,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}`);
   }
@@ -634,6 +706,88 @@ 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;
+            }
+            res.writeHead(200);
+            res.end('OK');
+
+            const chatId = chatIdResolver();
+            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) {
@@ -644,7 +798,7 @@ async function cmdAllow(token, chatId, args, setServer, setActiveSession, server
   try {
     await respondToPermission(p.server, p.sessionId, p.permissionId, 'once');
     await sendLongMessage(token, chatId, '✅ Permission approved (once).');
-    process.stderr.write(`  → /allow: ${p.type} ${p.pattern || ''}\n`);
+    log.debug(`  → /allow: ${p.type} ${p.pattern || ''}`);
   } catch (err) {
     await sendLongMessage(token, chatId, `Error: ${err.message}`);
   }
@@ -660,7 +814,7 @@ async function cmdReject(token, chatId, args, setServer, setActiveSession, serve
   try {
     await respondToPermission(p.server, p.sessionId, p.permissionId, 'reject');
     await sendLongMessage(token, chatId, '⛔ Permission denied.');
-    process.stderr.write(`  → /reject: ${p.type} ${p.pattern || ''}\n`);
+    log.debug(`  → /reject: ${p.type} ${p.pattern || ''}`);
   } catch (err) {
     await sendLongMessage(token, chatId, `Error: ${err.message}`);
   }
@@ -676,12 +830,30 @@ async function cmdAlways(token, chatId, args, setServer, setActiveSession, serve
   try {
     await respondToPermission(p.server, p.sessionId, p.permissionId, 'always');
     await sendLongMessage(token, chatId, '✅ Permission approved (always).');
-    process.stderr.write(`  → /always: ${p.type} ${p.pattern || ''}\n`);
+    log.debug(`  → /always: ${p.type} ${p.pattern || ''}`);
   } catch (err) {
     await sendLongMessage(token, chatId, `Error: ${err.message}`);
   }
 }
 
+async function cmdThink(token, chatId, args, setServer, setActiveSession, server) {
+  const st = getState(server);
+  const sub = args && args.length > 0 ? args[0].toLowerCase() : 'switch';
+  if (sub === 'on') {
+    st.thinkingEnabled = true;
+    await sendLongMessage(token, chatId, '💭 Thinking messages **on** (forwarded to chat).');
+  } else if (sub === 'off') {
+    st.thinkingEnabled = false;
+    await sendLongMessage(token, chatId, '💭 Thinking messages **off**.');
+  } else if (sub === 'switch') {
+    st.thinkingEnabled = !st.thinkingEnabled;
+    await sendLongMessage(token, chatId,
+      `💭 Thinking messages ${st.thinkingEnabled ? '**on**' : '**off**'}.`);
+  } else {
+    await sendLongMessage(token, chatId, 'Usage: `/think [on|off|switch]` (default: switch).');
+  }
+}
+
 const COMMANDS = {
   'help': cmdHelp,
   'servers': cmdServers,
@@ -689,6 +861,7 @@ const COMMANDS = {
   'session': cmdSessions,
   'agents': cmdAgents,
   'models': cmdModels,
+  'think': cmdThink,
   'allow': cmdAllow,
   'reject': cmdReject,
   'always': cmdAlways,
@@ -700,7 +873,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 };
+  return serverState[url] = serverState[url] || { busy: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, thinkingEnabled: false };
 }
 
 function sessionLabel(st) {
@@ -725,6 +898,10 @@ async function main() {
       process.exit(0);
     } else if (args[i] === '--dev') {
       DEV_MODE = true;
+    } else if (args[i] === '--verbose') {
+      log.verbose = true;
+    } else if (args[i] === '--think') {
+      getState(serverBase).thinkingEnabled = true;
     } else if (args[i] === '--help') {
       console.error('Usage: tgagentp [options] [url]');
       console.error('');
@@ -732,9 +909,11 @@ async function main() {
       console.error('Incoming Telegram messages are forwarded to OpenCode; answers are sent back to the chat.');
       console.error('');
       console.error('Options:');
-      console.error('  --dev      Enable development mode (adds /shutdown command)');
-      console.error('  --version  Show version');
-      console.error('  --help     Show this help message');
+      console.error('  --dev       Enable development mode (adds /shutdown command)');
+      console.error('  --version   Show version');
+      console.error('  --verbose   Show detailed logs (errors, trace, debug) on stderr');
+      console.error('  --think     Start with thinking messages enabled (default: off)');
+      console.error('  --help      Show this help message');
       console.error('');
       console.error('Arguments:');
       console.error('  url        OpenCode TUI server URL or port number (default: 4096)');
@@ -742,10 +921,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('');
@@ -769,24 +953,24 @@ async function main() {
     process.exit(1);
   }
 
-  process.stderr.write(`tgagentp v${version} started. OpenCode server: ${serverBase}\n`);
+  log.info(`tgagentp v${version} started. OpenCode server: ${serverBase}`);
 
   if (!process.env.OPENCODE_SERVER_PASSWORD) {
-    process.stderr.write('🔓 ⚠️  Server is not password-protected! Set OPENCODE_SERVER_PASSWORD for better security.\n');
+    log.error('🔓  Server is not password-protected! Set OPENCODE_SERVER_PASSWORD for better security.');
   }
 
   const allowedChatIds = parseAllowlist(process.env.TGAGENTP_ALLOWED_CHAT_IDS);
   if (allowedChatIds) {
-    process.stderr.write(`Chat allowlist: ${allowedChatIds.length} chat(s) configured\n`);
+    log.info(`Chat allowlist: ${allowedChatIds.length} chat(s) configured`);
   } else {
-    process.stderr.write('Chat allowlist: not configured (all chats accepted)\n');
+    log.info('Chat allowlist: not configured (all chats accepted)');
   }
 
   let lockedChatId = null;
 
   getState(serverBase);
 
-  process.stderr.write('Discovering server state...\n');
+  log.info('Discovering server state...');
   const [discovered, agents] = await Promise.all([
     discoverActiveSession(serverBase),
     listAgents(serverBase).catch(() => []),
@@ -794,20 +978,29 @@ async function main() {
   if (discovered) {
     getState(serverBase).activeSessionId = discovered.id;
     getState(serverBase).activeSessionName = discovered.name;
-    process.stderr.write(`  → session: ${discovered.name || discovered.id}\n`);
+    log.info(`  → session: ${discovered.name || discovered.id}`);
   }
   const defaultAgent = agents.find(a => a.mode === 'primary') || agents[0];
   if (defaultAgent) {
     getState(serverBase).activeAgentName = defaultAgent.name;
-    process.stderr.write(`  → agent: ${defaultAgent.name}\n`);
+    log.info(`  → agent: ${defaultAgent.name}`);
   }
 
-  process.stderr.write('Waiting for Telegram messages... (Ctrl+C to stop)\n');
+  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);
-    process.stderr.write(`Switched to server: ${url}\n`);
+    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(() => []),
@@ -815,12 +1008,12 @@ async function main() {
     if (discovered) {
       getState(url).activeSessionId = discovered.id;
       getState(url).activeSessionName = discovered.name;
-      process.stderr.write(`  → session: ${discovered.name || discovered.id}\n`);
+      log.info(`  → session: ${discovered.name || discovered.id}`);
     }
     const defaultAgent = agents.find(a => a.mode === 'primary') || agents[0];
     if (defaultAgent) {
       getState(url).activeAgentName = defaultAgent.name;
-      process.stderr.write(`  → agent: ${defaultAgent.name}\n`);
+      log.info(`  → agent: ${defaultAgent.name}`);
     }
     const p = getState(url).pendingResponse;
     if (p) {
@@ -832,24 +1025,47 @@ async function main() {
 
   const setActiveSession = (id) => {
     getState(serverBase).activeSessionId = id;
-    process.stderr.write(`Switched to session: ${id}\n`);
+    log.info(`Switched to session: ${id}`);
   };
 
-  async function processMessageAsync(chatId, text, url, useSession, sessionId, myTaskId) {
+  async function processMessageAsync(chatId, text, url, useSession, sessionId, myTaskId, replyTo) {
     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();
-        const ssePromise = listenForSessionEvents(url, sessionId, {
+        let thinkingBuf = '';
+        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; }
+            thinkingBuf += chunk;
+            if (thinkingBuf.length >= 50 || chunk.endsWith('\n')) {
+              const html = '💭 ' + thinkingBuf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+              sendLongMessage(token, chatId, html, replyTo)
+                .then(() => {})
+                .catch(() => {});
+              thinkingBuf = '';
+            }
+          },
           onPermission: (perm) => {
             const st2 = getState(url);
             const permDump = JSON.stringify(perm);
-            process.stderr.write(`  → permission_asked callback: ${permDump}\n`);
+            log.debug(`  → permission_asked callback: ${permDump}`);
             st2.pendingPermission = { server: url, sessionId, permissionId: perm.id, type: perm.permission || 'unspecified', pattern: perm.patterns || perm.pattern, title: perm.title };
             if (!notifiedPerms.has(perm.id)) {
               notifiedPerms.add(perm.id);
@@ -861,60 +1077,64 @@ async function main() {
                 + (patternStr ? '**Target:** `' + patternStr + '`\n' : '')
                 + (perm.title ? '**Detail:** ' + perm.title + '\n' : '')
                 + 'Use `/allow` to approve once, `/always` to always allow, or `/reject` to deny.';
-              process.stderr.write(`  → sending permission notification to chat ${chatId}\n`);
-              sendLongMessage(token, chatId, msg)
-                .then(() => process.stderr.write(`  → permission notification sent OK\n`))
-                .catch((err) => process.stderr.write(`  → permission notification failed: ${err.message}\n`));
+              log.debug(`  → sending permission notification to chat ${chatId}`);
+              sendLongMessage(token, chatId, msg, replyTo)
+                .then(() => log.debug(`  → permission notification sent OK`))
+                .catch((err) => log.debug(`  → permission notification failed: ${err.message}`));
             } else {
-              process.stderr.write(`  → permission ${perm.id} already notified, updating pendingPermission only\n`);
+              log.debug(`  → permission ${perm.id} already notified, updating pendingPermission only`);
             }
           },
           onPermissionReplied: () => {
-            process.stderr.write(`  → permission_replied: clearing pendingPermission\n`);
+            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;
+        }, 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 = '';
         }
-        // Wait for the SSE listener to collect the full answer
-        answer = await ssePromise;
+        // 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);
       }
       if (isCancelled()) {
-        process.stderr.write(`  → cancelled, discarding response from ${url}\n`);
+        log.debug(`  → cancelled, discarding response from ${url}`);
         st.pendingPermission = null;
         return;
       }
       st.pendingPermission = null;
       if (url === serverBase) {
         if (answer && answer.trim()) {
-          await sendLongMessage(token, chatId, answer.trim());
+          await sendLongMessage(token, chatId, answer.trim(), replyTo);
         }
       } else {
         getState(url).pendingResponse = answer;
-        await sendLongMessage(token, chatId, `✅ Server \`${url}\` finished processing. Switch back to see the response.`);
+        await sendLongMessage(token, chatId, `✅ Server \`${url}\` finished processing. Switch back to see the response.`, replyTo);
       }
     } catch (err) {
+      // Clean up SSE listener if it's still active
+      if (cancelRef.current) { cancelRef.current.destroy(); cancelRef.current = null; }
       if (isCancelled()) {
-        process.stderr.write(`  → cancelled, ignoring error from ${url}: ${err.message}\n`);
+        log.debug(`  → cancelled, ignoring error from ${url}: ${err.message}`);
         st.pendingPermission = null;
         return;
       }
-      process.stderr.write(`Error processing message (${url}): ${err.message}\n`);
+      log.error(`Error processing message (${url}): ${err.message}`);
       if (url === serverBase) {
-        try { await sendLongMessage(token, chatId, `Error: ${err.message}`); } catch (_) {}
+        try { await sendLongMessage(token, chatId, `Error: ${err.message}`, replyTo); } catch (_) {}
       }
     } finally {
       st.pendingPermission = null;
       if (st._cancelRef === cancelRef) st._cancelRef = null;
+      if (st._sessionReq === sessionCancelRef) st._sessionReq = null;
       if (!isCancelled()) {
         getState(url).busy = false;
       }
@@ -934,8 +1154,13 @@ 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.');
-    process.stderr.write(`  → /cancel on ${serverBase}\n`);
+    log.debug(`  → /cancel on ${serverBase}`);
   }
 
   const cmdStatus = async (token, chatId) => {
@@ -951,13 +1176,22 @@ async function main() {
     await sendLongMessage(token, chatId, lines.join('\n'));
   };
 
-  const cmdShutdown = async (token, chatId) => {
-    await sendLongMessage(token, chatId, '👋 Shutting down...');
+  const cmdShutdown = async (token, chatId, args) => {
+    const st = getState(serverBase);
+    const isForce = args && args.length > 0 && args[0].toLowerCase() === 'force';
+    if (st.busy && !isForce) {
+      await sendLongMessage(token, chatId,
+        '⏳ Server is busy processing a message.\n' +
+        'Use `/shutdown force` to shut down anyway (in-flight response will be lost).');
+      return;
+    }
+    const status = st.busy ? '⏳ busy (forced)' : '✅ idle';
+    await sendLongMessage(token, chatId, `👋 Shutting down (state: ${status})...`);
     try {
       fs.writeFileSync(STARTUP_CHAT_FILE, String(chatId));
     } catch (_) {}
     try { await getUpdates(token, offset, 1); } catch (_) {}
-    process.stderr.write('/shutdown received, exiting...\n');
+    log.debug('/shutdown received, exiting...');
     process.exit(0);
   };
 
@@ -978,6 +1212,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 (_) {}
   }
 
@@ -987,13 +1222,13 @@ async function main() {
     try {
       result = await getUpdates(token, offset, 30);
     } catch (err) {
-      process.stderr.write(`Polling error: ${err.message}\n`);
+      log.error(`Polling error: ${err.message}`);
       await new Promise((r) => setTimeout(r, 5000));
       continue;
     }
 
     if (!result.ok) {
-      process.stderr.write(`Telegram API error: ${result.description || JSON.stringify(result)}\n`);
+      log.error(`Telegram API error: ${result.description || JSON.stringify(result)}`);
       await new Promise((r) => setTimeout(r, 5000));
       continue;
     }
@@ -1008,6 +1243,7 @@ async function main() {
       }
 
       const chatId = String(msg.chat.id);
+      const replyTo = msg.message_id;
       const text = msg.text;
       const from = msg.from?.username
         ? `@${msg.from.username}`
@@ -1015,22 +1251,25 @@ async function main() {
 
       // Enforce chat allowlist if configured
       if (allowedChatIds && !allowedChatIds.includes(chatId)) {
-        process.stderr.write(`[chat ${chatId}] ${from}: blocked (not in allowlist)\n`);
+        log.debug(`[chat ${chatId}] ${from}: blocked (not in allowlist)`);
         continue;
       }
 
       // Lock to the first chat that connects (single-user guard)
       if (lockedChatId === null) {
         lockedChatId = chatId;
-        process.stderr.write(`[chat ${chatId}] ${from}: locked to this chat\n`);
+        log.debug(`[chat ${chatId}] ${from}: locked to this chat`);
       } else if (lockedChatId !== chatId) {
-        process.stderr.write(`[chat ${chatId}] ${from}: blocked (locked to ${lockedChatId})\n`);
+        log.debug(`[chat ${chatId}] ${from}: blocked (locked to ${lockedChatId})`);
         continue;
       }
 
-      process.stderr.write(`[chat ${chatId}] ${from}: ${text}\n`);
+      log.debug(`[chat ${chatId}] ${from}: ${text}`);
       try { fs.writeFileSync(STARTUP_CHAT_FILE, String(chatId)); } catch (_) {}
 
+      // Build reply context if this message is a Telegram reply
+      const replyContext = quoteReply(msg);
+
       // Intercept /commands
       if (text.startsWith('/')) {
         const parts = text.slice(1).split(' ');
@@ -1041,7 +1280,7 @@ async function main() {
           try {
             await handler(token, chatId, cmdArgs, setServer, setActiveSession, serverBase);
           } catch (err) {
-            process.stderr.write(`Error handling /${cmd}: ${err.message}\n`);
+            log.error(`Error handling /${cmd}: ${err.message}`);
             try { await sendLongMessage(token, chatId, `Error: ${err.message}`); } catch (_) {}
           }
         } else {
@@ -1051,7 +1290,7 @@ async function main() {
         continue;
       }
 
-      // Non-command message — process in background
+      // 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.');
@@ -1059,14 +1298,14 @@ async function main() {
       }
       st.busy = true;
       const myTaskId = ++st.taskId;
-      process.stderr.write(`  → started background processing (task ${myTaskId})\n`);
-      processMessageAsync(chatId, text, serverBase, !!st.activeSessionId, st.activeSessionId, myTaskId);
+      log.debug(`  → started background processing (task ${myTaskId})`);
+      processMessageAsync(chatId, replyContext + text, serverBase, !!st.activeSessionId, st.activeSessionId, myTaskId, replyTo);
     }
   }
 }
 
 process.on('SIGINT', () => {
-  process.stderr.write('\ntgagentp stopped.\n');
+  log.info('tgagentp stopped.');
   process.exit(0);
 });