agentp 0.6.0 → 0.8.0

package/AGENTS.md

@@ -14,6 +14,13 @@
 - **`"type": "commonjs"`**, requires Node >= 18.
 - **Linux and macOS compatible.** All tools use portable Node.js APIs only.
 
+## Logging conventions (tgagentp)
+
+- **stdout** — informational messages (startup, discovery, session switches)
+- **stderr** — errors (always shown) + trace/debug (only with `--verbose` flag)
+- Default usage for clean console: `tgagentp 2>/dev/null`
+- The `log` helper object at the top of `bin/tgagentp` provides `log.info()`, `log.error()`, and `log.debug()`.
+
 ## `.ocmux.json`
 
 Runtime state file created by `bin/ocmux` (contains URL, log path, and window index). **Not in `.gitignore`** — avoid committing it.
@@ -42,7 +49,7 @@ Shared ocmux session discovery; used by both `bin/ocmux` and `bin/tgagentp`:
 
 - `readState(file)` — parses `.ocmux.json`, returns `null` on error
 - `statefileFor(dir)` — `path.join(dir, '.ocmux.json')`
-- `tuiPaneId(windowIndex)` — returns pane ID if TUI process (`node`) is running, `null` if dead
+- `tuiPaneId(windowIndex)` — returns pane ID of the TUI pane (pane index != 0), `null` if dead
 - `windowByDir(dir)` — returns window index by name match
 - `windowNameByIndex(idx)` — reverse: name from index
 - `activeWindowIndex()` — returns index of currently selected tmux window
@@ -95,10 +102,19 @@ These endpoints are consumed but not documented elsewhere in the repo:
 
 ### Pending
 
+- `--print-logs` flag for `ocmux serve`
+
+### In Progress
+
 *(none)*
 
 ### Done
 
+- Logging rebalance: stdout for info, stderr for errors/debug/trace, `--verbose` flag, `2>/dev/null` default usage
+- `/shutdown force` — refuses shutdown when busy unless `force` flag is given; goodbye message includes state
+- `/think [on|off|switch]` — toggle real-time forwarding of model thinking messages to the chat; `--think` CLI flag to start enabled
+- Event-driven permission handling (`POST /session/:id/prompt_async` + SSE listener + `/allow`, `/reject`, `/always` commands) — included in v0.7.0
+- TUI navigation on `/sessions switch` and `/sessions new` — `POST /tui/select-session` now works in opencode 1.15.13 (was: tried second, never reached)
 - /agents switch <name> — switch active agent on the active session
 - /sessions new [name] — create a new session, TUI follows via /session/:id/select
 - /sessions rename <name> — rename the current active session
@@ -106,8 +122,9 @@ These endpoints are consumed but not documented elsewhere in the repo:
 - Case-insensitive matching for all switch subcommands (/servers, /sessions, /agents)
 - Fix: /sessions filter includes sessions with directory (TUI sessions) + active session exception
 - Fix: /sessions now shows the active session even without agent set (exception in filter)
-- Fix: /sessions switch and /sessions new call selectSession (TUI navigation doesn't work — see With Issues)
+- Fix: /sessions switch and /sessions new call selectSession (TUI navigation didn't work in opencode < 1.15.x)
 - Fix: active session highlighted with ▶ bullet in session list
+- Fix: discover TUI session on startup and server switch via `discoverActiveSession()`
 - Message splitting (>4096 chars, breaks at newlines)
 - Fix: tuiPaneId detects 'bun' (opencode 1.15.x) in addition to 'node'
 - Fix: URL polling in ocmux doNew takes last match, not first (more robust with bun startup)
@@ -115,10 +132,6 @@ These endpoints are consumed but not documented elsewhere in the repo:
 - /cancel with true server-side SSE abort via cancelRef
 - /shutdown (--dev mode) with Telegram offset acknowledgment
 
-### With Issues
-
-- `/sessions switch` and `/sessions new` — `selectSession` tries `POST /session/:id/select` and `POST /tui/select-session` but the TUI pane doesn't navigate to the session. Message routing (via `activeSessionId` + `sendToSession`) works correctly in the background. This is a known limitation — the TUI must be navigated manually to see the conversation in the UI. The underlying opencode API may lack the needed TUI navigation endpoints.
-
 ### Verified
 
 - Password auth support (OPENCODE_SERVER_PASSWORD) for agentp, ocmux, tgagentp

package/CHANGELOG.md

@@ -8,6 +8,16 @@ All notable changes to this project will be documented in this file.
 - Extract shared OpenCode client logic into `lib/opencode.js`.
 - Add `tgagentp` — bridge a Telegram bot chat with an OpenCode TUI session.
 
+## [0.8.0] - 2026-06-03
+
+- Fix `/servers` crash: `serverBase is not defined` error.
+- Logging rebalance: stdout for info, stderr for errors/debug with `--verbose` flag (`2>/dev/null` for clean console).
+- `/shutdown force`: refuse shutdown when busy unless `force` flag given.
+- `/think [on|off|switch]`: toggle real-time forwarding of model thinking messages; `--think` CLI flag.
+- Reply quoting: when replying to a Telegram message, prepend quoted text with safe backtick fencing.
+- Reply chaining: answers use `reply_to_message_id` to appear as replies.
+- TUI navigation: `POST /tui/select-session` tried first (works in opencode 1.15.13).
+
 ## [0.1.0] - 2026-05-08
 
 - Initial release.

package/README.md

@@ -192,7 +192,8 @@ Non-text Telegram updates (photos, stickers, etc.) are silently ignored.
 | `/models` | List connected providers with model counts, context limits, and costs |
 | `/status` | Show current server path, URL, busy status, and active session |
 | `/cancel` | Cancel the current AI response for the active server |
-| `/shutdown` | (requires `--dev`) Stop tgagentp gracefully; acknowledge offset and exit |
+| `/think [on\|off\|switch]` | Toggle forwarding of model thinking messages to the chat |
+| `/shutdown [force]` | (requires `--dev`) Stop tgagentp; refuses if busy unless `force` is given |
 
 ### Per-server state
 
@@ -212,8 +213,27 @@ tgagentp
 
 - `--version`: show version
 - `--help`: show help message
+- `--verbose`: show detailed logs (errors, trace, debug) on stderr
+- `--think`: start with thinking messages enabled (default: off)
 - `--dev`: enable `/shutdown` command for remote restart (run via `while true; do tgagentp --dev; done`)
 
+### Logging
+
+Informational messages (startup, discovery, session switches) go to **stdout**. Errors, warnings, and trace/debug messages go to **stderr**. With `--verbose`, detailed
+trace/debug messages are also printed to stderr.
+
+For a clean console with only essential info:
+
+```bash
+tgagentp 2>/dev/null
+```
+
+To capture everything (info + errors) to a log file:
+
+```bash
+tgagentp 2>/var/log/tgagentp.log
+```
+
 ### Telemetry
 
 A startup greeting is sent to the last known chat on boot — includes /status-style server info. The chat ID is persisted at `/tmp/tgagentp-startup-chat`.

package/bin/tgagentp

@@ -4,7 +4,15 @@ 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, listAgents, listProviders } = require('../lib/opencode.js');
+const { sendText, listenForFinalAnswer, listSessions, createSession, updateSession, selectSession, sendToSession, sendToSessionAsync, respondToPermission, listenForSessionEvents, listAgents, listProviders } = require('../lib/opencode.js');
+
+// 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 { listServers, activateServer } = require('../lib/ocmux.js');
@@ -51,9 +59,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);
 }
 
@@ -161,12 +170,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`;
 }
 
 // ---------------------------------------------------------------------------
@@ -195,7 +224,8 @@ async function cmdHelp(token, chatId, args) {
     }
     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`');
@@ -224,8 +254,29 @@ async function cmdHelp(token, chatId, args) {
         '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' +
+        '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`, 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,
@@ -243,11 +294,13 @@ async function cmdHelp(token, chatId, args) {
     '`/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,
@@ -279,7 +332,7 @@ async function cmdServers(token, chatId, args, setServer) {
       return;
     }
     const target = matches[0];
-    const pending = setServer(target.url);
+    const pending = await setServer(target.url);
     activateServer(target.dir, target.index, target.url);
     let msg = `Switched to server: ${target.url} → ${target.dir}`;
     if (pending && pending.trim()) {
@@ -297,7 +350,11 @@ async function cmdServers(token, chatId, args, setServer) {
     await sendLongMessage(token, chatId, 'No servers running.');
     return;
   }
-  const lines = servers.map(s => `  ${s.url} → ${s.dir} (${s.status})`);
+  const activeUrl = normalizeUrl(serverBase);
+  const lines = servers.map(s => {
+    const bullet = normalizeUrl(s.url) === activeUrl ? '▶ ' : ' · ';
+    return bullet + `${s.url} → ${s.dir} (${s.status})`;
+  });
   await sendLongMessage(token, chatId, 'Active servers:\n' + lines.join('\n'));
 }
 
@@ -324,6 +381,21 @@ function sortedSessions(sessions, limit) {
     .slice(0, limit || 50);
 }
 
+// Find the most recently updated session and return its ID and name.
+// Returns null if no sessions exist or the server is unreachable.
+async function discoverActiveSession(server) {
+  try {
+    const sessions = await listSessions(server);
+    if (!sessions || sessions.length === 0) return null;
+    const sorted = sortedSessions(sessions, 1);
+    if (sorted.length === 0) return null;
+    const s = sorted[0];
+    return { id: s.id, name: sessionName(s) };
+  } catch {
+    return null;
+  }
+}
+
 async function cmdSessions(token, chatId, args, setServer, setActiveSession, server) {
   if (args.length > 0) {
     const sub = args[0].toLowerCase();
@@ -590,6 +662,74 @@ async function cmdModels(token, chatId, args, setServer, setActiveSession, serve
   }
 }
 
+const PERM_RESPONSE_HELP = ' No pending permission. Use `/status` to check the current state.';
+
+async function cmdAllow(token, chatId, args, setServer, setActiveSession, server) {
+  const st = getState(server);
+  if (!st.pendingPermission) {
+    await sendLongMessage(token, chatId, '/allow' + PERM_RESPONSE_HELP);
+    return;
+  }
+  const p = st.pendingPermission;
+  try {
+    await respondToPermission(p.server, p.sessionId, p.permissionId, 'once');
+    await sendLongMessage(token, chatId, '✅ Permission approved (once).');
+    log.debug(`  → /allow: ${p.type} ${p.pattern || ''}`);
+  } catch (err) {
+    await sendLongMessage(token, chatId, `Error: ${err.message}`);
+  }
+}
+
+async function cmdReject(token, chatId, args, setServer, setActiveSession, server) {
+  const st = getState(server);
+  if (!st.pendingPermission) {
+    await sendLongMessage(token, chatId, '/reject' + PERM_RESPONSE_HELP);
+    return;
+  }
+  const p = st.pendingPermission;
+  try {
+    await respondToPermission(p.server, p.sessionId, p.permissionId, 'reject');
+    await sendLongMessage(token, chatId, '⛔ Permission denied.');
+    log.debug(`  → /reject: ${p.type} ${p.pattern || ''}`);
+  } catch (err) {
+    await sendLongMessage(token, chatId, `Error: ${err.message}`);
+  }
+}
+
+async function cmdAlways(token, chatId, args, setServer, setActiveSession, server) {
+  const st = getState(server);
+  if (!st.pendingPermission) {
+    await sendLongMessage(token, chatId, '/always' + PERM_RESPONSE_HELP);
+    return;
+  }
+  const p = st.pendingPermission;
+  try {
+    await respondToPermission(p.server, p.sessionId, p.permissionId, 'always');
+    await sendLongMessage(token, chatId, '✅ Permission approved (always).');
+    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,
@@ -597,6 +737,10 @@ const COMMANDS = {
   'session': cmdSessions,
   'agents': cmdAgents,
   'models': cmdModels,
+  'think': cmdThink,
+  'allow': cmdAllow,
+  'reject': cmdReject,
+  'always': cmdAlways,
 };
 
 // --------------------------------------------------------------------------
@@ -605,7 +749,13 @@ const COMMANDS = {
 
 const serverState = {};
 function getState(url) {
-  return serverState[url] = serverState[url] || { busy: false, pendingResponse: null, activeSessionId: null, activeAgentName: null, taskId: 0 };
+  return serverState[url] = serverState[url] || { busy: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, thinkingEnabled: false };
+}
+
+function sessionLabel(st) {
+  if (st.activeSessionName) return '`' + st.activeSessionName + '`';
+  if (st.activeSessionId) return '`' + st.activeSessionId + '`';
+  return '*none (TUI+SSE)*';
 }
 
 // --------------------------------------------------------------------------
@@ -624,6 +774,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('');
@@ -631,9 +785,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)');
@@ -668,29 +824,59 @@ 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;
 
-  process.stderr.write('Waiting for Telegram messages... (Ctrl+C to stop)\n');
-
   getState(serverBase);
 
-  const setServer = (url) => {
+  log.info('Discovering server state...');
+  const [discovered, agents] = await Promise.all([
+    discoverActiveSession(serverBase),
+    listAgents(serverBase).catch(() => []),
+  ]);
+  if (discovered) {
+    getState(serverBase).activeSessionId = discovered.id;
+    getState(serverBase).activeSessionName = discovered.name;
+    log.info(`  → session: ${discovered.name || discovered.id}`);
+  }
+  const defaultAgent = agents.find(a => a.mode === 'primary') || agents[0];
+  if (defaultAgent) {
+    getState(serverBase).activeAgentName = defaultAgent.name;
+    log.info(`  → agent: ${defaultAgent.name}`);
+  }
+
+  log.info('Waiting for Telegram messages... (Ctrl+C to stop)');
+
+  const setServer = async (url) => {
     serverBase = url;
     getState(url);
-    process.stderr.write(`Switched to server: ${url}\n`);
+    log.info(`Switched to server: ${url}`);
+    const [discovered, agents] = await Promise.all([
+      discoverActiveSession(url),
+      listAgents(url).catch(() => []),
+    ]);
+    if (discovered) {
+      getState(url).activeSessionId = discovered.id;
+      getState(url).activeSessionName = discovered.name;
+      log.info(`  → session: ${discovered.name || discovered.id}`);
+    }
+    const defaultAgent = agents.find(a => a.mode === 'primary') || agents[0];
+    if (defaultAgent) {
+      getState(url).activeAgentName = defaultAgent.name;
+      log.info(`  → agent: ${defaultAgent.name}`);
+    }
     const p = getState(url).pendingResponse;
     if (p) {
       getState(url).pendingResponse = null;
@@ -701,10 +887,10 @@ 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 };
@@ -712,33 +898,97 @@ async function main() {
     try {
       let answer;
       if (useSession) {
-        answer = await sendToSession(url, sessionId, `[Telegram] ${text}`, st.activeAgentName);
+        // Event-driven flow: start SSE listener first, then send message async
+        const notifiedPerms = new Set();
+        let thinkingBuf = '';
+        const ssePromise = listenForSessionEvents(url, sessionId, {
+          onText: null,
+          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;');
+              sendLongMessage(token, chatId, html, replyTo)
+                .then(() => {})
+                .catch(() => {});
+              thinkingBuf = '';
+            }
+          },
+          onPermission: (perm) => {
+            const st2 = getState(url);
+            const permDump = JSON.stringify(perm);
+            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);
+              const toolStr = perm.permission || 'unspecified';
+              const patternArr = perm.patterns || (perm.pattern ? [perm.pattern] : []);
+              const patternStr = patternArr.join(', ');
+              const msg = '🔐 **Permission needed**\n'
+                + '**Tool:** `' + toolStr + '`\n'
+                + (patternStr ? '**Target:** `' + patternStr + '`\n' : '')
+                + (perm.title ? '**Detail:** ' + perm.title + '\n' : '')
+                + 'Use `/allow` to approve once, `/always` to always allow, or `/reject` to deny.';
+              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 {
+              log.debug(`  → permission ${perm.id} already notified, updating pendingPermission only`);
+            }
+          },
+          onPermissionReplied: () => {
+            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;
+        // 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 = '';
+        }
       } 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) {
       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 (!isCancelled()) {
         getState(url).busy = false;
@@ -760,7 +1010,7 @@ async function main() {
       st._cancelRef.current = null;
     }
     await sendLongMessage(token, chatId, '✅ Cancelled.');
-    process.stderr.write(`  → /cancel on ${serverBase}\n`);
+    log.debug(`  → /cancel on ${serverBase}`);
   }
 
   const cmdStatus = async (token, chatId) => {
@@ -771,18 +1021,27 @@ async function main() {
     if (dir) lines.push('  • **Path:** `' + dir + '`');
     lines.push('  • **URL:** `' + serverBase + '`');
     lines.push('  • **Status:** ' + busyInfo);
-    lines.push('**Session:** ' + (st.activeSessionId ? '`' + st.activeSessionId + '`' : '*none (TUI+SSE)*'));
+    lines.push('**Session:** ' + sessionLabel(st));
     lines.push('**Agent:** ' + (st.activeAgentName ? '`' + st.activeAgentName + '`' : '*default*'));
     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);
   };
 
@@ -794,12 +1053,14 @@ async function main() {
   // Startup greeting to last-known chat
   const savedChatId = (() => { try { return fs.readFileSync(STARTUP_CHAT_FILE, 'utf8').trim(); } catch { return null; } })();
   if (savedChatId) {
+    const st = getState(serverBase);
     const dir = serverDir(serverBase);
     const lines = ['✅ Bot started.', '**Server:**'];
     if (dir) lines.push('  • **Path:** `' + dir + '`');
     lines.push('  • **URL:** `' + serverBase + '`');
     lines.push('  • **Status:** ✅ idle');
-    lines.push('**Session:** *none (TUI+SSE)*');
+    lines.push('**Session:** ' + sessionLabel(st));
+    lines.push('**Agent:** ' + (st.activeAgentName ? '`' + st.activeAgentName + '`' : '*default*'));
     try { await sendLongMessage(token, savedChatId, lines.join('\n')); } catch (_) {}
     try { fs.unlinkSync(STARTUP_CHAT_FILE); } catch (_) {}
   }
@@ -810,13 +1071,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;
     }
@@ -831,6 +1092,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}`
@@ -838,22 +1100,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(' ');
@@ -864,7 +1129,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 {
@@ -882,14 +1147,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);
 });
 

package/lib/opencode.js

@@ -222,13 +222,16 @@ async function updateSession(server, sessionId, title) {
 async function selectSession(server, sessionId) {
   const encoded = encodeURIComponent(sessionId);
   const attempts = [
-    { url: `${server}/session/${encoded}/select`, body: '{}' },
     { url: `${server}/tui/select-session`, body: JSON.stringify({ sessionID: sessionId }) },
+    { url: `${server}/session/${encoded}/select`, body: '{}' },
   ];
   for (const { url, body } of attempts) {
     try {
-      await makeRequest(buildJsonRequest(url, 'POST', body), body);
-      return;
+      const { status } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
+      // /session/:id/select returns 200 with HTML even for bad IDs (TUI page),
+      // but doesn't actually navigate. Only consider it a success if the
+      // response looks like JSON (i.e. not HTML).
+      if (status === 200) return;
     } catch {
       // try next approach
     }
@@ -251,6 +254,161 @@ async function listProviders(server) {
   return JSON.parse(body);
 }
 
+// Send a message asynchronously (non-blocking). Returns 204 No Content.
+async function sendToSessionAsync(server, sessionId, text, agent) {
+  const url = `${server}/session/${encodeURIComponent(sessionId)}/prompt_async`;
+  const bodyObj = { parts: [{ type: 'text', text }] };
+  if (agent) bodyObj.agent = agent;
+  const body = JSON.stringify(bodyObj);
+  const { status } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
+  if (status !== 204) throw new Error(`Failed to send async message: ${status}`);
+}
+
+// Respond to a permission request.
+async function respondToPermission(server, sessionId, permissionId, response, remember) {
+  const url = `${server}/session/${encodeURIComponent(sessionId)}/permissions/${encodeURIComponent(permissionId)}`;
+  const bodyObj = { response };
+  if (remember) bodyObj.remember = true;
+  const body = JSON.stringify(bodyObj);
+  const { status } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
+  if (status !== 200) throw new Error(`Failed to respond to permission: ${status}`);
+}
+
+// Listen for session events via SSE, collecting assistant text parts and detecting
+// permission requests. Resolves with the full collected text when the session goes idle.
+// callbacks: { onText(chunk), onPermission(permission) }
+// cancelRef — allows aborting the SSE stream via req.destroy()
+function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
+  process.stderr.write(`  [SSE] connecting to ${server}/event for session ${sessionId}\n`);
+  return new Promise((resolve, reject) => {
+    const url = `${server}/event`;
+    const parsed = new URL(url);
+
+    const req = http.request({
+      hostname: parsed.hostname,
+      port: parsed.port,
+      path: parsed.pathname,
+      method: 'GET',
+      headers: { 'Accept': 'text/event-stream', ...getAuthHeaders() }
+    }, (res) => {
+      if (res.statusCode === 401) {
+        res.resume();
+        reject(new Error('OpenCode server authentication failed. Set OPENCODE_SERVER_PASSWORD to match the server password.'));
+        return;
+      }
+      process.stderr.write(`  [SSE] connected for session ${sessionId}\n`);
+      let buffer = '';
+      const userMessageIDs = new Set();
+      let collected = '';
+
+      res.on('data', (chunk) => {
+        buffer += chunk.toString();
+        while (buffer.includes('\n\n')) {
+          const eventEnd = buffer.indexOf('\n\n');
+          const eventData = buffer.slice(0, eventEnd);
+          buffer = buffer.slice(eventEnd + 2);
+
+          const lines = eventData.split('\n');
+          let jsonStr = '';
+          for (const line of lines) {
+            if (line.startsWith('data: ')) jsonStr += line.slice(6);
+          }
+          if (!jsonStr.trim()) continue;
+
+          try {
+            const event = JSON.parse(jsonStr);
+            const props = event.properties || {};
+
+            if (event.type === 'session.status') {
+              process.stderr.write(`  [SSE] session.status: type=${props.status?.type} status=${JSON.stringify(props.status)}\n`);
+            } else {
+              process.stderr.write(`  [SSE] event type=${event.type} sessionID=${props.sessionID} waitSession=${sessionId}\n`);
+            }
+
+            // Filter by sessionID when the event carries one
+            if (props.sessionID && props.sessionID !== sessionId) continue;
+
+            if (event.type === 'message.updated' && props.info?.role === 'user') {
+              userMessageIDs.add(props.info.id);
+              continue;
+            }
+
+            if (event.type === 'permission.asked') {
+              const permStr = JSON.stringify(props);
+              process.stderr.write(`  [SSE] PERMISSION ASKED: ${permStr}\n`);
+              if (callbacks.onPermission) {
+                process.stderr.write(`  [SSE] calling onPermission callback\n`);
+                callbacks.onPermission(props);
+              } else {
+                process.stderr.write(`  [SSE] WARNING: no onPermission callback registered\n`);
+              }
+              continue;
+            }
+
+            if (event.type === 'permission.replied') {
+              process.stderr.write(`  [SSE] PERMISSION REPLIED: type=${props.type}\n`);
+              if (callbacks.onPermissionReplied) {
+                callbacks.onPermissionReplied(props);
+              }
+              continue;
+            }
+
+            // Completion signals
+            if (event.type === 'session.idle') {
+              cleanup();
+              req.destroy();
+              res.destroy();
+              resolve(collected);
+              return;
+            }
+            if (event.type === 'session.status' && props.status?.type === 'idle') {
+              cleanup();
+              req.destroy();
+              res.destroy();
+              resolve(collected);
+              return;
+            }
+
+            const part = props.part;
+            if (!part) continue;
+
+            // Skip echoed user input
+            if (part.messageID && userMessageIDs.has(part.messageID)) continue;
+
+            if (part.type === 'text' && part.text != null && part.text !== '') {
+              if (callbacks.onText) callbacks.onText(part.text);
+              collected += part.text;
+            }
+
+            if ((part.type === 'reasoning' || part.type === 'thinking') && part.text != null && part.text !== '') {
+              if (callbacks.onThinking) callbacks.onThinking(part.text);
+            }
+          } catch (e) {
+            // Malformed SSE event — skip
+          }
+        }
+      });
+
+      res.on('end', () => {
+        cleanup();
+        resolve(collected);
+      });
+    });
+
+    const cleanup = () => {
+      if (cancelRef) cancelRef.current = null;
+    };
+
+    req.on('error', (err) => {
+      cleanup();
+      reject(err);
+    });
+
+    if (cancelRef) cancelRef.current = req;
+    req.end();
+  });
+}
+
 module.exports = {
   getAuthHeaders,
   makeRequest,
@@ -265,6 +423,9 @@ module.exports = {
   updateSession,
   selectSession,
   sendToSession,
+  sendToSessionAsync,
+  respondToPermission,
+  listenForSessionEvents,
   listAgents,
   listProviders,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentp",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Pipe prompts into a running OpenCode TUI session and stream the final answer",
   "bin": {
     "agentp": "bin/agentp",