agentp 0.8.0 → 0.10.0

package/AGENTS.md

@@ -2,7 +2,7 @@
 
 ## Three binaries, all registered
 
-- `bin/agentp` (Node.js) — registered in `package.json` `"bin"` — pipes stdin → opencode TUI
+- `bin/agentp` (Node.js) — registered in `package.json` `"bin"` — pipes stdin → opencode session
 - `bin/ocmux` (Node.js) — registered in `package.json` `"bin"` — manages opencode tmux sessions
 - `bin/tgagentp` (Node.js) — registered in `package.json` `"bin"` — bridges Telegram bot ↔ opencode TUI
 
@@ -37,11 +37,14 @@ Extracted from `bin/agentp`; used by both `agentp` and `tgagentp`:
 - `listenForFinalAnswer(server, onText?, cancelRef?)` — SSE event stream listener; `cancelRef` allows true server-side abort via `req.destroy()`
 - `listSessions(server, directory?)` — `GET /session`; returns parsed JSON array; optional `?directory=` filter
 - `createSession(server, title?)` — `POST /session`; returns the created `Session` object; optional `title`
-- `updateSession(server, sessionId, title)` — `PATCH /session/:id`; returns the updated `Session` object
-- `sendToSession(server, sessionId, text, agent?)` — `POST /session/:id/message`; returns concatenated text parts from response; optional `agent` to handle the message
+- `updateSession(server, sessionId, title, agent?)` — `PATCH /session/:id`; returns the updated `Session` object; optional `agent` to set the session's agent
+- `sendToSession(server, sessionId, text, agent?, cancelRef?)` — `POST /session/:id/message`; returns concatenated text parts from response; optional `agent`, optional `cancelRef` for aborting the request
+- `sendToSessionAsync(server, sessionId, text, agent?)` — `POST /session/:id/prompt_async`; returns 204; non-blocking, answer delivered via SSE
+- `respondToPermission(server, sessionId, permissionId, response)` — `POST /session/:id/permissions/:id`
 - `selectSession(server, sessionId)` — `POST /session/:id/select`; tells the TUI to navigate to the given session (silently ignores 404 if the endpoint isn't available in older opencode versions)
 - `listAgents(server)` — `GET /agent`; returns parsed JSON array of agent objects
 - `listProviders(server)` — `GET /provider`; returns parsed JSON array of provider objects
+- `listenForSessionEvents(server, sessionId, callbacks, cancelRef?)` — SSE listener for session events (text parts, permissions, thinking, session.idle)
 
 ## Shared `lib/ocmux.js`
 
@@ -67,17 +70,30 @@ These endpoints are consumed but not documented elsewhere in the repo:
 - `GET /event` (SSE stream)
 - `GET /session` — list sessions (optional `?directory=` filter)
 - `POST /session` — create a new session (optional `{ title? }` body)
-- `PATCH /session/:id` — update session properties (`{ title }`)
+- `PATCH /session/:id` — update session properties (`{ title }`, optional `{ agent }`)
 - `POST /session/:id/select` — tell the TUI to navigate to a session (only with TUI attached)
 - `POST /session/:id/message` — send message to session (returns parts synchronously; optional `agent` field)
+- `POST /session/:id/prompt_async` — send message to session (returns 204; answer via SSE)
 - `GET /agent` — list available agents
 - `GET /provider` — list connected providers/models
 
+## Agentp gateway (tgagentp ↔ agentp interop)
+
+- tgagentp starts a tiny HTTP server (POST /send) on `127.0.0.1`, port from `TGAGENTP_PORT` (default 0 = random).
+- Port is written to `/tmp/tgagentp-port` for agentp discovery.
+- Validates `Authorization` header against `OPENCODE_SERVER_PASSWORD`.
+- agentp `--tg` reads the port file and POSTs `{ text, server }` to the gateway.
+- Messages for the active server are delivered immediately; others are queued per-server.
+- Debounced Telegram notification (configurable via `TGAGENTP_DEBOUNCE_MS`, default 5000ms).
+- Queued messages are flushed on `/servers switch`.
+- Gateway response includes `{ buffered: [...] }` — recorded conversation messages (see `/record` command) flushed on each POST.
+- agentp `--qa` prepends the buffered context to stdout; `--flush` bypasses prepending but still triggers the flush.
+
 ## OpenCode tmux session model (ocmux)
 
 - Single tmux session named `"Opencode"`
 - Windows named by full project directory path
-- Server pane runs `opencode serve --port 0` (via send-keys → interactive shell for env var support), TUI pane runs `opencode attach --continue`
+- Server pane runs `opencode serve --port 0` (via send-keys → interactive shell for env var support), TUI pane runs `opencode attach --continue`; `ocmux serve --print-logs` adds `--print-logs` to the serve command
 - Log file per project: `/tmp/opencode-serve-<hashDir(dir)>.log` — captured via `tee`, read by ocmux polling loop
 - Per-project `.ocmux.json` with upward directory search (git-like)
 - Auto-restarts dead TUI panes on switch (respawn-pane or split-window)
@@ -89,10 +105,10 @@ These endpoints are consumed but not documented elsewhere in the repo:
 |---|---|---|
 | `npm link` | local dev install |
 | `npm install -g .` | alternative local install |
-| `agentp [--qa] [port]` | pipe stdin → opencode TUI, stream answer to stdout |
+| `agentp [--qa] [--tg|--no-tg] [--flush] [--getLast n] [port]` | pipe stdin → opencode session, stream answer to stdout (uses session API); `--tg` forwards answer to Telegram; `--flush` clears recorded buffer; `--getLast n` retrieves last n answers |
 | `tgagentp [port]` | bridge Telegram bot ↔ opencode TUI (needs `TELEGRAM_BOT_TOKEN`) |
 | `tgagentp --dev` | enable `/shutdown` command for remote restart |
-| `ocmux serve [dir]` | start opencode serve in a tmux window (primary verb) |
+| `ocmux serve [--print-logs] [dir]` | start opencode serve in a tmux window (primary verb) |
 | `ocmux new [dir]` | alias for `serve` (backwards compat, to be removed in 1.0) |
 | `ocmux kill [dir]` | kill server + tmux window |
 | `ocmux list [-l]` | list running servers |
@@ -102,7 +118,7 @@ These endpoints are consumed but not documented elsewhere in the repo:
 
 ### Pending
 
-- `--print-logs` flag for `ocmux serve`
+*(none)*
 
 ### In Progress
 
@@ -110,12 +126,23 @@ These endpoints are consumed but not documented elsewhere in the repo:
 
 ### Done
 
+- `/queue` command: queue messages when server is busy, auto-sent after current task finishes preserves replyTo chain — 0.10.0
+- `agentp --getLast n` — retrieve last n answers from session history — 0.10.0
+- `/record` command with ring buffer (100 msgs / 100KB), gateway returns `{ buffered }`, agentp `--qa` prepends recorded context, `--flush` flushes without prepending — 0.10.0
+- agentp `--qa` full context forwarding to Telegram (rulers, prompt, answer) — 0.9.0
+- agentp resilience: 5s HTTP timeout, pre-send gate check, post-send warning (not hard error) for `--tg`; auto mode silently degrades — 0.9.0
+- tgagentp: `lockedChatId` set at startup to fix race condition with agentp gateway — 0.9.0
+- tgagentp: server error handler + try-catch in gateway handler (no crash on socket errors) — 0.9.0
+- agentp `--tg`/`--no-tg` — gateway forwards answer to Telegram via tgagentp HTTP server; per-server queue with debounced notifications; auto-flush on server switch
+- agentp session API migration — uses `POST /session/:id/message` instead of TUI endpoints
+- ocmux `--print-logs` flag — pass-through to `opencode serve --print-logs` (prints server logs to stderr in the server pane)
+- /agents lists only primary agents with ▶ active marker
+- /agents switch calls `updateSession(agent)` to persist agent on session + `selectSession` to refresh TUI
 - 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
 - Merge /session into /sessions (keep /session as alias)

package/CHANGELOG.md

@@ -2,11 +2,23 @@
 
 All notable changes to this project will be documented in this file.
 
-## [Unreleased]
+## [0.10.0] - 2026-06-04
 
-- Rename package and CLI command from `aprompt` to `agentp`.
-- Extract shared OpenCode client logic into `lib/opencode.js`.
-- Add `tgagentp` — bridge a Telegram bot chat with an OpenCode TUI session.
+- `/queue` command: queue messages when server is busy, auto-sent after current task finishes, preserves replyTo chain.
+- `/record` command with ring buffer (100 msgs / 100KB), `/record stop` to clear; gateway returns `{ buffered }` JSON.
+- agentp `--flush`: flush tgagentp's recorded buffer without prepending to stdout.
+- agentp `--getLast n`: retrieve last n assistant answers from session history.
+- agentp `--qa` prepends recorded Telegram context (with rulers) to stdout.
+- `getSession()` in lib/opencode: `GET /session/:id` with fallback to session list.
+- `makeRequest` optional timeout parameter (used only for getSession; all other calls wait indefinitely).
+- Minimum 3-backtick code fence for reply quoting.
+
+## [0.9.0] - 2026-06-04
+
+- agentp `--tg`/`--no-tg` flags: gateway forwards answer to Telegram; auto mode silently degrades.
+- Agentp resilience: 5s HTTP timeout, pre-send gate check, post-send warning.
+- Full `--qa` output (rulers + prompt + answer) forwarded to Telegram.
+- Rulers changed from `—` to `─`, shortened to 17 chars.
 
 ## [0.8.0] - 2026-06-03
 

package/README.md

@@ -53,9 +53,16 @@ agentp [options] [url]
 Options:
 
 - `--qa`: print the original prompt and answer with labels (useful when used as a filter)
+- `--tg`: forward the answer to Telegram via tgagentp gateway (error if unreachable)
+- `--no-tg`: do not forward to Telegram
+- `--flush`: flush tgagentp's recorded buffer without prepending it to output
+- `--getLast <n>`: retrieve last n assistant answers from session history
 - `--version`: show version
 - `--help`: show help message
 
+By default, `--qa` auto-detects tgagentp (silently degrades if unavailable); standalone mode implies `--no-tg`.
+With `--tg`, errors if tgagentp is unavailable.
+
 Arguments:
 
 - `url`: OpenCode TUI server URL or port number (defaults to `4096`). Examples: `4096`, `http://localhost:4096`, `http://192.168.1.50:4096`
@@ -111,6 +118,34 @@ From Vim/Neovim, send the current visual selection and keep the prompt with the
 :'<,'>!agentp --qa
 ```
 
+From Vim/Neovim, forward the answer to your Telegram:
+
+```vim
+:'<,'>!agentp --qa --tg
+```
+
+(Works as long as `tgagentp` is running. The answer appears both in the editor
+and in your Telegram chat.)
+
+From Vim/Neovim, flush the recorded buffer without prepending context:
+
+```vim
+:'<,'>!agentp --qa --flush
+```
+
+Useful when you've finished a conversation thread and want to reset the recorded
+context for a new topic.
+
+Retrieve the last 3 assistant answers from session history:
+
+```bash
+agentp --getLast 3
+```
+
+Useful to grab recent answers without sending a new prompt.
+
+## ocmux
+
 ## ocmux
 
 Manage OpenCode server + TUI in tmux for project directories.
@@ -123,9 +158,10 @@ Without arguments, searches upward from `<directory>` (default: `$PWD`) for `.oc
 
 Subcommands:
 
-- **`serve [--git|--GIT] [dir]`** — Create a server in `dir` (default: `$PWD`) and attach a TUI pane. Aliased as `new` for backwards compatibility (to be removed in 1.0). Errors if one already exists there. Warns if a parent directory already has a server.
+- **`serve [--git|--GIT] [--print-logs] [dir]`** — Create a server in `dir` (default: `$PWD`) and attach a TUI pane. Aliased as `new` for backwards compatibility (to be removed in 1.0). Errors if one already exists there. Warns if a parent directory already has a server.
   - `--git` resolves `dir` to the nearest parent with a `.git` entry (file or dir); errors if none is found.
   - `--GIT` resolves `dir` to the nearest parent with a `.git` directory only; errors if none is found.
+  - `--print-logs` passes `--print-logs` to `opencode serve`, which prints server logs to stderr in the server tmux pane.
 - **`kill [dir]`** — Kill the server found upward from `dir`. Removes its tmux window and state file.
 - **`list`** — List all running servers with their directories, URLs, and status.
 
@@ -153,11 +189,19 @@ Notes:
 
 ## How agentp Works
 
-1. Clears the current TUI prompt input.
-2. Appends each line from stdin to the TUI prompt.
-3. Submits the prompt.
-4. Listens to the event stream and prints assistant text parts.
-5. Stops when the session reaches idle state.
+1. Reads all stdin into a single prompt string.
+2. Finds the most recently updated session, or creates one named `agentp`.
+3. Sends the prompt via the session API (`POST /session/:id/message`).
+4. Prints the assistant answer to stdout.
+5. With `--tg` (or by default when `--qa` is given), forwards the answer to Telegram
+   via the agentp gateway. The answer appears in your Telegram chat as if tgagentp
+   itself had processed the request.
+6. If tgagentp's [/record](#tgagentp) feature was active, the gateway response includes
+   the recorded conversation buffer. In `--qa` mode, agentp prepends this buffer (with
+   rulers) to its stdout so OpenCode receives the full Telegram context. Use `--flush`
+   to clear the buffer without prepending.
+
+The session API ensures the request is processed even when no TUI is attached, and returns the full answer in a single HTTP response.
 
 Operational hint:
 
@@ -183,16 +227,22 @@ Non-text Telegram updates (photos, stickers, etc.) are silently ignored.
 
 | Command | Action |
 |---|---|
-| `/help [topic]` | Show general help or help for a topic (`servers`, `sessions`, `agents`, `models`) |
+| `/help [topic]` | Show general help or help for a topic (`servers`, `sessions`, `agents`, `models`, `allow`, `think`, `record`, `queue`) |
 | `/servers` | List all running ocmux-served projects with URL + status (✅ idle / ⏳ busy) |
 | `/servers switch <name>` | Switch active server; matches by full path, basename, or substring |
 | `/sessions` | List recent sessions for the current server (max 50, with date headings) |
 | `/sessions switch <number\|name>` | Switch active session by position or partial name match |
-| `/agents` | List available agents (name, mode, model, description) |
+| `/agents` | List primary agents (▶ marker for the active one) |
+| `/agents switch <name>` | Switch active agent — persists on session and refreshes TUI |
 | `/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 |
 | `/think [on\|off\|switch]` | Toggle forwarding of model thinking messages to the chat |
+| `/record [stop]` | Toggle recording of Telegram conversation for agentp context; `/record stop` clears and stops |
+| `/queue <message>` | Queue a message when the server is busy; auto-sent when current task finishes |
+| `/allow` | Approve a permission request once |
+| `/reject` | Deny a permission request |
+| `/always` | Approve and remember for the session |
 | `/shutdown [force]` | (requires `--dev`) Stop tgagentp; refuses if busy unless `force` is given |
 
 ### Per-server state
@@ -217,6 +267,18 @@ tgagentp
 - `--think`: start with thinking messages enabled (default: off)
 - `--dev`: enable `/shutdown` command for remote restart (run via `while true; do tgagentp --dev; done`)
 
+### Agentp gateway
+
+tgagentp starts a tiny HTTP server on `127.0.0.1` that accepts `POST /send` requests from `agentp --tg`. This enables cross-tool interoperability: answers obtained through `agentp` (from scripts, editors, or pipes) are forwarded to your Telegram chat.
+
+- Port is randomly assigned by default; overridable via `TGAGENTP_PORT`.
+- Port is written to `/tmp/tgagentp-port` for agentp discovery.
+- Authentication reuses `OPENCODE_SERVER_PASSWORD`.
+- Messages for the active server are delivered immediately.
+- Messages for non-active servers are queued and delivered on `/servers switch`.
+- Debounced Telegram notification on queue (configurable via `TGAGENTP_DEBOUNCE_MS`).
+- When [/record](#tgagentp) is active, the gateway response includes the recorded conversation buffer. `agentp --qa` prepends this buffer (with rulers) to its stdout so the full Telegram context is available to OpenCode. Use `agentp --qa --flush` to flush the buffer without prepending.
+
 ### Logging
 
 Informational messages (startup, discovery, session switches) go to **stdout**. Errors, warnings, and trace/debug messages go to **stderr**. With `--verbose`, detailed
@@ -243,9 +305,11 @@ A startup greeting is sent to the last known chat on boot — includes /status-s
 | Variable | Description |
 |---|---|
 | `TELEGRAM_BOT_TOKEN` | **Required.** Telegram bot token from @BotFather. |
-| `OPENCODE_SERVER_PASSWORD` | Optional. OpenCode server HTTP Basic Auth password. |
+| `OPENCODE_SERVER_PASSWORD` | Optional. OpenCode server HTTP Basic Auth password (also used for agentp gateway auth). |
 | `OPENCODE_SERVER_USERNAME` | Optional. OpenCode server username (default: `opencode`). |
 | `TGAGENTP_ALLOWED_CHAT_IDS` | Optional. Comma-separated Telegram chat IDs that are allowed to use the bot. |
+| `TGAGENTP_PORT` | Optional. Agentp gateway listen port (default: `0` = random). |
+| `TGAGENTP_DEBOUNCE_MS` | Optional. Debounce interval for queued-message notifications (default: `5000`). |
 
 ## License
 

package/bin/agentp

@@ -1,39 +1,83 @@
 #!/usr/bin/env node
 
+const http = require('http');
+const fs = require('fs');
 const readline = require('readline');
 const { version } = require('../package.json');
 const {
-  clearPrompt,
-  appendPrompt,
-  submitPrompt,
-  listenForFinalAnswer,
+  sendToSession,
+  listSessions,
+  createSession,
+  getSession,
 } = require('../lib/opencode');
 
-async function sendPrompt(server) {
-  let promptText = '';
+const TGAGENTP_PORT_FILE = '/tmp/tgagentp-port';
 
-  await clearPrompt(server);
+function notifyAgentpGateway(port, server, text) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({ text, server });
+    const options = {
+      hostname: '127.0.0.1',
+      port,
+      path: '/send',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+    };
+    const password = process.env.OPENCODE_SERVER_PASSWORD;
+    if (password) {
+      const username = process.env.OPENCODE_SERVER_USERNAME || 'opencode';
+      options.headers['Authorization'] = 'Basic ' +
+        Buffer.from(`${username}:${password}`).toString('base64');
+    }
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode === 200) {
+          try {
+            const result = JSON.parse(data);
+            resolve(result.buffered || []);
+          } catch {
+            resolve([]);
+          }
+        } else {
+          reject(new Error(`status ${res.statusCode}: ${data}`));
+        }
+      });
+    });
+    req.setTimeout(5000, () => {
+      req.destroy();
+      reject(new Error('Connection timed out'));
+    });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
 
+async function readAllStdin() {
+  let text = '';
   const rl = readline.createInterface({ input: process.stdin });
-
   for await (const line of rl) {
-    const promptLine = line + '\n';
-    promptText += promptLine;
-    await appendPrompt(server, promptLine);
+    text += line + '\n';
   }
-
   rl.close();
-  await submitPrompt(server);
-  return promptText;
+  return text;
 }
 
-const HUMAN_ROW = '👤: ￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣\n'
-const AGENT_ROW = '🤖: ￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣\n'
-const FINAL_ROW = '￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣\n';
+const HUMAN_ROW = '👤: —————————————————\n'
+const AGENT_ROW = '🤖: —————————————————\n'
+const FINAL_ROW = '    —————————————————\n';
 
 async function main() {
   let serverBase = 'http://localhost:4096';
   let qaMode = false;
+  let flushMode = false;
+  // tgMode: false = disabled, 'auto' = auto-detect, true = explicit --tg
+  let tgMode = null;
 
   const args = process.argv.slice(2);
   for (let i = 0; i < args.length; i++) {
@@ -43,27 +87,94 @@ async function main() {
     } else if (args[i] === '--help') {
       console.error('Usage: agentp [options] [url]');
       console.error('');
-      console.error('Pipe prompt text to an OpenCode TUI session and stream the assistant response to stdout.');
+      console.error('Pipe prompt text to an OpenCode session and get the assistant response on stdout.');
       console.error('');
       console.error('Options:');
       console.error('  --version  Show version');
       console.error('  --qa       Print the original prompt and answer with labels (useful as a filter)');
+      console.error('  --tg       Forward the answer to Telegram via agentp gateway (error if unavailable)');
+      console.error('  --no-tg    Do not forward to Telegram');
+      console.error('  --flush    Flush tgagentp\'s recorded buffer without prepending it to output');
+      console.error('  --getLast  Retrieve last N assistant answers from session history');
       console.error('  --help     Show this help message');
       console.error('');
+      console.error('By default, --qa auto-detects tgagentp; standalone mode implies --no-tg.');
+      console.error('--tg: error if tgagentp is unavailable; auto mode: silently degrade.');
+      console.error('');
       console.error('Arguments:');
-      console.error('  url        OpenCode TUI server URL or port number (default: 4096)');
+      console.error('  url        OpenCode server URL or port number (default: 4096)');
       console.error('             Examples: 4096, http://localhost:4096, http://192.168.1.50:4096');
       console.error('');
-      console.error('See also: ocmux -- manage OpenCode tmux sessions (ocmux --help)');
+      console.error('See also: tgagentp -- Telegram bridge (tgagentp --help), ocmux -- manage OpenCode tmux sessions (ocmux --help)');
       console.error('');
       console.error('Examples:');
       console.error('  printf "Summarize this file" | agentp');
       console.error('  cat prompt.txt | agentp 4096');
       console.error('  # Vim/Neovim filter, preserving prompt + answer:');
       console.error("  :'<,'>!agentp --qa");
+      console.error('  # Retrieve last 3 assistant answers:');
+      console.error('  agentp --getLast 3');
+      console.error('  agentp --getLast 1 4096');
       process.exit(0);
     } else if (args[i] === '--qa') {
       qaMode = true;
+    } else if (args[i] === '--flush') {
+      flushMode = true;
+    } else if (args[i] === '--getLast') {
+      i++;
+      const nStr = args[i];
+      if (!nStr || !/^\d+$/.test(nStr)) {
+        console.error('Error: --getLast requires a number (e.g. --getLast 5)');
+        process.exit(1);
+      }
+      const n = parseInt(nStr, 10);
+      try {
+        const sessions = await listSessions(serverBase);
+        if (!sessions || sessions.length === 0) {
+          console.error('No sessions found.');
+          process.exit(1);
+        }
+        const sorted = sessions
+          .filter(s => s.time && s.time.updated)
+          .sort((a, b) => b.time.updated - a.time.updated);
+        // Try to extract messages; getSession may return data with
+        // messages, or the sessions list may already contain them
+        let rawMessages = [];
+        try {
+          const session = await getSession(serverBase, sorted[0].id);
+          rawMessages = session.messages || session.history || session.conversation || [];
+        } catch {
+          // If the dedicated endpoint fails, the list data may have messages
+          rawMessages = sorted[0].messages || sorted[0].history || sorted[0].conversation || [];
+        }
+        if (rawMessages.length === 0) {
+          console.error('No message history available for the most recent session.');
+          console.error('The OpenCode server may not expose message history via the HTTP API.');
+          process.exit(1);
+        }
+        const assistantTexts = rawMessages
+          .filter(m => m.role === 'assistant')
+          .map(m => {
+            if (m.parts) return m.parts.filter(p => p.type === 'text').map(p => p.text).join('');
+            return m.content || m.text || '';
+          })
+          .filter(t => t.trim());
+        if (assistantTexts.length === 0) {
+          console.error('No assistant answers found in session history.');
+          process.exit(1);
+        }
+        const lastN = assistantTexts.slice(-n);
+        process.stdout.write(lastN.join('\n'));
+        if (lastN.length > 0 && !lastN[lastN.length - 1].endsWith('\n')) process.stdout.write('\n');
+      } catch (err) {
+        console.error('Error retrieving session history:', err.message);
+        process.exit(1);
+      }
+      return;
+    } else if (args[i] === '--tg') {
+      tgMode = true;
+    } else if (args[i] === '--no-tg') {
+      tgMode = false;
     } else if (args[i].includes('://')) {
       serverBase = args[i].replace(/\/+$/, '');
     } else if (/^\d+$/.test(args[i])) {
@@ -71,20 +182,102 @@ async function main() {
     }
   }
 
-  const promptText = await sendPrompt(serverBase);
+  // Resolve default: --qa → auto-detect, standalone → disabled
+  if (tgMode === null) {
+    tgMode = qaMode ? 'auto' : false;
+  }
+
+  // Pre-send: probe tgagentp gateway if enabled
+  let tgPort = null;
+  if (tgMode) {
+    try {
+      tgPort = fs.readFileSync(TGAGENTP_PORT_FILE, 'utf8').trim();
+      if (!tgPort || !/^\d+$/.test(tgPort)) tgPort = null;
+    } catch {
+      tgPort = null;
+    }
+    if (!tgPort && tgMode === true) {
+      console.error('Error: tgagentp gateway not found. Is tgagentp running?');
+      process.exit(1);
+    }
+    // auto mode: tgPort stays null → silently skip tgagentp
+  }
+
+  const promptText = await readAllStdin();
+
+  // Find most recent session or create one
+  let sessions;
+  try {
+    sessions = await listSessions(serverBase);
+  } catch (err) {
+    console.error('Error connecting to server:', err.message);
+    process.exit(1);
+  }
+
+  let sessionId = null;
+  if (sessions && sessions.length > 0) {
+    const sorted = sessions
+      .filter(s => s.time && s.time.updated)
+      .sort((a, b) => b.time.updated - a.time.updated);
+    if (sorted.length > 0) sessionId = sorted[0].id;
+  }
+
+  if (!sessionId) {
+    try {
+      const session = await createSession(serverBase, 'agentp');
+      sessionId = session.id;
+    } catch (err) {
+      console.error('Error creating session:', err.message);
+      process.exit(1);
+    }
+  }
+
+  let answer;
+  try {
+    answer = await sendToSession(serverBase, sessionId, promptText);
+  } catch (err) {
+    console.error('Error sending prompt:', err.message);
+    process.exit(1);
+  }
 
+  // Build the message to send to Telegram (QA pair with rulers)
+  let tgMessage = answer;
   if (qaMode) {
-    process.stdout.write(HUMAN_ROW);
-    process.stdout.write(promptText);
-    process.stdout.write(AGENT_ROW);
+    tgMessage = HUMAN_ROW + promptText + AGENT_ROW + answer;
+    if (!answer.endsWith('\n')) tgMessage += '\n';
+    tgMessage += FINAL_ROW;
   }
 
-  await listenForFinalAnswer(serverBase, (chunk) => process.stdout.write(chunk));
-  process.stdout.write('\n');
+  // Post-send: notify tgagentp, get recorded context back
+  let buffered = [];
+  let tgError = null;
+  if (tgPort) {
+    try {
+      buffered = await notifyAgentpGateway(tgPort, serverBase, tgMessage);
+    } catch (err) {
+      tgError = err;
+    }
+  }
+
+  // Build stdout output (prepend recorded context if any, unless --flush)
   if (qaMode) {
-    process.stdout.write(FINAL_ROW);
+    if (!flushMode && buffered.length > 0) {
+      for (const msg of buffered) {
+        const row = msg.role === 'user' ? HUMAN_ROW : AGENT_ROW;
+        process.stdout.write(row + msg.text + '\n');
+      }
+    }
+    process.stdout.write(tgMessage);
+  } else {
+    process.stdout.write(tgMessage);
+    if (!tgMessage.endsWith('\n')) process.stdout.write('\n');
   }
 
+  // Warnings at the end (stderr)
+  if (tgError && tgMode === true) {
+    process.stderr.write('\n');
+    process.stderr.write(`⚠️  Telegram notification failed: ${tgError.message}\n`);
+  }
   if (!process.env.OPENCODE_SERVER_PASSWORD) {
     process.stderr.write('\n');
     process.stderr.write('🔓 ⚠️  Server is not password-protected! Set OPENCODE_SERVER_PASSWORD for better security.\n');