agentp 0.11.7 → 0.11.9

package/README.md

@@ -7,9 +7,9 @@
 
 This package provides three CLI tools:
 
-- **`agentp`** — pipes prompt text into a running OpenCode TUI session and streams the assistant final answer back to stdout
+- **`agentp`** — pipes prompt text into a running OpenCode server and streams the assistant final answer back to stdout
 - **`ocmux`** — manages OpenCode server + TUI sessions in tmux (create, switch, kill, list)
-- **`tgagentp`** — bridges a Telegram bot chat with all running OpenCode TUI sessions (receives messages from Telegram, routes them to the active server, sends answers back). Supports slash commands for multi-server management, session switching, agent/model listing, and remote restart.
+- **`tgagentp`** — bridges a Telegram bot chat with all running OpenCode servers (receives messages from Telegram, routes them to the active server, sends answers back). Supports slash commands for multi-server management, session switching, agent/model listing, including file sharing from the chat.
 
 It is designed for prompt-driven workflows where you want to do things like:
 
@@ -61,6 +61,8 @@ Options:
 - `--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
+- `--session <name>`: target a specific session by name (exact or partial match)
+- `--new`: create a new session with the given title (requires `--session`)
 - `--version`: show version
 - `--help`: show help message
 
@@ -150,8 +152,6 @@ Useful to grab recent answers without sending a new prompt.
 
 ## ocmux
 
-## ocmux
-
 Manage OpenCode server + TUI in tmux for project directories.
 
 ```bash
@@ -233,24 +233,14 @@ 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`, `allow`, `think`, `record`, `queue`) |
-| `/servers` | List all running ocmux-served projects with URL + status (✅ idle / ⏳ busy) |
+| `/servers` | List all ocmux-served projects (▶ active, 🔌 disconnected, 💀 dead) |
 | `/servers switch <name> [--force]` | Switch active server; matches by full path, basename, or substring; `--force` takes over from another chat |
-| `/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 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 |
-| `/flush` | Clear all queued messages (manual and auto-queued) |
-| `/resurrect` | Recover a dead server — restart processes in the same directory, reconnect chat |
+| `/resurrect [path]` | Restart a crashed server from its `.ocmux.json`; accepts optional directory path |
 | `/allow` | Approve a permission request once |
 | `/reject` | Deny a permission request |
 | `/always` | Approve and remember for the session |
 | `/answer <number>` | Respond to a question asked by the AI (structured multiple-choice) |
+| `/markdown` | Send the original markdown of the last response as a `.md` file; reply to a message to get that specific response |
 | `/shutdown [force\|clear]` | (requires `--dev`) Stop tgagentp; `clear` also wipes saved connections |
 
 #### TUI Command Passthrough
@@ -328,6 +318,7 @@ Chat-to-server directory mappings are saved to `/tmp/tgagentp-connections.json`
 | `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`). |
+| `TGAGENTP_ROOT` | Optional. Root directory for `/serve` and `/new` commands (must be writable). |
 
 ## License
 

package/bin/ocmux

@@ -22,6 +22,7 @@ const {
   logfileFor,
   URL_RE,
   resurrectServer,
+  startServer,
   getActiveServer,
 } = require('../lib/ocmux');
 
@@ -332,7 +333,7 @@ function doNew(targetDir, longMode, printLogs) {
   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';
+  const serveFlags = printLogs ? '--print-logs' : '';
   tmux(['send-keys', '-t', `${SESSION}:${winIdx}.0`,
     `opencode serve ${serveFlags} 2>&1 | tee '${lf}'`, 'Enter']);
 

package/bin/tgagentp

@@ -18,7 +18,7 @@ const TGAGENTP_PORT = parseInt(process.env.TGAGENTP_PORT || '0', 10);
 const PORT_FILE = '/tmp/tgagentp-port';
 const TGAGENTP_DEBOUNCE_MS = parseInt(process.env.TGAGENTP_DEBOUNCE_MS || '5000', 10);
 const CONNECTIONS_FILE = '/tmp/tgagentp-connections.json';
-const { listServers, activateServer, resurrectServer, statefileFor, readState, tuiPaneId } = require('../lib/ocmux.js');
+const { listServers, activateServer, resurrectServer, statefileFor, readState, tuiPaneId, serverStatus, listDeadServers } = require('../lib/ocmux.js');
 const { executeTuiCommand } = require('../lib/tui-cmd.js');
 const { getUpdates, downloadTelegramFile, sendTelegramDocument } = require('../lib/telegram-api.js');
 const { sendLongMessage } = require('../lib/telegram-format.js');
@@ -162,6 +162,33 @@ function flushRecorded(chatId, threadId) {
   return msgs;
 }
 
+// Ring buffer of recent responses keyed by Telegram message ID.
+// Stored per chatId+threadId for /markdown command lookups.
+const responseHistory = {}; // convKey → [{ messageId, text }]
+
+function recordResponseMessage(chatId, threadId, messageIds, text) {
+  const key = convKey(chatId, threadId);
+  if (!responseHistory[key]) responseHistory[key] = [];
+  responseHistory[key].push({ messageIds, text });
+  if (responseHistory[key].length > 20) responseHistory[key].shift();
+}
+
+function getResponseByMessageId(chatId, threadId, messageId) {
+  const key = convKey(chatId, threadId);
+  const list = responseHistory[key] || [];
+  return list.find(e => e.messageIds.includes(messageId));
+}
+
+function getRecentResponse(chatId, threadId, index) {
+  const key = convKey(chatId, threadId);
+  const list = responseHistory[key] || [];
+  if (list.length === 0) return null;
+  // index 1 = most recent, 2 = second most recent, etc.
+  const idx = list.length - (index || 1);
+  if (idx < 0 || idx >= list.length) return null;
+  return list[idx];
+}
+
 // ---------------------------------------------------------------------------
 // Telegram Bot API helpers
 // ---------------------------------------------------------------------------
@@ -179,7 +206,7 @@ function parseAllowlist(raw) {
 // 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.
-const { ensureSharedDir, saveUploadedFile, formatFileSize } = require('../lib/file-share.js');
+const { formatFileSize } = require('../lib/file-share.js');
 
 function quoteReply(msg) {
   const rm = msg.reply_to_message;
@@ -202,7 +229,7 @@ function quoteReply(msg) {
 // ---------------------------------------------------------------------------
 
 // Handle an uploaded file from Telegram.
-// Downloads the file, saves it, and returns a notification message.
+// Returns a notification message with fileId so the agent can download it on demand.
 async function handleFileUpload(token, msg, projectDir) {
   const doc = msg.document;
   const photo = msg.photo;
@@ -217,18 +244,15 @@ async function handleFileUpload(token, msg, projectDir) {
     fileName = doc.file_name || 'upload.bin';
     fileSize = doc.file_size || 0;
   } else if (photo) {
-    // Use the largest photo
     const largest = photo[photo.length - 1];
     fileId = largest.file_id;
     fileName = 'photo.jpg';
     fileSize = largest.file_size || 0;
   }
 
-  const fileData = await downloadTelegramFile(token, fileId);
-  ensureSharedDir(projectDir);
-  const relativePath = saveUploadedFile(projectDir, fileName, fileData);
   const sizeStr = fileSize > 0 ? ` (${formatFileSize(fileSize)})` : '';
-  return `📎 File uploaded: \`${relativePath}\`${sizeStr}`;
+  return `📎 File uploaded: \`${fileName}\`${sizeStr}\n` +
+    `Use \`[Telegram]{"command":"download","fileId":"${fileId}","path":"<destination>"}\` to save it.`;
 }
 
 // ---------------------------------------------------------------------------
@@ -405,8 +429,15 @@ async function cmdHelp(token, chatId, args, chatState) {
         hint);
       return;
     }
+    if (topic === 'markdown') {
+      await sendLongMessage(token, chatState,
+        '`/markdown` ─ send the original markdown of the most recent response as a `.md` file\n\n' +
+        'Reply to any message and use `/markdown` to get the original markdown of the response that generated that message ' +
+        '(works even if the response was split into multiple Telegram messages).');
+      return;
+    }
     await sendLongMessage(token, chatState,
-      'Unknown topic. Try `/help servers`, `/help sessions`, `/help agents`, `/help models`, `/help allow`, `/help think`, `/help record`, `/help queue`, `/help flush`, `/help note`, `/help comment`, `/help disconnect`, `/help serve`, `/help new`, or just `/help`.');
+      'Unknown topic. Try `/help servers`, `/help sessions`, `/help agents`, `/help models`, `/help allow`, `/help think`, `/help record`, `/help queue`, `/help flush`, `/help note`, `/help comment`, `/help disconnect`, `/help serve`, `/help new`, `/help markdown`, or just `/help`.');
     return;
   }
   await sendLongMessage(token, chatState,
@@ -433,6 +464,7 @@ async function cmdHelp(token, chatId, args, chatState) {
     '`/comment <text>` ─ save a comment in the chat (not forwarded to the agent)\n' +
     '`/disconnect` ─ disconnect this chat from its server\n' +
     '`/allow` / `/reject` / `/always` ─ respond to permission requests\n' +
+    '`/markdown` ─ send the original markdown of the last response as a `.md` file\n' +
     '`/shutdown` ─ stop tgagentp (only with `--dev` flag)\n' +
     (tgagentpRootValid
       ? '`/serve <path>` ─ start a server in an existing directory\n' +
@@ -527,14 +559,21 @@ async function cmdServers(token, chatId, args, chatState, setServerForChat, setA
     return;
   }
 
-  // Default: list servers
+  // Default: list servers (alive + dead)
   const servers = listServers();
-  if (servers.length === 0) {
-    await sendLongMessage(token, chatState, 'No servers running.');
+  // Also find dead servers from saved connections
+  let savedData;
+  try { savedData = JSON.parse(fs.readFileSync(CONNECTIONS_FILE, 'utf8')); } catch {}
+  const knownDirs = savedData && Array.isArray(savedData.connections)
+    ? savedData.connections.map(c => c.dir).filter(Boolean) : [];
+  const dead = listDeadServers(knownDirs);
+  const all = [...servers, ...dead.map(d => ({ url: d.url, dir: d.dir, index: d.windowIndex, status: 'dead' }))];
+  if (all.length === 0) {
+    await sendLongMessage(token, chatState, 'No servers found.');
     return;
   }
   const activeUrl = chatState.serverBase ? normalizeUrl(chatState.serverBase) : null;
-  const lines = servers.map(s => {
+  const lines = all.map(s => {
     const normalizedUrl = normalizeUrl(s.url);
     const isActive = activeUrl && normalizedUrl === activeUrl;
     const isOwned = Object.keys(serverOwners).some(url => normalizeUrl(url) === normalizedUrl);
@@ -543,12 +582,14 @@ async function cmdServers(token, chatId, args, chatState, setServerForChat, setA
       bullet = '▶ ';
     } else if (isOwned) {
       bullet = ' · ';
+    } else if (s.status === 'dead') {
+      bullet = '💀 ';
     } else {
       bullet = '🔌 ';
     }
     return bullet + `${s.url} → ${s.dir} (${s.status})`;
   });
-  const prefix = chatState.serverBase ? 'Active servers:' : 'Available servers:';
+  const prefix = chatState.serverBase ? 'All servers:' : 'Available servers:';
   await sendLongMessage(token, chatState, prefix + '\n' + lines.join('\n'));
 }
 
@@ -557,6 +598,7 @@ function sessionName(s) {
 }
 
 function normalizeUrl(url) {
+  if (!url) return url;
   return url.replace(/\/+$/, '').replace(/^http:\/\/127\.0\.0\.1:/, 'http://localhost:');
 }
 
@@ -600,7 +642,7 @@ async function cmdSessions(token, chatId, args, chatState, setServerForChat, set
       try {
         const session = await createSession(server, title);
         const name = session.title || session.slug || session.id;
-        setActiveSessionForChat(chatState, session.id);
+        setActiveSessionForChat(chatState, session.id, name);
         selectSession(server, session.id);
         await sendLongMessage(token, chatState,
           `Created session: \`${name}\`\nIt is now the active session.`);
@@ -652,7 +694,7 @@ async function cmdSessions(token, chatId, args, chatState, setServerForChat, set
         const num = parseInt(query, 10);
         if (/^\d+$/.test(query) && num >= 1 && num <= sorted.length) {
           const target = sorted[num - 1];
-          setActiveSessionForChat(chatId, target.id);
+          setActiveSessionForChat(chatState, target.id, sessionName(target));
           selectSession(server, target.id);
           await sendLongMessage(token, chatState,
             `Switched to session #${num}: \`${sessionName(target)}\`\nSubsequent messages will be sent to this session.`);
@@ -674,7 +716,7 @@ async function cmdSessions(token, chatId, args, chatState, setServerForChat, set
           return;
         }
         const target = matches[0];
-        setActiveSessionForChat(chatId, target.id);
+        setActiveSessionForChat(chatState, target.id);
         selectSession(server, target.id);
         await sendLongMessage(token, chatState,
           `Switched to session: \`${sessionName(target)}\`\nSubsequent messages will be sent to this session.`);
@@ -704,10 +746,13 @@ async function cmdSessions(token, chatId, args, chatState, setServerForChat, set
       return;
     }
 
-    // Show user sessions (have agent or directory) and always include the active session
+    // Show primary-agent sessions and always include the active session
+    const agents = await listAgents(server).catch(() => []);
+    const primaryAgents = new Set(agents.filter(a => a.mode === 'primary').map(a => a.name));
+    const hasPrimaryAgent = (s) => s.agent && primaryAgents.has(s.agent);
     const activeId = getState(server).activeSessionId;
     const filtered = sessions.filter(s =>
-      (s.agent || s.directory || s.id === activeId) && (!projectDir || s.directory === projectDir));
+      (hasPrimaryAgent(s) || s.id === activeId) && (!projectDir || s.directory === projectDir));
     const sorted = sortedSessions(filtered, 50);
     if (sorted.length === 0) {
       await sendLongMessage(token, chatState, 'No active sessions.');
@@ -891,8 +936,6 @@ function startAgentpGateway(token, serverBaseResolver) {
         }
         if (req.url === '/send') {
           handleSendRequest(req, res, token, serverBaseResolver);
-        } else if (req.url === '/send-file') {
-          handleSendFileRequest(req, res, token, serverBaseResolver);
         } else {
           res.writeHead(404);
           res.end('Not Found');
@@ -944,7 +987,9 @@ function handleSendRequest(req, res, token, serverBaseResolver) {
       const activeUrl = normalizeUrl(serverBaseResolver());
 
       if (targetUrl === activeUrl) {
-        sendLongMessage(token, owningChatId, text.trim()).catch(() => {});
+        processTelegramCommands(text, server, token, owningChatId).then((cleaned) => {
+          if (cleaned) sendLongMessage(token, owningChatId, cleaned).catch(() => {});
+        });
       } else {
         if (!agentpQueues[server]) {
           agentpQueues[server] = { messages: [], notifyTimer: null, notified: false };
@@ -969,72 +1014,122 @@ function handleSendRequest(req, res, token, serverBaseResolver) {
   });
 }
 
-function handleSendFileRequest(req, res, token, serverBaseResolver) {
-  let body = '';
-  req.on('data', (chunk) => { body += chunk; });
-  req.on('end', () => {
-    try {
-      let data;
-      try { data = JSON.parse(body); } catch {
-        res.writeHead(400);
-        res.end('Bad Request');
-        return;
-      }
-      const { filePath, server, message } = data;
-      if (typeof filePath !== 'string' || typeof server !== 'string') {
-        res.writeHead(400);
-        res.end('Bad Request: filePath and server are required');
-        return;
-      }
+// Scan response text for [Telegram]{...} structured messages, process them,
+// and return the text with those lines removed (or replaced, for help commands).
+// Supported commands:
+//   "upload"  — send a file to the Telegram chat.
+//               Format: [Telegram]{"command":"upload","path":"<rel-path>","msg":"<caption>"}
+//   "download" — save a Telegram file to the project directory.
+//                Format: [Telegram]{"command":"download","fileId":"<id>","path":"<rel-path>"}
+//   "help"    — get help about available commands.
+//               Format: [Telegram]{"command":"help","topic":"<upload|download|help>"}
+// The [Telegram]{...} must be the only content on its line.
+
+// Parse a single [Telegram]{...} line. Returns { payload } or null.
+function parseTelegramLine(line) {
+  const m = line.match(/^\[Telegram\](\{.*\})\s*$/);
+  if (!m) return null;
+  let payload;
+  try { payload = JSON.parse(m[1]); } catch { return null; }
+  if (!payload || typeof payload !== 'object') return null;
+  return payload;
+}
 
-      // Find the chat that owns this server
-      const targetUrl = normalizeUrl(server);
-      const owningChatId = Object.entries(serverOwners).find(([url]) => normalizeUrl(url) === targetUrl)?.[1];
+const TELEGRAM_COMMANDS_HELP = {
+  all: 'Available commands:\n\n' +
+    '• upload — send a file to Telegram.\n' +
+    '  [Telegram]{"command":"upload","path":"<relative-path>","msg":"<optional caption>"}\n\n' +
+    '• download — save a file from Telegram to the project.\n' +
+    '  [Telegram]{"command":"download","fileId":"<telegram-file-id>","path":"<relative-destination>"}\n\n' +
+    '• help — show this help or details for a specific command.\n' +
+    '  [Telegram]{"command":"help","topic":"<command>"}',
+  upload: 'Upload a file to the Telegram chat.\n\n' +
+    'Format: [Telegram]{"command":"upload","path":"<relative-path>","msg":"<optional caption>"}\n\n' +
+    '- path: file path relative to the project root (required)\n' +
+    '- msg:  optional caption sent with the file',
+  download: 'Download a file the user uploaded to Telegram.\n\n' +
+    'Format: [Telegram]{"command":"download","fileId":"<telegram-file-id>","path":"<relative-destination>"}\n\n' +
+    '- fileId: the Telegram file identifier (provided when the user uploads a file)\n' +
+    '- path:   destination path relative to the project root (required)',
+  help: 'Get help about Telegram commands.\n\n' +
+    'Format: [Telegram]{"command":"help","topic":"<command>"}\n\n' +
+    '- topic: one of "upload", "download", "help". Omit for general help.',
+};
 
-      if (!owningChatId) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ sent: false, reason: 'no owner' }));
-        return;
-      }
+function getHelpText(topic) {
+  if (topic && TELEGRAM_COMMANDS_HELP[topic]) return TELEGRAM_COMMANDS_HELP[topic];
+  return TELEGRAM_COMMANDS_HELP.all;
+}
 
-      // Resolve the file path relative to the server directory
-      const dir = serverDir(server);
-      if (!dir) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ sent: false, reason: 'no server dir' }));
-        return;
+async function processTelegramCommands(text, server, token, chatState) {
+  if (!text) return text;
+  const lines = text.split('\n');
+  const toStrip = new Set();
+  const filesSent = [];
+  const dir = serverDir(server);
+
+  for (let i = 0; i < lines.length; i++) {
+    const payload = parseTelegramLine(lines[i]);
+    if (!payload) continue;
+
+    if (payload.command === 'upload' && payload.path) {
+      toStrip.add(i);
+      const resolved = dir ? path.resolve(dir, payload.path) : path.resolve(payload.path);
+      if (dir && !resolved.startsWith(dir + path.sep)) {
+        log.error(`processTelegramCommands: path outside project rejected: ${payload.path}`);
+        continue;
       }
-      const fullPath = path.resolve(dir, filePath);
-      if (!fs.existsSync(fullPath)) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ sent: false, reason: 'file not found' }));
-        return;
+      try {
+        if (!fs.existsSync(resolved)) {
+          log.error(`processTelegramCommands: file not found: ${resolved}`);
+          continue;
+        }
+        const fileData = fs.readFileSync(resolved);
+        const fileName = path.basename(resolved);
+        const caption = typeof payload.msg === 'string' ? payload.msg : undefined;
+        await sendTelegramDocument(token, chatState, fileData, fileName, caption);
+        filesSent.push(fileName);
+      } catch (err) {
+        log.error(`processTelegramCommands: failed to send file ${resolved}: ${err.message}`);
+      }
+    } else if (payload.command === 'download' && payload.fileId && payload.path) {
+      toStrip.add(i);
+      const resolved = dir ? path.resolve(dir, payload.path) : path.resolve(payload.path);
+      if (dir && !resolved.startsWith(dir + path.sep)) {
+        log.error(`processTelegramCommands: download path outside project rejected: ${payload.path}`);
+        continue;
       }
+      try {
+        const fileData = await downloadTelegramFile(token, payload.fileId);
+        fs.mkdirSync(path.dirname(resolved), { recursive: true });
+        fs.writeFileSync(resolved, fileData);
+        filesSent.push(path.basename(resolved));
+      } catch (err) {
+        log.error(`processTelegramCommands: failed to download file: ${err.message}`);
+      }
+    } else if (payload.command === 'help') {
+      toStrip.add(i);
+      const topic = typeof payload.topic === 'string' ? payload.topic : undefined;
+      const st = getState(server);
+      if (st.activeSessionId) {
+        sendToSession(server, st.activeSessionId, getHelpText(topic)).catch(() => {});
+      }
+    } else {
+      toStrip.add(i); // unrecognized command — strip silently
+    }
+  }
 
-      const fileData = fs.readFileSync(fullPath);
-      const fileName = path.basename(fullPath);
+  if (toStrip.size === 0) return text;
 
-      // Send file to Telegram
-      sendTelegramDocument(token, owningChatId, fileData, fileName, message).then(() => {
-        // Clean up: only delete files from telegram-shared/downloads/
-        // to prevent accidental deletion of project files
-        const downloadsDir = path.join(dir, 'telegram-shared', 'downloads');
-        if (fullPath.startsWith(downloadsDir + path.sep)) {
-          try { fs.unlinkSync(fullPath); } catch (_) {}
-        }
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ sent: true }));
-      }).catch((err) => {
-        log.error(`Failed to send file: ${err.message}`);
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ sent: false, reason: err.message }));
-      });
-    } catch (err) {
-      log.error(`Agentp gateway handler error: ${err.message}`);
-      res.writeHead(500);
-      res.end('Internal Server Error');
-    }
-  });
+  if (filesSent.length > 0) {
+    log.info(`processTelegramCommands: processed ${filesSent.length} file(s): ${filesSent.join(', ')}`);
+  }
+
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (!toStrip.has(i)) out.push(lines[i]);
+  }
+  return out.join('\n').replace(/\n{3,}/g, '\n\n').trim();
 }
 
 async function cmdAllow(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
@@ -1277,31 +1372,53 @@ async function cmdComment(token, chatId, args, chatState) {
 }
 
 async function cmdResurrect(token, chatId, args, chatState) {
-  const url = chatState.serverBase;
-  if (!url) {
-    await sendLongMessage(token, chatState, '🔌 Not connected to any server. Nothing to resurrect.');
-    return;
-  }
-
-  let dir = serverDir(url);
-  if (!dir) {
-    // Fallback: look up directory from saved connections
-    try {
-      const savedData = JSON.parse(fs.readFileSync(CONNECTIONS_FILE, 'utf8'));
-      if (savedData && Array.isArray(savedData.connections)) {
-        const match = savedData.connections.find(c =>
-          String(c.chatId) === String(chatId) && (c.threadId || null) === (chatState.threadId || null)
-        );
-        if (match && match.dir) dir = match.dir;
+  let dir = null;
+  let url = null;
+  const dirArg = args && args.length > 0 ? args.join(' ') : null;
+  if (dirArg) {
+    // User specified a directory: resolve it
+    if (TGAGENTP_ROOT) {
+      const resolved = path.resolve(TGAGENTP_ROOT, dirArg);
+      if (resolved.startsWith(TGAGENTP_ROOT) && fs.existsSync(resolved)) {
+        dir = resolved;
       }
-    } catch {}
-  }
-  if (!dir) {
-    await sendLongMessage(token, chatState,
-      'Could not find the directory for this server.\n' +
-      'The tmux window may have been removed.\n' +
-      'Use `ocmux resurrect` from the terminal to recover it.');
-    return;
+    }
+    if (!dir) {
+      // Resolve against home or absolute path
+      const resolved = path.resolve(dirArg);
+      if (fs.existsSync(resolved)) dir = resolved;
+    }
+    if (!dir) {
+      await sendLongMessage(token, chatState, `❌ Directory not found: \`${dirArg}\``);
+      return;
+    }
+    // Read the old URL from the state file
+    const state = readState(statefileFor(dir));
+    url = state ? state.url : null;
+  } else {
+    url = chatState.serverBase;
+    if (!url) {
+      await sendLongMessage(token, chatState, '🔌 Not connected to any server. Specify a directory or switch to a server first.');
+      return;
+    }
+    dir = serverDir(url);
+    if (!dir) {
+      try {
+        const savedData = JSON.parse(fs.readFileSync(CONNECTIONS_FILE, 'utf8'));
+        if (savedData && Array.isArray(savedData.connections)) {
+          const match = savedData.connections.find(c =>
+            String(c.chatId) === String(chatId) && (c.threadId || null) === (chatState.threadId || null)
+          );
+          if (match && match.dir) dir = match.dir;
+        }
+      } catch {}
+    }
+    if (!dir) {
+      await sendLongMessage(token, chatState,
+        'Could not find the directory for this server.\n' +
+        'Use `ocmux resurrect` from the terminal or specify a directory: `/resurrect <path>`.');
+      return;
+    }
   }
 
   await sendLongMessage(token, chatState,
@@ -1400,9 +1517,16 @@ async function cmdServe(token, chatId, args, chatState, setServerForChat, setAct
   }
   const sf = statefileFor(targetDir);
   if (fs.existsSync(sf)) {
-    await sendLongMessage(token, chatState,
-      `⚠️ Server already exists for \`${relPath}\`.\n` +
-      'Use `/servers switch <name>` to connect to it.');
+    const status = serverStatus(targetDir);
+    if (status && status.status === 'dead') {
+      await sendLongMessage(token, chatState,
+        `💀 A dead server exists at \`${relPath}\` (${status.url}).\n` +
+        `Use \`/resurrect ${relPath}\` to restart it.`);
+    } else {
+      await sendLongMessage(token, chatState,
+        `⚠️ Server already exists for \`${relPath}\`.\n` +
+        'Use `/servers switch <name>` to connect to it.');
+    }
     return;
   }
   await sendLongMessage(token, chatState,
@@ -1490,6 +1614,26 @@ async function cmdNew(token, chatId, args, chatState, setServerForChat, setActiv
   log.info(`[chat ${chatId}] Created ${targetDir} → ${url}`);
 }
 
+async function cmdMarkdown(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat, replyTo, replyToMsgId) {
+  let entry = null;
+  if (replyToMsgId) {
+    entry = getResponseByMessageId(chatId, chatState.threadId, replyToMsgId);
+    if (!entry) {
+      await sendLongMessage(token, chatState, '❌ Could not find the original response for this message. It may be too old or was not sent by tgagentp.');
+      return;
+    }
+  } else {
+    entry = getRecentResponse(chatId, chatState.threadId, 1);
+    if (!entry) {
+      await sendLongMessage(token, chatState, '❌ No recent responses available. Send a message to the agent first.');
+      return;
+    }
+  }
+  const fileData = Buffer.from(entry.text, 'utf8');
+  const fileName = 'response-' + Date.now() + '.md';
+  await sendTelegramDocument(token, chatState, fileData, fileName, 'Original markdown response');
+}
+
 const COMMANDS = {
   'help': cmdHelp,
   'servers': cmdServers,
@@ -1511,6 +1655,7 @@ const COMMANDS = {
   'answer': cmdAnswer,
   'serve': cmdServe,
   'new': cmdNew,
+  'markdown': cmdMarkdown,
 };
 
 // --------------------------------------------------------------------------
@@ -1519,7 +1664,8 @@ const COMMANDS = {
 
 const serverState = {};
 function getState(url) {
-  return serverState[url] = serverState[url] || { busy: false, serverDead: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, pendingQuestion: null, thinkingEnabled: false, _thinkingBuf: '', messageQueue: [] };
+  const key = normalizeUrl(url);
+  return serverState[key] = serverState[key] || { busy: false, serverDead: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, pendingQuestion: null, thinkingEnabled: false, _thinkingBuf: '', messageQueue: [] };
 }
 
 function sessionLabel(st) {
@@ -1681,6 +1827,9 @@ async function main() {
     serverOwners[url] = { chatId: cs.chatId, threadId: cs.threadId };
     getState(url);
 
+    // Send Telegram bridge awareness note to the new session
+    sendGreeting(cs).catch(() => {});
+
     // Auto-activate tmux window for this server
     const servers = listServers();
     const normalized = normalizeUrl(url);
@@ -1717,12 +1866,48 @@ async function main() {
     return null;
   };
 
-  const setActiveSessionForChat = (chatState, id) => {
+  const setActiveSessionForChat = (chatState, id, name) => {
     const server = chatState.serverBase;
+    const prevId = getState(server).activeSessionId;
     getState(server).activeSessionId = id;
-    log.info(`[chat ${chatState.chatId}] Switched to session: ${id}`);
+    if (name) getState(server).activeSessionName = name;
+    log.info(`[chat ${chatState.chatId}] Switched to session: ${name || id}`);
+    if (id !== prevId) sendGreeting(chatState);
   };
 
+  const TELEGRAM_GREETING_BODY = (sessionName) =>
+    '[Telegram] The following information is for your awareness. Reply with only "Ack" and do not take any action:\n\n' +
+    'Your responses are being relayed through a Telegram bridge ' +
+    '(current session: ' + sessionName + ').\n' +
+    'The user sees your messages and can reply from there. ' +
+    'Their messages appear here prefixed with [Telegram].\n\n' +
+    'You can use these structured commands in your own response text ' +
+    '(on their own line, with no other content on that line). ' +
+    'Do NOT use CLI tools to generate them — just include them directly in your response:\n\n' +
+    'To send a file to the user:\n' +
+    '[Telegram]{"command":"upload","path":"<relative-path>","msg":"<optional caption>"}\n\n' +
+    'To download a file the user sent:\n' +
+    '[Telegram]{"command":"download","fileId":"<id>","path":"<relative-destination>"}\n\n' +
+    'For more details about a command:\n' +
+    '[Telegram]{"command":"help","topic":"<upload|download|help>"}';
+
+  async function sendGreeting(chatState) {
+    const st = getState(chatState.serverBase);
+    if (!st.activeSessionId) {
+      try {
+        const discovered = await discoverActiveSession(chatState.serverBase);
+        if (discovered) { st.activeSessionId = discovered.id; st.activeSessionName = discovered.name; }
+      } catch {}
+    }
+    if (!st.activeSessionId) return;
+    const greeting = TELEGRAM_GREETING_BODY(st.activeSessionName || st.activeSessionId);
+    try {
+      await sendToSession(chatState.serverBase, st.activeSessionId, greeting);
+    } catch (err) {
+      log.debug(`sendGreeting error: ${err.message}`);
+    }
+  }
+
   // Start agentp gateway (tiny HTTP server for agentp --tg)
   const serverBaseResolver = () => {
     const entries = Object.entries(serverOwners);
@@ -1813,7 +1998,7 @@ async function main() {
         }, cancelRef).catch(() => {});
         await onConnected;
         answer = await sendToSession(url, sessionId, `[Telegram] ${text}`, st.activeAgentName, sessionCancelRef);
-        if (st._thinkingBuf) {
+        if (st.thinkingEnabled && st._thinkingBuf) {
           const html = '💭 ' + st._thinkingBuf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
           sendLongMessage(token, chatState, html, replyTo, threadId).catch(() => {});
           st._thinkingBuf = '';
@@ -1834,9 +2019,13 @@ async function main() {
       if (url === chatServer) {
         if (answer && answer.trim()) {
           const trimmed = answer.trim();
-          msgLog('out', chatId, '', trimmed);
-          await sendLongMessage(token, chatState, trimmed, replyTo, threadId);
-          bufferMessage(chatId, threadId, 'assistant', trimmed);
+          const cleaned = await processTelegramCommands(trimmed, url, token, chatState);
+          msgLog('out', chatId, '', cleaned);
+          if (cleaned) {
+            const msgIds = await sendLongMessage(token, chatState, cleaned, replyTo, threadId);
+            if (msgIds && msgIds.length > 0) recordResponseMessage(chatId, threadId, msgIds, cleaned);
+            bufferMessage(chatId, threadId, 'assistant', cleaned);
+          }
         }
       } else {
         getState(url).pendingResponse = answer;
@@ -1869,7 +2058,7 @@ async function main() {
         const msg = isConnError
           ? `⚠️ Server \`${url}\` is unreachable. The message has been requeued and will be sent when the server is available again.\n\n` +
             `**Options:**\n` +
-            `• Start the server: \`ocmux serve\`\n` +
+            `• Restart it: \`/resurrect\`\n` +
             `• Switch to another server: \`/servers switch <name>\`\n` +
             `• Flush the queue: \`/flush\``
           : `Error: ${err.message}`;
@@ -2100,7 +2289,7 @@ async function main() {
             await sendLongMessage(token, cs,
               '🔄 Bot started. Previously connected to `' + dir + '`.\n' +
               '⚠️ The server at `' + state.url + '` is not reachable.\n' +
-              'Options: start the server with `ocmux serve`, or switch with `/servers switch <name>`.');
+              'Use `/resurrect` to restart it, or `/servers switch <name>` to connect elsewhere.');
           } catch (_) {}
         }
       }
@@ -2215,21 +2404,6 @@ async function main() {
         }
         try {
           const notification = await handleFileUpload(token, msg, projectDir);
-          // Verify the file is actually on disk before notifying
-          const relativePath = notification.match(/`([^`]+)`/)?.[1];
-          if (relativePath) {
-            const fullPath = path.join(projectDir, relativePath);
-            let retries = 5;
-            while (!fs.existsSync(fullPath) && retries > 0) {
-              await new Promise(r => setTimeout(r, 100));
-              retries--;
-            }
-            if (!fs.existsSync(fullPath)) {
-              log.error(`File not found after upload: ${fullPath}`);
-              await sendLongMessage(token, cs, `❌ File upload failed: file not saved to disk.`);
-              continue;
-            }
-          }
           const userText = msg.caption || msg.text || '';
           const fullMessage = notification + (userText ? '\n\nUser message: ' + userText : '');
           log.debug(`[chat ${chatId}] ${from}: [file upload]`);
@@ -2251,7 +2425,7 @@ async function main() {
               `⚠️ Server \`${cs.serverBase}\` is not reachable.\n\n` +
               `Your file upload has been queued (#${qlen}). It will be sent when the server becomes available.\n\n` +
               `**Options:**\n` +
-              `• Start the server: \`ocmux serve\`\n` +
+              `• Restart it: \`/resurrect\`\n` +
               `• Switch to another server: \`/servers switch <name>\`\n` +
               `• Flush the queue: \`/flush\``);
             continue;
@@ -2330,11 +2504,16 @@ async function main() {
                 fileName = 'photo.jpg';
                 fileSize = largest.file_size || 0;
               }
-              const fileData = await downloadTelegramFile(token, fileId);
-              ensureSharedDir(projectDir);
-              const relativePath = saveUploadedFile(projectDir, fileName, fileData);
               const sizeStr = fileSize > 0 ? ` (${formatFileSize(fileSize)})` : '';
-              await sendLongMessage(token, cs, `📎 File downloaded: \`${relativePath}\`${sizeStr}`);
+              const notification = `📎 File available: \`${fileName}\`${sizeStr}\n` +
+                `Use \`[Telegram]{"command":"download","fileId":"${fileId}","path":"<destination>"}\` to save it.`;
+              await sendLongMessage(token, cs, notification);
+              // Also send the notification to the agent's session so it knows the fileId
+              const st = getState(cs.serverBase);
+              if (st.activeSessionId) {
+                sendToSession(cs.serverBase, st.activeSessionId,
+                  '[Telegram] ' + notification).catch(() => {});
+              }
             } catch (err) {
               log.error(`Download on reply error: ${err.message}`);
               await sendLongMessage(token, cs, `❌ File download failed: ${err.message}`);
@@ -2372,7 +2551,12 @@ async function main() {
         try {
           const answer = await executeTuiCommand(paneId, cs.serverBase, tuiCmd);
           if (answer && answer.trim()) {
-            await sendLongMessage(token, cs, answer.trim());
+            const cleaned = await processTelegramCommands(answer.trim(), cs.serverBase, token, cs);
+            if (cleaned) {
+              await sendLongMessage(token, cs, cleaned);
+            } else {
+              await sendLongMessage(token, cs, `✅ \`${tuiCmd}\` submitted.`);
+            }
           } else {
             await sendLongMessage(token, cs, `✅ \`${tuiCmd}\` submitted.`);
           }
@@ -2392,22 +2576,23 @@ async function main() {
         const cmdArgs = parts.slice(1);
         const handler = cmds[cmd];
         if (handler) {
-          // Disconnected guard: only /help, /servers, /force-switch, /start, /comment, /shutdown, /serve, and /new work without a server
-          if (!cs.serverBase && cmd !== 'help' && cmd !== 'servers' && cmd !== 'force-switch' && cmd !== 'start' && cmd !== 'comment' && cmd !== 'shutdown' && cmd !== 'serve' && cmd !== 'new') {
+          // Disconnected guard: only /help, /servers, /force-switch, /start, /comment, /shutdown, /serve, /new, and /resurrect work without a server
+          if (!cs.serverBase && cmd !== 'help' && cmd !== 'servers' && cmd !== 'force-switch' && cmd !== 'start' && cmd !== 'comment' && cmd !== 'shutdown' && cmd !== 'serve' && cmd !== 'new' && cmd !== 'resurrect') {
             await sendLongMessage(token, cs,
               '🔌 Not connected to any server.\n\n' +
               'Use `/servers` to see available servers and `/servers switch <name>` to connect.');
             continue;
           }
           try {
-            await handler(token, chatId, cmdArgs, cs, setServerForChat, setActiveSessionForChat);
+            const replyToMsgId = msg.reply_to_message ? msg.reply_to_message.message_id : 0;
+            await handler(token, chatId, cmdArgs, cs, setServerForChat, setActiveSessionForChat, replyTo, replyToMsgId);
           } catch (err) {
             log.error(`Error handling /${cmd}: ${err.message}`);
             try { await sendLongMessage(token, cs, `Error: ${err.message}`); } catch (_) {}
           }
         } else {
           await sendLongMessage(token, cs,
-            `Unknown command: /${cmd}\n\nAvailable commands: /help, /status, /servers, /sessions, /agents, /models, /think, /record, /queue, /flush, /note, /comment, /disconnect, /serve, /new`);
+            `Unknown command: /${cmd}\n\nAvailable commands: /help, /status, /servers, /sessions, /agents, /models, /think, /record, /queue, /flush, /note, /comment, /disconnect, /serve, /new, /markdown`);
         }
         continue;
       }
@@ -2441,7 +2626,7 @@ async function main() {
         const qlen = st.messageQueue.length;
         const servers = listServers();
         const suggestions = [];
-        suggestions.push(`• Start the server: \`ocmux serve\``);
+        suggestions.push(`• Restart it: \`/resurrect\``);
         if (servers.length > 0) {
           suggestions.push(`• Switch to another server: \`/servers switch <name>\``);
         }
@@ -2476,7 +2661,11 @@ process.on('SIGINT', () => {
   process.exit(0);
 });
 
-main().catch((err) => {
-  console.error('Error:', err.message);
-  process.exit(1);
-});
+if (require.main === module) {
+  main().catch((err) => {
+    console.error('Error:', err.message);
+    process.exit(1);
+  });
+}
+
+module.exports = { processTelegramCommands, parseTelegramLine, getHelpText, normalizeUrl };

package/lib/ocmux.js

@@ -130,6 +130,37 @@ function listServers() {
   return rows;
 }
 
+// Check the state of a server in a given directory.
+// Returns null if no .ocmux.json exists, or an object with status.
+function serverStatus(dir) {
+  const sf = statefileFor(dir);
+  const state = readState(sf);
+  if (!state || !state.url) return null;
+  const winIdx = windowByDir(dir);
+  const tui = winIdx != null ? tuiPaneId(winIdx) : null;
+  return {
+    dir,
+    url: state.url,
+    status: winIdx != null ? 'alive' : 'dead',
+    windowIndex: winIdx,
+    hasTui: tui != null,
+  };
+}
+
+// List dead servers by scanning known directories for orphaned .ocmux.json files.
+// dirs: array of directories to check (e.g. from connections file).
+// Returns entries with status 'dead' that are not already in listServers().
+function listDeadServers(knownDirs) {
+  const alive = new Set(listServers().map(s => s.dir));
+  const dead = [];
+  for (const dir of knownDirs) {
+    if (alive.has(dir)) continue;
+    const status = serverStatus(dir);
+    if (status) dead.push(status);
+  }
+  return dead;
+}
+
 // Switch tmux focus to the given server window and ensure the TUI pane is alive and zoomed.
 function activateServer(dir, index, url) {
   const winIdx = index;
@@ -182,6 +213,7 @@ function activateServer(dir, index, url) {
 
 // Recover a dead/crashed server: kill old window, remove state file,
 // create fresh server + TUI in the same directory.
+// Delegates to startServer for the actual server creation.
 // Returns { url, dir } on success, throws on error.
 function resurrectServer(dir, printLogs) {
   const sf = path.join(dir, '.ocmux.json');
@@ -209,7 +241,14 @@ function resurrectServer(dir, printLogs) {
   // Remove old state file so we can create a fresh one
   try { fs.unlinkSync(sf); } catch {}
 
-  // Create fresh server + TUI
+  // Start fresh server (same logic as ocmux serve)
+  return startServer(dir, printLogs);
+}
+
+// Start a new opencode server in the given directory.
+// Creates a tmux window, starts opencode serve, waits for the URL,
+// and writes .ocmux.json. Returns { url, dir } on success.
+function startServer(dir, printLogs) {
   ensureSession();
   const lf = logfileFor(dir);
 
@@ -223,16 +262,16 @@ function resurrectServer(dir, printLogs) {
 
   try { fs.truncateSync(lf); } catch {}
 
-  const serveFlags = printLogs ? '--port 0 --print-logs' : '--port 0';
+  const serveFlags = printLogs ? '--print-logs' : '';
   _tmux(['send-keys', '-t', `${SESSION}:${winIdx}.0`,
-    `opencode serve ${serveFlags} 2>&1 | tee '${lf}'`, 'Enter']);
+    'opencode serve' + (serveFlags ? ' ' + serveFlags : '') + ` 2>&1 | tee '${lf}'`, 'Enter']);
 
   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];
+    if (m) { url = m[1]; break; }
   }
 
   if (!url) {
@@ -242,7 +281,7 @@ function resurrectServer(dir, printLogs) {
   }
 
   const newState = { url, logfile: lf, window_index: winIdx };
-  fs.writeFileSync(sf, JSON.stringify(newState) + '\n');
+  fs.writeFileSync(path.join(dir, '.ocmux.json'), JSON.stringify(newState) + '\n');
 
   const splitResult = _tmux(['split-window', '-v', '-P', '-F', '#{pane_id}', '-t', `${SESSION}:${winIdx}`, '-c', dir]);
   const tuiPane = splitResult.stdout.trim();
@@ -278,4 +317,7 @@ module.exports = {
   ensureSession,
   pinWindowName,
   resurrectServer,
+  startServer,
+  serverStatus,
+  listDeadServers,
 };

package/lib/telegram-format.js

@@ -104,10 +104,13 @@ async function sendLongMessage(token, chatIdOrState, text, replyTo, threadId) {
     ? chatIdOrState.chatId : chatIdOrState;
   const effectiveThreadId = threadId || (typeof chatIdOrState === 'object' ? chatIdOrState.threadId : undefined);
   const chunks = splitMessage(text);
+  let msgIds = [];
   for (let i = 0; i < chunks.length; i++) {
     const html = convertMarkdownToHtml(chunks[i]);
-    await sendTelegramMessage(token, chatId, html, 'HTML', i === 0 ? replyTo : undefined, effectiveThreadId);
+    const result = await sendTelegramMessage(token, chatId, html, 'HTML', i === 0 ? replyTo : undefined, effectiveThreadId);
+    if (result && result.result) msgIds.push(result.result.message_id);
   }
+  return msgIds;
 }
 
 module.exports = {

package/package.json

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