agentp 0.5.0 → 0.7.0

package/AGENTS.md

@@ -42,7 +42,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,7 +95,12 @@ These endpoints are consumed but not documented elsewhere in the repo:
 
 ### Pending
 
-*(none)*
+- TUI navigation on session switch (open code API limitation — likely not possible)
+- `--print-logs` flag for `ocmux serve`
+
+### 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
 
 ### Done
 
@@ -108,7 +113,10 @@ These endpoints are consumed but not documented elsewhere in the repo:
 - 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: 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)
 - lib/ocmux.js shared session discovery, refactor ocmux + tgagentp
 - /cancel with true server-side SSE abort via cancelRef
 - /shutdown (--dev mode) with Telegram offset acknowledgment

package/bin/ocmux

@@ -346,13 +346,15 @@ function doNew(targetDir, longMode) {
   tmux(['send-keys', '-t', `${SESSION}:${winIdx}.0`,
     `opencode serve --port 0 2>&1 | tee '${lf}'`, 'Enter']);
 
-  // Wait up to 10s for the URL in the logfile
+  // Wait up to 10s for the URL in the logfile.
+  // Don't break on first match — keep polling so url ends up holding the
+  // final URL in case the server prints multiple URLs during startup.
   let url = null;
   for (let i = 0; i < 50; i++) {
     sleep(0.2);
     const log = (() => { try { return fs.readFileSync(lf, 'utf8'); } catch { return ''; } })();
     const m = log.match(URL_RE);
-    if (m) { url = m[1]; break; }
+    if (m) url = m[1];
   }
 
   if (!url) {

package/bin/tgagentp

@@ -4,7 +4,19 @@ 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');
+
+// Monkey-patch stderr to prefix all output with timestamps
+{
+  const origWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = function (chunk, encoding, cb) {
+    const ts = new Date().toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, '');
+    const str = typeof chunk === 'string' ? chunk : chunk.toString(encoding || 'utf8');
+    const lines = str.split('\n');
+    const prefixed = lines.map(l => l ? `[${ts}] ${l}` : l).join('\n');
+    return origWrite(prefixed, encoding, cb);
+  };
+}
 
 const STARTUP_CHAT_FILE = '/tmp/tgagentp-startup-chat';
 const { listServers, activateServer } = require('../lib/ocmux.js');
@@ -224,8 +236,18 @@ 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;
+    }
     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`, or just `/help`.');
     return;
   }
   await sendLongMessage(token, chatId,
@@ -243,6 +265,7 @@ async function cmdHelp(token, chatId, args) {
     '`/agents` — list available agents\n' +
     '`/agents switch <name>` — switch active agent\n' +
     '`/models` — list providers and models\n' +
+    '`/allow` / `/reject` / `/always` — respond to permission requests\n' +
     '`/shutdown` — stop tgagentp (only with `--dev` flag)\n\n' +
     'Everything else is forwarded to the active server as `[Telegram] <text>`.');
 }
@@ -279,7 +302,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 +320,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 +351,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 +632,56 @@ 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).');
+    process.stderr.write(`  → /allow: ${p.type} ${p.pattern || ''}\n`);
+  } 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.');
+    process.stderr.write(`  → /reject: ${p.type} ${p.pattern || ''}\n`);
+  } 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).');
+    process.stderr.write(`  → /always: ${p.type} ${p.pattern || ''}\n`);
+  } catch (err) {
+    await sendLongMessage(token, chatId, `Error: ${err.message}`);
+  }
+}
+
 const COMMANDS = {
   'help': cmdHelp,
   'servers': cmdServers,
@@ -597,6 +689,9 @@ const COMMANDS = {
   'session': cmdSessions,
   'agents': cmdAgents,
   'models': cmdModels,
+  'allow': cmdAllow,
+  'reject': cmdReject,
+  'always': cmdAlways,
 };
 
 // --------------------------------------------------------------------------
@@ -605,7 +700,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 };
+}
+
+function sessionLabel(st) {
+  if (st.activeSessionName) return '`' + st.activeSessionName + '`';
+  if (st.activeSessionId) return '`' + st.activeSessionId + '`';
+  return '*none (TUI+SSE)*';
 }
 
 // --------------------------------------------------------------------------
@@ -683,14 +784,44 @@ async function main() {
 
   let lockedChatId = null;
 
-  process.stderr.write('Waiting for Telegram messages... (Ctrl+C to stop)\n');
-
   getState(serverBase);
 
-  const setServer = (url) => {
+  process.stderr.write('Discovering server state...\n');
+  const [discovered, agents] = await Promise.all([
+    discoverActiveSession(serverBase),
+    listAgents(serverBase).catch(() => []),
+  ]);
+  if (discovered) {
+    getState(serverBase).activeSessionId = discovered.id;
+    getState(serverBase).activeSessionName = discovered.name;
+    process.stderr.write(`  → session: ${discovered.name || discovered.id}\n`);
+  }
+  const defaultAgent = agents.find(a => a.mode === 'primary') || agents[0];
+  if (defaultAgent) {
+    getState(serverBase).activeAgentName = defaultAgent.name;
+    process.stderr.write(`  → agent: ${defaultAgent.name}\n`);
+  }
+
+  process.stderr.write('Waiting for Telegram messages... (Ctrl+C to stop)\n');
+
+  const setServer = async (url) => {
     serverBase = url;
     getState(url);
     process.stderr.write(`Switched to server: ${url}\n`);
+    const [discovered, agents] = await Promise.all([
+      discoverActiveSession(url),
+      listAgents(url).catch(() => []),
+    ]);
+    if (discovered) {
+      getState(url).activeSessionId = discovered.id;
+      getState(url).activeSessionName = discovered.name;
+      process.stderr.write(`  → session: ${discovered.name || discovered.id}\n`);
+    }
+    const defaultAgent = agents.find(a => a.mode === 'primary') || agents[0];
+    if (defaultAgent) {
+      getState(url).activeAgentName = defaultAgent.name;
+      process.stderr.write(`  → agent: ${defaultAgent.name}\n`);
+    }
     const p = getState(url).pendingResponse;
     if (p) {
       getState(url).pendingResponse = null;
@@ -712,15 +843,57 @@ 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();
+        const ssePromise = listenForSessionEvents(url, sessionId, {
+          onPermission: (perm) => {
+            const st2 = getState(url);
+            const permDump = JSON.stringify(perm);
+            process.stderr.write(`  → permission_asked callback: ${permDump}\n`);
+            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.';
+              process.stderr.write(`  → sending permission notification to chat ${chatId}\n`);
+              sendLongMessage(token, chatId, msg)
+                .then(() => process.stderr.write(`  → permission notification sent OK\n`))
+                .catch((err) => process.stderr.write(`  → permission notification failed: ${err.message}\n`));
+            } else {
+              process.stderr.write(`  → permission ${perm.id} already notified, updating pendingPermission only\n`);
+            }
+          },
+          onPermissionReplied: () => {
+            process.stderr.write(`  → permission_replied: clearing pendingPermission\n`);
+            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;
       } else {
         await sendText(url, `[Telegram] ${text}`);
         answer = await listenForFinalAnswer(url, null, cancelRef);
       }
       if (isCancelled()) {
         process.stderr.write(`  → cancelled, discarding response from ${url}\n`);
+        st.pendingPermission = null;
         return;
       }
+      st.pendingPermission = null;
       if (url === serverBase) {
         if (answer && answer.trim()) {
           await sendLongMessage(token, chatId, answer.trim());
@@ -732,6 +905,7 @@ async function main() {
     } catch (err) {
       if (isCancelled()) {
         process.stderr.write(`  → cancelled, ignoring error from ${url}: ${err.message}\n`);
+        st.pendingPermission = null;
         return;
       }
       process.stderr.write(`Error processing message (${url}): ${err.message}\n`);
@@ -739,6 +913,7 @@ async function main() {
         try { await sendLongMessage(token, chatId, `Error: ${err.message}`); } catch (_) {}
       }
     } finally {
+      st.pendingPermission = null;
       if (st._cancelRef === cancelRef) st._cancelRef = null;
       if (!isCancelled()) {
         getState(url).busy = false;
@@ -771,7 +946,7 @@ 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'));
   };
@@ -794,12 +969,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 (_) {}
   }

package/lib/ocmux.js

@@ -27,11 +27,12 @@ function statefileFor(dir) {
 }
 
 function tuiPaneId(windowIndex) {
-  const r = _tmux(['list-panes', '-t', `${SESSION}:${windowIndex}`, '-F', '#{pane_id}\t#{pane_current_command}']);
+  const r = _tmux(['list-panes', '-t', `${SESSION}:${windowIndex}`, '-F', '#{pane_id}\t#{pane_index}']);
   if (r.status !== 0) return null;
   for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
-    const [paneId, cmd] = line.split('\t');
-    if (cmd === 'node') return paneId;
+    const [paneId, idx] = line.split('\t');
+    // Server is always pane 0, TUI is pane 1+
+    if (idx !== '0') return paneId;
   }
   return null;
 }

package/lib/opencode.js

@@ -251,6 +251,157 @@ 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;
+            }
+          } 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 +416,9 @@ module.exports = {
   updateSession,
   selectSession,
   sendToSession,
+  sendToSessionAsync,
+  respondToPermission,
+  listenForSessionEvents,
   listAgents,
   listProviders,
 };

package/package.json

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

package/status_report.md

@@ -0,0 +1,85 @@
+# Project Status Report — June 2026
+
+## Environment
+
+- **Node.js:** v22.12.0
+- **opencode:** v1.15.13 (compiled ELF binary, bun-based)
+- **Package:** agentp v0.6.0 (just published)
+- **Branch structure (local):**
+  - `main` — v0.6.0, published, contains all ocmux fixes
+  - `pr-2` — worktree at `wt/pr-2/`, same as main + minor divergence
+  - `feature/tgagentp-session-init` — branch with WIP session discovery work (based on old v0.5.0, needs rebase onto main)
+
+## What's Fixed (v0.6.0)
+
+- **tuiPaneId** rewritten to use pane index (server=0, TUI=1+) instead of process name — works with any runtime (node, bun, compiled binary)
+- **URL polling** in `doNew()` takes the last match instead of the first — more robust with bun startup
+- **agentp freeze** confirmed resolved — the 401/event stream issue was caused by stale opencode 0.14.39 session, not a code bug
+
+## Known Issues (unsolved)
+
+### 1. Session initialization — startup / server switch
+- **Branch:** `feature/tgagentp-session-init` (1 commit, needs rebase)
+- **Problem:** On fresh tgagentp start or `/servers switch`, `activeSessionId` is `null`. The user must manually do `/sessions switch` or `/sessions new` before session-aware messaging works.
+- **WIP fix:** `discoverActiveSession()` helper — calls `listSessions`, sorts by `time.updated`, picks most recent. Called at startup (async `.then()`) and in `setServer()` (awaited). But startup greeting may fire before discovery completes, showing "Session: *none (TUI+SSE)*".
+- **Next step:** Rebase branch onto main, tune timing (await discovery before greeting, or delay greeting).
+
+### 2. /status shows session ID instead of name
+- `/status` displays raw `ses_xxxxx` ID. Would be user-friendly to show the session title/slug (available from `listSessions`).
+- **Fix approach:** Either fetch session name on `/status` (adds latency), or cache discovered session names.
+
+### 3. /status shows "Agent: *default*" instead of actual agent name
+- `activeAgentName` is never initialized on startup. The TUI has an active agent but tgagentp doesn't discover it.
+- **Fix:** Could extend `discoverActiveSession()` to also fetch the session's agent, or query `GET /agent` for the default agent on startup.
+
+### 4. /servers list — no active server marker
+- Unlike `/sessions` (which marks active session with ▶), `/servers` doesn't highlight the currently selected server.
+- **Fix:** Simple — compare each server URL against `serverBase` and prepend a bullet.
+
+### 5. TUI navigation on session switch
+- `/sessions switch` and `/sessions new` call `selectSession()` which tries `POST /session/:id/select` and `POST /tui/select-session`. Neither navigates the TUI pane. Message routing works correctly in background.
+- **Status:** Known limitation — documented in AGENTS.md "With Issues." The underlying opencode API may lack the needed TUI navigation endpoints. Revisit after opencode 1.15.x API audit.
+
+### 6. AGENTS.md docs need updating
+- `tuiPaneId` doc still says "returns pane ID if TUI process (`node`) is running" — now uses pane index, not process name.
+- Session discovery feature (once merged) needs documenting.
+
+### 7. --print-logs request (low priority)
+- User requested a `--print-logs` option for the server startup command in ocmux to aid debugging.
+- The log file is at `/tmp/opencode-serve-<hashDir(dir)>.log` and is already captured via `tee`. Could add a flag to tail it.
+
+## Session discovery (feature branch details)
+
+Branch `feature/tgagentp-session-init` contains 1 commit (`6393a8f`):
+
+```
+WIP: session discovery, initialization improvements, known issues
+  - Added discoverActiveSession() helper
+  - setServer() made async
+  - Startup greeting uses st.activeSessionId
+
+Known issues (at time of writing, with opencode v1.14.39):
+  1. Startup greeting shows "Session: *none*" due to async race
+  2. /status shows session ID not name
+  3. /status shows "Agent: *default*"
+  4. /servers list no active marker
+  5. /servers switch doesn't switch tmux window (now partially fixed in v0.6.0)
+  6. /sessions switch doesn't navigate TUI
+  7. ocmux misbehaved with opencode >= 1.15.x (now fixed in v0.6.0)
+```
+
+**Files changed:** `bin/tgagentp`, `AGENTS.md` (+34/-5 lines)
+
+The branch needs to be rebased onto main (v0.6.0) before further work.
+
+## Next Steps
+
+1. Rebase `feature/tgagentp-session-init` onto main
+2. Continue on that branch:
+   a. Fix startup greeting race (await discovery before sending)
+   b. Add session name resolution for /status
+   c. Add agent discovery for /status
+   d. Add active server marker in /servers
+   e. Revisit TUI navigation after opencode API audit
+3. Merge back into main when ready
+4. Clean up: remove `pr-2` worktree and branch