agentp 0.7.0 → 0.9.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
 
@@ -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.
@@ -30,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`
 
@@ -60,17 +70,28 @@ 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`.
+
 ## 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)
@@ -82,10 +103,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] [port]` | pipe stdin → opencode session, stream answer to stdout (uses session API); `--tg` forwards answer to Telegram |
 | `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 |
@@ -95,23 +116,35 @@ These endpoints are consumed but not documented elsewhere in the repo:
 
 ### Pending
 
-- TUI navigation on session switch (open code API limitation — likely not possible)
-- `--print-logs` flag for `ocmux serve`
+- `agentp --getLast n` — retrieve last n answers from session history
 
 ### In Progress
 
-- Event-driven permission handling via Telegram: `POST /session/:id/prompt_async` + `GET /event` SSE listener for `permission.updated` events + `/allow`, `/reject`, `/always` commands — implemented, pending user testing
+*(none)*
 
 ### Done
 
-- /agents switch <name> — switch active agent on the active session
+- 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)
 - /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)
 - 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)
@@ -121,10 +154,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

@@ -53,9 +53,13 @@ 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
 - `--version`: show version
 - `--help`: show help message
 
+By default, `--qa` implies `--tg`; standalone mode implies `--no-tg`.
+
 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 +115,15 @@ 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.)
+
 ## ocmux
 
 Manage OpenCode server + TUI in tmux for project directories.
@@ -123,9 +136,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 +167,15 @@ 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.
+
+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 +201,21 @@ 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`) |
 | `/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 |
-| `/shutdown` | (requires `--dev`) Stop tgagentp gracefully; acknowledge offset and exit |
+| `/think [on\|off\|switch]` | Toggle forwarding of model thinking messages to the chat |
+| `/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
 
@@ -212,8 +235,38 @@ 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`)
 
+### 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`).
+
+### 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`.
@@ -223,9 +276,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,73 @@
 #!/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,
 } = 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) 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;
+  // 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,18 +77,23 @@ 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('  --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');
@@ -64,6 +103,10 @@ async function main() {
       process.exit(0);
     } else if (args[i] === '--qa') {
       qaMode = true;
+    } 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 +114,91 @@ 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();
 
-  if (qaMode) {
-    process.stdout.write(HUMAN_ROW);
-    process.stdout.write(promptText);
-    process.stdout.write(AGENT_ROW);
+  // 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);
   }
 
-  await listenForFinalAnswer(serverBase, (chunk) => process.stdout.write(chunk));
-  process.stdout.write('\n');
+  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 full --qa output and send to stdout
+  let tgText = answer;
   if (qaMode) {
-    process.stdout.write(FINAL_ROW);
+    tgText = HUMAN_ROW + promptText + AGENT_ROW + answer;
+    if (!answer.endsWith('\n')) tgText += '\n';
+    tgText += FINAL_ROW;
+    process.stdout.write(tgText);
+  } else {
+    process.stdout.write(answer);
+    if (!answer.endsWith('\n')) process.stdout.write('\n');
+  }
+
+  // Post-send: notify tgagentp if we have a port
+  let tgError = null;
+  if (tgPort) {
+    try {
+      await notifyAgentpGateway(tgPort, serverBase, tgText);
+    } catch (err) {
+      tgError = err;
+    }
   }
 
+  // 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');

package/bin/ocmux

@@ -192,6 +192,7 @@ function printHelp() {
   console.error('          --git  Use the nearest parent with a .git entry (file or dir).');
   console.error('          --GIT  Use the nearest parent with a .git directory only.');
   console.error('          Refuses to create above an existing .ocmux.json found while searching.');
+  console.error(          '          --print-logs  Pass --print-logs to opencode serve (prints server logs to stderr).');
   console.error('  kill    Kill the server found upward from <directory>.');
   console.error('          Removes its tmux window and state file.');
   console.error('  list    List all running servers with their directories and URLs.');
@@ -201,6 +202,7 @@ function printHelp() {
   console.error('');
   console.error('Options:');
   console.error('  -l       Long output: append " → <dir>" after the URL (serve/default).');
+  console.error('  --print-logs  Pass --print-logs to opencode serve (prints server logs to stderr).');
   console.error('  --version  Show version');
   console.error('  -h       Show this help');
   console.error('');
@@ -290,7 +292,7 @@ function cmdList() {
 // Subcommand: new
 // ---------------------------------------------------------------------------
 
-function cmdNew(targetDir, longMode) {
+function cmdNew(targetDir, longMode, printLogs) {
   const sf = path.join(targetDir, '.ocmux.json');
   if (fs.existsSync(sf)) {
     console.error(`Error: a server already exists in ${targetDir}.`);
@@ -311,14 +313,14 @@ function cmdNew(targetDir, longMode) {
         console.error('Cancelled.');
         process.exit(0);
       }
-      doNew(targetDir, longMode);
+      doNew(targetDir, longMode, printLogs);
     });
   } else {
-    doNew(targetDir, longMode);
+    doNew(targetDir, longMode, printLogs);
   }
 }
 
-function doNew(targetDir, longMode) {
+function doNew(targetDir, longMode, printLogs) {
   ensureSession();
   const lf = logfileFor(targetDir);
 
@@ -343,8 +345,9 @@ function doNew(targetDir, longMode) {
   try { fs.truncateSync(lf); } catch { /* may not exist yet */ }
 
   // Send the command to the interactive shell (like typing it manually)
+  const serveFlags = printLogs ? '--port 0 --print-logs' : '--port 0';
   tmux(['send-keys', '-t', `${SESSION}:${winIdx}.0`,
-    `opencode serve --port 0 2>&1 | tee '${lf}'`, 'Enter']);
+    `opencode serve ${serveFlags} 2>&1 | tee '${lf}'`, 'Enter']);
 
   // Wait up to 10s for the URL in the logfile.
   // Don't break on first match — keep polling so url ends up holding the
@@ -432,12 +435,15 @@ function cmdKill(statefile) {
 function main() {
   let longMode = false;
   let gitMode = null;
+  let printLogs = false;
   const positional = [];
   let dirIsForced = false;
 
   for (const arg of process.argv.slice(2)) {
     if (arg === '-l') {
       longMode = true;
+    } else if (arg === '--print-logs') {
+      printLogs = true;
     } else if (arg === '--git') {
       if (gitMode && gitMode !== 'nearest') {
         console.error("Error: cannot combine '--git' with '--GIT'.");
@@ -506,6 +512,10 @@ function main() {
       console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
       process.exit(1);
     }
+    if (printLogs) {
+      console.error("Error: '--print-logs' is only valid with 'serve'.");
+      process.exit(1);
+    }
     if (targetDir !== process.cwd()) {
       console.error("Error: 'list' does not accept a directory path.");
       process.exit(1);
@@ -516,6 +526,10 @@ function main() {
       console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
       process.exit(1);
     }
+    if (printLogs) {
+      console.error("Error: '--print-logs' is only valid with 'serve'.");
+      process.exit(1);
+    }
     const sf = findParentStatefile(targetDir);
     if (!sf) {
       console.error(`Error: no opencode server found in ${targetDir} or any of its parents.`);
@@ -528,12 +542,16 @@ function main() {
       const flagLabel = gitMode === 'root' ? '--GIT' : '--git';
       targetDir = resolveGitDir(targetDir, gitMode === 'root', flagLabel);
     }
-    cmdNew(targetDir, longMode);
+    cmdNew(targetDir, longMode, printLogs);
   } else {
     if (gitMode) {
       console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
       process.exit(1);
     }
+    if (printLogs) {
+      console.error("Error: '--print-logs' is only valid with 'serve'.");
+      process.exit(1);
+    }
     // Default mode
     const sf = findParentStatefile(targetDir);
     if (!sf) {