agentp 0.9.0 → 0.11.0

package/bin/tgagentp

@@ -5,7 +5,7 @@ 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, sendToSessionAsync, respondToPermission, listenForSessionEvents, listAgents, listProviders } = require('../lib/opencode.js');
+const { getAuthHeaders, sendText, listenForFinalAnswer, listSessions, createSession, updateSession, selectSession, sendToSession, sendToSessionAsync, respondToPermission, listenForSessionEvents, listAgents, listProviders, isServerAlive } = require('../lib/opencode.js');
 
 // Logger: info→stdout, error→stderr (always), debug→stderr (--verbose only)
 const log = {
@@ -15,11 +15,35 @@ const log = {
   debug(msg) { if (this.verbose) process.stderr.write(`${msg}\n`); },
 };
 
-const STARTUP_CHAT_FILE = '/tmp/tgagentp-startup-chat';
 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 { listServers, activateServer } = require('../lib/ocmux.js');
+const CONNECTIONS_FILE = '/tmp/tgagentp-connections.json';
+const { listServers, activateServer, resurrectServer, statefileFor, readState } = require('../lib/ocmux.js');
+
+// Persist chat↔server directory mappings across restarts
+function saveConnection(chatId, threadId, dir) {
+  let data = { connections: [] };
+  try { data = JSON.parse(fs.readFileSync(CONNECTIONS_FILE, 'utf8')); } catch {}
+  const key = convKey(chatId, threadId);
+  const idx = data.connections.findIndex(c => convKey(c.chatId, c.threadId) === key);
+  const entry = { chatId, threadId: threadId || null, dir };
+  if (idx !== -1) data.connections[idx] = entry;
+  else data.connections.push(entry);
+  try { fs.writeFileSync(CONNECTIONS_FILE, JSON.stringify(data, null, 2)); } catch {}
+}
+
+function removeConnection(chatId, threadId) {
+  let data = { connections: [] };
+  try { data = JSON.parse(fs.readFileSync(CONNECTIONS_FILE, 'utf8')); } catch {}
+  const key = convKey(chatId, threadId);
+  data.connections = data.connections.filter(c => convKey(c.chatId, c.threadId) !== key);
+  try { fs.writeFileSync(CONNECTIONS_FILE, JSON.stringify(data, null, 2)); } catch {}
+}
+
+function clearConnections() {
+  try { fs.unlinkSync(CONNECTIONS_FILE); } catch {}
+}
 
 // Agentp gateway message queue, keyed by server URL
 const agentpQueues = {};
@@ -32,23 +56,89 @@ function validateAgentpAuth(req) {
   return req.headers.authorization === expected;
 }
 
-function flushAgentpQueue(server, token, chatId) {
+function flushAgentpQueue(server, token, chatId, threadId) {
   if (!chatId) return;
   const q = agentpQueues[server];
   if (!q || q.messages.length === 0) return;
   const msgs = q.messages.splice(0);
   q.notified = false;
   if (q.notifyTimer) { clearTimeout(q.notifyTimer); q.notifyTimer = null; }
-  sendLongMessage(token, chatId,
-    `📨 Delivering ${msgs.length} queued agentp message(s):`)
+  const cs = { chatId, threadId };
+  sendLongMessage(token, cs,
+    `📨 Delivering ${msgs.length} queued agentp message(s):`, undefined, threadId)
     .then(() => {
       for (const msg of msgs) {
-        sendLongMessage(token, chatId, msg.trim()).catch(() => {});
+        sendLongMessage(token, cs, msg.trim(), undefined, threadId).catch(() => {});
       }
     })
     .catch(() => {});
 }
 
+// Check if an opencode server is reachable by hitting its /session endpoint.
+// Uses a short 5s timeout; returns true for any HTTP response (even 4xx/5xx)
+// and false only for connection-level failures (dead server, DNS, timeout).
+// ---------------------------------------------------------------------------
+// Per-chat state
+// ---------------------------------------------------------------------------
+
+const MAX_RECORDED_MSGS = 100;
+const MAX_RECORDED_BYTES = 100 * 1024;
+
+const chatStates = {};
+const serverOwners = {}; // serverUrl → { chatId, threadId } (for agentp gateway routing)
+
+// Compound key for isolated chat+thread (forum topic) state
+function convKey(chatId, threadId) {
+  return threadId ? `${chatId}:t${threadId}` : chatId;
+}
+
+function getChatState(chatId, threadId, defaultServer) {
+  const key = convKey(chatId, threadId);
+  if (!chatStates[key]) {
+    chatStates[key] = {
+      chatId,
+      threadId: threadId || null,
+      serverBase: defaultServer || null,
+      recording: { active: false, paused: false, messages: [], bytes: 0 },
+      ring: { messages: [], bytes: 0 },
+    };
+  }
+  return chatStates[key];
+}
+
+const RING_MAX_MSGS = 50;
+const RING_MAX_BYTES = 50 * 1024;
+
+function bufferMessage(chatId, threadId, role, text) {
+  const cs = getChatState(chatId, threadId);
+
+  // Always maintain an in-memory ring buffer of recent messages.
+  // This enables retroactive /record N: copy last N messages into recording.
+  cs.ring.messages.push({ role, text });
+  cs.ring.bytes += Buffer.byteLength(text, 'utf8');
+  while (cs.ring.messages.length > RING_MAX_MSGS || cs.ring.bytes > RING_MAX_BYTES) {
+    const oldest = cs.ring.messages.shift();
+    cs.ring.bytes -= Buffer.byteLength(oldest.text, 'utf8');
+  }
+
+  // Recording buffer (only when active AND not paused)
+  if (!cs.recording.active || cs.recording.paused) return;
+  cs.recording.messages.push({ role, text });
+  cs.recording.bytes += Buffer.byteLength(text, 'utf8');
+  while (cs.recording.messages.length > MAX_RECORDED_MSGS || cs.recording.bytes > MAX_RECORDED_BYTES) {
+    const oldest = cs.recording.messages.shift();
+    cs.recording.bytes -= Buffer.byteLength(oldest.text, 'utf8');
+  }
+}
+
+function flushRecorded(chatId, threadId) {
+  const cs = getChatState(chatId, threadId);
+  if (!cs.recording.active) return [];
+  const msgs = cs.recording.messages.splice(0);
+  cs.recording.bytes = 0;
+  return msgs;
+}
+
 // ---------------------------------------------------------------------------
 // Telegram Bot API helpers
 // ---------------------------------------------------------------------------
@@ -91,10 +181,11 @@ function getUpdates(token, offset, timeout) {
   });
 }
 
-function sendTelegramMessage(token, chatId, text, parseMode, replyTo) {
+function sendTelegramMessage(token, chatId, text, parseMode, replyTo, threadId) {
   const params = { chat_id: chatId, text };
   if (parseMode) params.parse_mode = parseMode;
   if (replyTo) params.reply_to_message_id = replyTo;
+  if (threadId) params.message_thread_id = threadId;
   return telegramRequest(token, 'sendMessage', params);
 }
 
@@ -202,11 +293,15 @@ function splitMessage(text, maxLength = 4096) {
 // Converts Markdown to Telegram HTML formatting.
 // Splits the raw text first, then converts each chunk independently
 // to avoid broken HTML tags across messages.
-async function sendLongMessage(token, chatId, text, replyTo) {
+async function sendLongMessage(token, chatIdOrState, text, replyTo, threadId) {
+  // Accept either (token, chatState, ...) or (token, rawChatId, ...)
+  const chatId = typeof chatIdOrState === 'object' && chatIdOrState.chatId != null
+    ? chatIdOrState.chatId : chatIdOrState;
+  const effectiveThreadId = threadId || (typeof chatIdOrState === 'object' ? chatIdOrState.threadId : undefined);
   const chunks = splitMessage(text);
   for (let i = 0; i < chunks.length; i++) {
     const html = convertMarkdownToHtml(chunks[i]);
-    await sendTelegramMessage(token, chatId, html, 'HTML', i === 0 ? replyTo : undefined);
+    await sendTelegramMessage(token, chatId, html, 'HTML', i === 0 ? replyTo : undefined, effectiveThreadId);
   }
 }
 
@@ -226,7 +321,7 @@ function quoteReply(msg) {
     if (rm.text[i] === '`') { cur++; maxBackticks = Math.max(maxBackticks, cur); }
     else cur = 0;
   }
-  const fence = '`'.repeat(maxBackticks + 1);
+  const fence = '`'.repeat(Math.max(3, maxBackticks + 1));
   return `In response to ${replyFrom} (${senderType}):\n\n${fence}\n${rm.text}\n${fence}\n\n`;
 }
 
@@ -234,18 +329,20 @@ function quoteReply(msg) {
 // Telegram command handlers
 // ---------------------------------------------------------------------------
 
-async function cmdHelp(token, chatId, args) {
+async function cmdHelp(token, chatId, args, chatState) {
   if (args.length > 0) {
     const topic = args[0].toLowerCase();
     if (topic === 'servers') {
-      await sendLongMessage(token, chatId,
+      await sendLongMessage(token, chatState,
         '`/servers` ─ list all opencode servers (ocmux sessions)\n' +
-        '`/servers switch <name>` ─ switch target server\n\n' +
+        '`/servers switch <name>` ─ switch target server\n' +
+        '`/force-switch <name>` ─ take over a server from another chat\n\n' +
+        'Name matching: case-insensitive first, then case-sensitive. ' +
         '`<name>` can be a full path or basename of the project directory.');
       return;
     }
     if (topic === 'sessions') {
-      await sendLongMessage(token, chatId,
+      await sendLongMessage(token, chatState,
         '`/sessions` ─ list active sessions (numbered, newest first, max 50)\n' +
         '`/sessions switch <number-or-name>` ─ send messages to a specific session\n' +
         '`/sessions new [name]` ─ create a new session\n' +
@@ -255,7 +352,7 @@ async function cmdHelp(token, chatId, args) {
       return;
     }
     if (topic === 'shutdown') {
-      await sendLongMessage(token, chatId,
+      await sendLongMessage(token, chatState,
         '`/shutdown` ─ stop tgagentp process\n' +
         '`/shutdown force` ─ force shutdown even if busy (in-flight work will be lost)\n\n' +
         'Only available when tgagentp is started with `--dev` flag.\n' +
@@ -264,14 +361,14 @@ async function cmdHelp(token, chatId, args) {
       return;
     }
     if (topic === 'agents') {
-      await sendLongMessage(token, chatId,
+      await sendLongMessage(token, chatState,
         '`/agents` ─ list primary agents (with ▶ marker for the active one).\n' +
         '`/agents switch <name>` ─ switch the active agent. Subsequent messages will use this agent.\n\n' +
         'Agent switching requires an active session (`/sessions switch` or `/sessions new`).');
       return;
     }
     if (topic === 'session') {
-      await sendLongMessage(token, chatId,
+      await sendLongMessage(token, chatState,
         '`/session` is an alias for `/sessions`.\n\n' +
         '`/sessions` ─ list active sessions\n' +
         '`/sessions switch <number-or-name>` ─ switch to a session\n' +
@@ -280,14 +377,14 @@ async function cmdHelp(token, chatId, args) {
       return;
     }
     if (topic === 'models') {
-      await sendLongMessage(token, chatId,
+      await sendLongMessage(token, chatState,
         '`/models` ─ list all providers and their models.\n' +
         'Shows provider name, connection status, default model, and up to 5 models per provider\n' +
         'with status, context limit, and input/output costs.');
       return;
     }
     if (topic === 'allow' || topic === 'reject' || topic === 'always') {
-      await sendLongMessage(token, chatId,
+      await sendLongMessage(token, chatState,
         '`/allow` ─ approve a permission request once\n' +
         '`/reject` ─ deny a permission request\n' +
         '`/always` ─ approve and remember for the session\n\n' +
@@ -297,7 +394,7 @@ async function cmdHelp(token, chatId, args) {
       return;
     }
     if (topic === 'think') {
-      await sendLongMessage(token, chatId,
+      await sendLongMessage(token, chatState,
         '`/think` ─ toggle thinking message forwarding\n' +
         '`/think on` ─ forward model thinking to the chat in real-time\n' +
         '`/think off` ─ stop forwarding thinking messages (default)\n' +
@@ -307,17 +404,88 @@ async function cmdHelp(token, chatId, args) {
         'Can also be enabled at startup with `--think` flag.');
       return;
     }
-    await sendLongMessage(token, chatId,
-      'Unknown topic. Try `/help servers`, `/help sessions`, `/help session`, `/help agents`, `/help models`, `/help allow`, `/help think`, or just `/help`.');
+    if (topic === 'queue') {
+      await sendLongMessage(token, chatState,
+        '`/queue <message>` ─ queue a message when the server is busy\n\n' +
+        'When the server is processing a previous message, queuing allows you to\n' +
+        'continue working without waiting. Once the current task finishes, the next\n' +
+        'queued message is automatically sent and the answer will reply to the\n' +
+        'original queued message.\n\n' +
+        'Messages are also automatically queued when the server is unreachable.\n' +
+        'Use `/flush` to clear the queue at any time.');
+      return;
+    }
+    if (topic === 'flush') {
+      await sendLongMessage(token, chatState,
+        '`/flush` ─ clear all queued messages\n\n' +
+        'Flushes both the regular message queue and any queued agentp messages.\n' +
+        'Messages are queued automatically when the server is unreachable or busy.');
+      return;
+    }
+    if (topic === 'comment') {
+      await sendLongMessage(token, chatState,
+        '`/comment <text>` ─ save a comment in the chat\n\n' +
+        'Comments are NOT forwarded to the agent. They are stored as a regular message\n' +
+        'in the chat. If you reply to a comment with a message that doesn\'t start with\n' +
+        '`/comment`, the comment text is included as context (via the reply-to quoting mechanism).');
+      return;
+    }
+    if (topic === 'note') {
+      await sendLongMessage(token, chatState,
+        '`/note <message>` ─ send context for the agent to acknowledge\n\n' +
+        'The message is forwarded to the agent with an awareness prefix. ' +
+        'The agent will reply with "Ack" and take no action, ' +
+        'but the information will inform future responses.');
+      return;
+    }
+    if (topic === 'disconnect') {
+      await sendLongMessage(token, chatState,
+        '`/disconnect` ─ disconnect this chat from its server\n\n' +
+        'Clears the server connection for this chat. Use `/servers switch <name>` to reconnect.');
+      return;
+    }
+    if (topic === 'status') {
+      await sendLongMessage(token, chatState,
+        '`/status` ─ show current server, session, agent, and queue info\n\n' +
+        'Shows:\n' +
+        '• Server URL and directory path\n' +
+        '• Status: ✅ idle, ⏳ busy, or ❌ unreachable\n' +
+        '• Active session name/ID\n' +
+        '• Active agent name\n' +
+        '• Number of queued messages');
+      return;
+    }
+    if (topic === 'record') {
+      await sendLongMessage(token, chatState,
+        '`/record` ─ toggle between active/paused (starts fresh if inactive)\n' +
+        '`/record continue` ─ resume recording without clearing buffer\n' +
+        '`/record pause [N]` ─ pause recording, keep buffer (optionally discard last N)\n' +
+        '`/record flush` ─ clear buffer, keep current state (active/paused)\n' +
+        '`/record stop` ─ fully stop and clear buffer\n' +
+        '`/record N` ─ retroactively buffer the last N messages from the ring\n\n' +
+        '**States:**\n' +
+        '🔴 *active* — new messages are added to the buffer\n' +
+        '⏸ *paused* — buffer preserved, not recording new messages\n' +
+        '⏹ *inactive* — no buffer, nothing recorded\n\n' +
+        'When active or paused, the next `agentp` invocation retrieves the buffered\n' +
+        'conversation and prepends it to its `--qa` stdout output.\n' +
+        '`/record N` uses the always-on ring buffer (last 50 messages) to retroactively\n' +
+        'fill the recording buffer — as if `/record` had been enabled N messages ago.\n\n' +
+        'Max 100 messages / 100KB. Oldest messages are dropped first.');
+      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`, or just `/help`.');
     return;
   }
-  await sendLongMessage(token, chatId,
+  await sendLongMessage(token, chatState,
     '`/help` ─ show this message\n' +
     '`/help <topic>` ─ detailed help\n' +
     '`/status` ─ show current server and session\n' +
     '`/cancel` ─ cancel the running prompt\n' +
     '`/servers` ─ list running opencode servers\n' +
     '`/servers switch <name>` ─ switch to a different server\n' +
+    '`/force-switch <name>` ─ take over a server from another chat\n' +
     '`/sessions` ─ list/create/switch/rename sessions\n' +
     '`/sessions switch <number-or-name>` ─ switch to a session\n' +
     '`/sessions new [name]` ─ create a new session\n' +
@@ -327,51 +495,99 @@ async function cmdHelp(token, chatId, args) {
     '`/agents switch <name>` ─ switch active agent\n' +
     '`/models` ─ list providers and models\n' +
     '`/think` ─ toggle thinking message forwarding\n' +
+    '`/record` ─ record Telegram conversation for agentp context\n' +
+    '`/queue <message>` ─ queue a message when server is busy\n' +
+    '`/flush` ─ clear all queued messages\n' +
+    '`/note <message>` ─ send context for the agent to acknowledge\n' +
+    '`/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' +
     '`/shutdown` ─ stop tgagentp (only with `--dev` flag)\n\n' +
     'Everything else is forwarded to the active server as `[Telegram] <text>`.');
 }
 
-async function cmdServers(token, chatId, args, setServer, setActiveSession, serverBase) {
-  if (args.length > 0 && args[0].toLowerCase() === 'switch') {
-    if (args.length < 2) {
-      await sendLongMessage(token, chatId,
+async function cmdForceSwitch(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  return cmdServers(token, chatId, ['switch', '--force', ...args], chatState, setServerForChat, setActiveSessionForChat);
+}
+
+async function cmdServers(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const isForce = args.length > 0 && args[0].toLowerCase() === 'force-switch';
+  if (args.length > 0 && (args[0].toLowerCase() === 'switch' || isForce)) {
+    const forceIdx = args.indexOf('--force');
+    const force = forceIdx !== -1 || isForce;
+    const switchArgs = args.slice(1).filter(a => a !== '--force');
+    if (switchArgs.length < 1) {
+      await sendLongMessage(token, chatState,
         'Usage: `/servers switch <name>`\n' +
+        'To force-switch (take over a server from another chat), use `/force-switch <name>`.\n' +
         '`<name>` can be a full directory path or a basename.');
       return;
     }
-    const name = args.slice(1).join(' ');
+    const name = switchArgs.join(' ');
     const servers = listServers();
     if (servers.length === 0) {
-      await sendLongMessage(token, chatId, 'No servers running.');
+      await sendLongMessage(token, chatState, 'No servers running.');
       return;
     }
-    let matches = servers.filter(s => s.dir === name);
+
+    // Phase 1: case-insensitive exact match on dir or basename
+    let matches = servers.filter(s => s.dir.toLowerCase() === name.toLowerCase());
     if (matches.length === 0) {
-      matches = servers.filter(s => path.basename(s.dir) === name);
+      matches = servers.filter(s => path.basename(s.dir).toLowerCase() === name.toLowerCase());
     }
+    // Fallback: case-insensitive substring match
     if (matches.length === 0) {
-      matches = servers.filter(s => s.dir.includes(name) || path.basename(s.dir).includes(name));
+      const lowerName = name.toLowerCase();
+      matches = servers.filter(s => s.dir.toLowerCase().includes(lowerName) || path.basename(s.dir).toLowerCase().includes(lowerName));
     }
-    if (matches.length === 0) {
-      await sendLongMessage(token, chatId, `No server found matching "${name}".`);
+
+    if (matches.length === 1) {
+      // Phase 1 found a single match — use it directly
+    } else if (matches.length === 0) {
+      await sendLongMessage(token, chatState, `No server found matching "${name}".`);
       return;
+    } else {
+      // Phase 2: case-sensitive exact match to disambiguate
+      let exact = servers.filter(s => s.dir === name);
+      if (exact.length === 0) {
+        exact = servers.filter(s => path.basename(s.dir) === name);
+      }
+      if (exact.length === 1) {
+        matches = exact;
+      } else {
+        const list = matches.map(s => `  ${s.url} → ${s.dir}`).join('\n');
+        await sendLongMessage(token, chatState,
+          `Multiple matches for "${name}":\n${list}\n\nPlease be more specific.`);
+        return;
+      }
     }
-    if (matches.length > 1) {
-      const list = matches.map(s => `  ${s.url} → ${s.dir}`).join('\n');
-      await sendLongMessage(token, chatId,
-        `Multiple matches for "${name}":\n${list}\n\nPlease be more specific.`);
+    const target = matches[0];
+    const existing = serverOwners[target.url];
+    if (existing && existing.chatId !== chatState.chatId && !force) {
+      await sendLongMessage(token, chatState,
+        `⚠️ Server \`${target.url}\` is already connected to another chat.\n\n` +
+        `Use \`/servers force-switch ${name}\` to take over (the other chat will be disconnected).`);
       return;
     }
-    const target = matches[0];
-    const pending = await setServer(target.url);
+    if (existing && existing.chatId === chatState.chatId) {
+      // Already connected — re-run setup to refresh state
+    }
+    if (force && existing && existing.chatId !== chatState.chatId) {
+      // Reset the old owner's server and notify them
+      const oldState = getChatState(existing.chatId, existing.threadId);
+      oldState.serverBase = null;
+      sendLongMessage(token, oldState,
+        `⚠️ Server \`${target.url}\` has been taken over by another chat.\n\n` +
+        `Use \`/servers\` to see available servers and reconnect.`).catch(() => {});
+    }
+    const pending = await setServerForChat(chatState, target.url);
     activateServer(target.dir, target.index, target.url);
     let msg = `Switched to server: ${target.url} → ${target.dir}`;
     if (pending && pending.trim()) {
-      await sendLongMessage(token, chatId, msg);
-      await sendLongMessage(token, chatId, pending.trim());
+      await sendLongMessage(token, chatState, msg);
+      await sendLongMessage(token, chatState, pending.trim());
     } else {
-      await sendLongMessage(token, chatId, msg);
+      await sendLongMessage(token, chatState, msg);
     }
     return;
   }
@@ -379,15 +595,16 @@ async function cmdServers(token, chatId, args, setServer, setActiveSession, serv
   // Default: list servers
   const servers = listServers();
   if (servers.length === 0) {
-    await sendLongMessage(token, chatId, 'No servers running.');
+    await sendLongMessage(token, chatState, 'No servers running.');
     return;
   }
-  const activeUrl = normalizeUrl(serverBase);
+  const activeUrl = chatState.serverBase ? normalizeUrl(chatState.serverBase) : null;
   const lines = servers.map(s => {
-    const bullet = normalizeUrl(s.url) === activeUrl ? '▶ ' : ' · ';
+    const bullet = activeUrl && normalizeUrl(s.url) === activeUrl ? '▶ ' : ' · ';
     return bullet + `${s.url} → ${s.dir} (${s.status})`;
   });
-  await sendLongMessage(token, chatId, 'Active servers:\n' + lines.join('\n'));
+  const prefix = chatState.serverBase ? 'Active servers:' : 'Available servers:';
+  await sendLongMessage(token, chatState, prefix + '\n' + lines.join('\n'));
 }
 
 function sessionName(s) {
@@ -428,7 +645,8 @@ async function discoverActiveSession(server) {
   }
 }
 
-async function cmdSessions(token, chatId, args, setServer, setActiveSession, server) {
+async function cmdSessions(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const server = chatState.serverBase;
   if (args.length > 0) {
     const sub = args[0].toLowerCase();
 
@@ -437,41 +655,41 @@ async function cmdSessions(token, chatId, args, setServer, setActiveSession, ser
       try {
         const session = await createSession(server, title);
         const name = session.title || session.slug || session.id;
-        setActiveSession(session.id);
+        setActiveSessionForChat(chatState, session.id);
         selectSession(server, session.id);
-        await sendLongMessage(token, chatId,
+        await sendLongMessage(token, chatState,
           `Created session: \`${name}\`\nIt is now the active session.`);
       } catch (err) {
-        await sendLongMessage(token, chatId, `Error creating session: ${err.message}`);
+        await sendLongMessage(token, chatState, `Error creating session: ${err.message}`);
       }
       return;
     }
 
     if (sub === 'rename') {
       if (args.length < 2) {
-        await sendLongMessage(token, chatId, 'Usage: `/sessions rename <name>`');
+        await sendLongMessage(token, chatState, 'Usage: `/sessions rename <name>`');
         return;
       }
       const st = getState(server);
       if (!st.activeSessionId) {
-        await sendLongMessage(token, chatId, 'No active session. Use `/sessions switch` or `/sessions new` first.');
+        await sendLongMessage(token, chatState, 'No active session. Use `/sessions switch` or `/sessions new` first.');
         return;
       }
       const newTitle = args.slice(1).join(' ');
       try {
         const session = await updateSession(server, st.activeSessionId, newTitle);
         const name = session.title || session.slug || session.id;
-        await sendLongMessage(token, chatId,
+        await sendLongMessage(token, chatState,
           `Renamed session to: \`${name}\``);
       } catch (err) {
-        await sendLongMessage(token, chatId, `Error renaming session: ${err.message}`);
+        await sendLongMessage(token, chatState, `Error renaming session: ${err.message}`);
       }
       return;
     }
 
     if (sub === 'switch') {
       if (args.length < 2) {
-        await sendLongMessage(token, chatId,
+        await sendLongMessage(token, chatState,
           'Usage: `/sessions switch <number-or-name>`\n' +
           'Use `/sessions` to see numbered list. You can switch by number or by name (case-insensitive partial match).');
         return;
@@ -489,9 +707,9 @@ async function cmdSessions(token, chatId, args, setServer, setActiveSession, ser
         const num = parseInt(query, 10);
         if (/^\d+$/.test(query) && num >= 1 && num <= sorted.length) {
           const target = sorted[num - 1];
-          setActiveSession(target.id);
+          setActiveSessionForChat(chatId, target.id);
           selectSession(server, target.id);
-          await sendLongMessage(token, chatId,
+          await sendLongMessage(token, chatState,
             `Switched to session #${num}: \`${sessionName(target)}\`\nSubsequent messages will be sent to this session.`);
           return;
         }
@@ -500,29 +718,29 @@ async function cmdSessions(token, chatId, args, setServer, setActiveSession, ser
         const q = query.toLowerCase();
         const matches = sorted.filter(s => sessionName(s).toLowerCase().includes(q));
         if (matches.length === 0) {
-          await sendLongMessage(token, chatId,
+          await sendLongMessage(token, chatState,
             `No session matching "${query}". Use /sessions to list active sessions.`);
           return;
         }
         if (matches.length > 1) {
           const list = matches.map(s => `  \`${sessionName(s)}\``).join('\n');
-          await sendLongMessage(token, chatId,
+          await sendLongMessage(token, chatState,
             `Multiple matches for "${query}":\n${list}\n\nPlease be more specific or use a number.`);
           return;
         }
         const target = matches[0];
-        setActiveSession(target.id);
+        setActiveSessionForChat(chatId, target.id);
         selectSession(server, target.id);
-        await sendLongMessage(token, chatId,
+        await sendLongMessage(token, chatState,
           `Switched to session: \`${sessionName(target)}\`\nSubsequent messages will be sent to this session.`);
       } catch (err) {
-        await sendLongMessage(token, chatId, `Error switching session: ${err.message}`);
+        await sendLongMessage(token, chatState, `Error switching session: ${err.message}`);
       }
       return;
     }
 
     // Unknown subcommand
-    await sendLongMessage(token, chatId,
+    await sendLongMessage(token, chatState,
       `Unknown subcommand: /sessions ${sub}\n\n` +
       'Usage:\n' +
       '  `/sessions` ─ list sessions\n' +
@@ -537,7 +755,7 @@ async function cmdSessions(token, chatId, args, setServer, setActiveSession, ser
     const projectDir = serverDir(server);
     const sessions = await listSessions(server, projectDir);
     if (!sessions || sessions.length === 0) {
-      await sendLongMessage(token, chatId, 'No active sessions.');
+      await sendLongMessage(token, chatState, 'No active sessions.');
       return;
     }
 
@@ -547,7 +765,7 @@ async function cmdSessions(token, chatId, args, setServer, setActiveSession, ser
       (s.agent || s.directory || s.id === activeId) && (!projectDir || s.directory === projectDir));
     const sorted = sortedSessions(filtered, 50);
     if (sorted.length === 0) {
-      await sendLongMessage(token, chatId, 'No active sessions.');
+      await sendLongMessage(token, chatState, 'No active sessions.');
       return;
     }
 
@@ -591,16 +809,17 @@ async function cmdSessions(token, chatId, args, setServer, setActiveSession, ser
       lines.push('`' + bullet + pos + ' ' + timeLabel + ' – ' + name.replace(/`/g, "'") + '`');
     });
 
-    await sendLongMessage(token, chatId, 'Sessions:\n' + lines.join('\n'));
+    await sendLongMessage(token, chatState, 'Sessions:\n' + lines.join('\n'));
   } catch (err) {
-    await sendLongMessage(token, chatId, `Error listing sessions: ${err.message}`);
+    await sendLongMessage(token, chatState, `Error listing sessions: ${err.message}`);
   }
 }
 
-async function cmdAgents(token, chatId, args, setServer, setActiveSession, server) {
+async function cmdAgents(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const server = chatState.serverBase;
   if (args.length > 0 && args[0].toLowerCase() === 'switch') {
     if (args.length < 2) {
-      await sendLongMessage(token, chatId,
+      await sendLongMessage(token, chatState,
         'Usage: `/agents switch <name>`\n' +
         'Use `/agents` to list available agents.');
       return;
@@ -609,7 +828,7 @@ async function cmdAgents(token, chatId, args, setServer, setActiveSession, serve
     try {
       const agents = await listAgents(server);
       if (!agents || agents.length === 0) {
-        await sendLongMessage(token, chatId, 'No agents available.');
+        await sendLongMessage(token, chatState, 'No agents available.');
         return;
       }
       let matches = agents.filter(a => a.name === name);
@@ -617,12 +836,12 @@ async function cmdAgents(token, chatId, args, setServer, setActiveSession, serve
         matches = agents.filter(a => a.name.toLowerCase().includes(name.toLowerCase()));
       }
       if (matches.length === 0) {
-        await sendLongMessage(token, chatId, `No agent matching "${name}".`);
+        await sendLongMessage(token, chatState, `No agent matching "${name}".`);
         return;
       }
       if (matches.length > 1) {
         const list = matches.map(a => `  \`${a.name}\``).join('\n');
-        await sendLongMessage(token, chatId,
+        await sendLongMessage(token, chatState,
           `Multiple matches for "${name}":\n${list}\n\nPlease be more specific.`);
         return;
       }
@@ -634,10 +853,10 @@ async function cmdAgents(token, chatId, args, setServer, setActiveSession, serve
         selectSession(server, st.activeSessionId);
       }
       const model = target.model ? ` ─ \`${target.model.providerID}/${target.model.modelID}\`` : '';
-      await sendLongMessage(token, chatId,
+      await sendLongMessage(token, chatState,
         `Switched to agent: **${target.name}**${model}\nSubsequent messages will use this agent.`);
     } catch (err) {
-      await sendLongMessage(token, chatId, `Error switching agent: ${err.message}`);
+      await sendLongMessage(token, chatState, `Error switching agent: ${err.message}`);
     }
     return;
   }
@@ -645,12 +864,12 @@ async function cmdAgents(token, chatId, args, setServer, setActiveSession, serve
   try {
     const agents = await listAgents(server);
     if (!agents || agents.length === 0) {
-      await sendLongMessage(token, chatId, 'No agents available.');
+      await sendLongMessage(token, chatState, 'No agents available.');
       return;
     }
     const primary = agents.filter(a => a.mode === 'primary');
     if (primary.length === 0) {
-      await sendLongMessage(token, chatId, 'No primary agents available.');
+      await sendLongMessage(token, chatState, 'No primary agents available.');
       return;
     }
     const activeAgentName = getState(server).activeAgentName;
@@ -660,13 +879,14 @@ async function cmdAgents(token, chatId, args, setServer, setActiveSession, serve
       const desc = a.description ? `. ${a.description}` : '';
       return bullet + '**' + a.name + '**' + model + desc;
     });
-    await sendLongMessage(token, chatId, 'Primary agents:\n' + lines.join('\n'));
+    await sendLongMessage(token, chatState, 'Primary agents:\n' + lines.join('\n'));
   } catch (err) {
-    await sendLongMessage(token, chatId, `Error listing agents: ${err.message}`);
+    await sendLongMessage(token, chatState, `Error listing agents: ${err.message}`);
   }
 }
 
-async function cmdModels(token, chatId, args, setServer, setActiveSession, server) {
+async function cmdModels(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const server = chatState.serverBase;
   try {
     const result = await listProviders(server);
     const all = result.all || [];
@@ -674,7 +894,7 @@ async function cmdModels(token, chatId, args, setServer, setActiveSession, serve
 
     const filtered = all.filter(p => connectedIds.includes(p.id));
     if (filtered.length === 0) {
-      await sendLongMessage(token, chatId, 'No connected providers.');
+      await sendLongMessage(token, chatState, 'No connected providers.');
       return;
     }
 
@@ -698,9 +918,9 @@ async function cmdModels(token, chatId, args, setServer, setActiveSession, serve
       }
     }
 
-    await sendLongMessage(token, chatId, 'Connected providers:\n' + lines.join('\n'));
+    await sendLongMessage(token, chatState, 'Connected providers:\n' + lines.join('\n'));
   } catch (err) {
-    await sendLongMessage(token, chatId, `Error listing models: ${err.message}`);
+    await sendLongMessage(token, chatState, `Error listing models: ${err.message}`);
   }
 }
 
@@ -710,7 +930,7 @@ const PERM_RESPONSE_HELP = ' No pending permission. Use `/status` to check the c
 // Agentp gateway ─ tiny HTTP server for agentp --tg
 // ---------------------------------------------------------------------------
 
-function startAgentpGateway(token, chatIdResolver, serverBaseResolver) {
+function startAgentpGateway(token, serverBaseResolver) {
   return new Promise((resolve) => {
     const server = http.createServer((req, res) => {
       try {
@@ -740,16 +960,21 @@ function startAgentpGateway(token, chatIdResolver, serverBaseResolver) {
               res.end('Bad Request: text and server are required');
               return;
             }
-            res.writeHead(200);
-            res.end('OK');
 
-            const chatId = chatIdResolver();
-            if (!chatId) return;
-            const activeUrl = normalizeUrl(serverBaseResolver());
+            // Find the chat that owns this server
             const targetUrl = normalizeUrl(server);
+            const owningChatId = Object.entries(serverOwners).find(([url]) => normalizeUrl(url) === targetUrl)?.[1];
+
+            // Return recorded conversation buffer for the owning chat
+            const buffered = owningChatId ? flushRecorded(owningChatId.chatId, owningChatId.threadId) : [];
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ buffered }));
+
+            if (!owningChatId) return;
+            const activeUrl = normalizeUrl(serverBaseResolver());
 
             if (targetUrl === activeUrl) {
-              sendLongMessage(token, chatId, text.trim()).catch(() => {});
+              sendLongMessage(token, owningChatId, text.trim()).catch(() => {});
             } else {
               if (!agentpQueues[server]) {
                 agentpQueues[server] = { messages: [], notifyTimer: null, notified: false };
@@ -761,7 +986,7 @@ function startAgentpGateway(token, chatIdResolver, serverBaseResolver) {
                   q.notifyTimer = null;
                   if (q.messages.length > 0 && !q.notified) {
                     q.notified = true;
-                    sendLongMessage(token, chatId,
+                    sendLongMessage(token, owningChatId,
                       `📥 ${q.messages.length} agentp message(s) queued for server \`${server}\`. Switch servers to view them.`)
                       .catch(() => {});
                   }
@@ -788,80 +1013,321 @@ function startAgentpGateway(token, chatIdResolver, serverBaseResolver) {
   });
 }
 
-async function cmdAllow(token, chatId, args, setServer, setActiveSession, server) {
-  const st = getState(server);
+async function cmdAllow(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const st = getState(chatState.serverBase);
   if (!st.pendingPermission) {
-    await sendLongMessage(token, chatId, '/allow' + PERM_RESPONSE_HELP);
+    await sendLongMessage(token, chatState, '/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).');
+    await sendLongMessage(token, chatState, '✅ Permission approved (once).');
     log.debug(`  → /allow: ${p.type} ${p.pattern || ''}`);
   } catch (err) {
-    await sendLongMessage(token, chatId, `Error: ${err.message}`);
+    await sendLongMessage(token, chatState, `Error: ${err.message}`);
   }
 }
 
-async function cmdReject(token, chatId, args, setServer, setActiveSession, server) {
-  const st = getState(server);
+async function cmdReject(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const st = getState(chatState.serverBase);
   if (!st.pendingPermission) {
-    await sendLongMessage(token, chatId, '/reject' + PERM_RESPONSE_HELP);
+    await sendLongMessage(token, chatState, '/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.');
+    await sendLongMessage(token, chatState, '⛔ Permission denied.');
     log.debug(`  → /reject: ${p.type} ${p.pattern || ''}`);
   } catch (err) {
-    await sendLongMessage(token, chatId, `Error: ${err.message}`);
+    await sendLongMessage(token, chatState, `Error: ${err.message}`);
   }
 }
 
-async function cmdAlways(token, chatId, args, setServer, setActiveSession, server) {
-  const st = getState(server);
+async function cmdAlways(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const st = getState(chatState.serverBase);
   if (!st.pendingPermission) {
-    await sendLongMessage(token, chatId, '/always' + PERM_RESPONSE_HELP);
+    await sendLongMessage(token, chatState, '/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).');
+    await sendLongMessage(token, chatState, '✅ Permission approved (always).');
     log.debug(`  → /always: ${p.type} ${p.pattern || ''}`);
   } catch (err) {
-    await sendLongMessage(token, chatId, `Error: ${err.message}`);
+    await sendLongMessage(token, chatState, `Error: ${err.message}`);
   }
 }
 
-async function cmdThink(token, chatId, args, setServer, setActiveSession, server) {
-  const st = getState(server);
+async function cmdThink(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const st = getState(chatState.serverBase);
   const sub = args && args.length > 0 ? args[0].toLowerCase() : 'switch';
   if (sub === 'on') {
     st.thinkingEnabled = true;
-    await sendLongMessage(token, chatId, '💭 Thinking messages **on** (forwarded to chat).');
+    await sendLongMessage(token, chatState, '💭 Thinking messages **on** (forwarded to chat).');
   } else if (sub === 'off') {
     st.thinkingEnabled = false;
-    await sendLongMessage(token, chatId, '💭 Thinking messages **off**.');
+    await sendLongMessage(token, chatState, '💭 Thinking messages **off**.');
   } else if (sub === 'switch') {
     st.thinkingEnabled = !st.thinkingEnabled;
-    await sendLongMessage(token, chatId,
+    await sendLongMessage(token, chatState,
       `💭 Thinking messages ${st.thinkingEnabled ? '**on**' : '**off**'}.`);
   } else {
-    await sendLongMessage(token, chatId, 'Usage: `/think [on|off|switch]` (default: switch).');
+    await sendLongMessage(token, chatState, 'Usage: `/think [on|off|switch]` (default: switch).');
+  }
+}
+
+async function cmdQueue(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat, replyTo) {
+  const st = getState(chatState.serverBase);
+  if (!st.busy) {
+    await sendLongMessage(token, chatState, 'Server is not busy. No need to queue — send your message directly.');
+    return;
+  }
+  const text = args.join(' ').trim();
+  if (!text) {
+    await sendLongMessage(token, chatState, 'Usage: `/queue <message>` — queue a message for when the server is idle.');
+    return;
+  }
+  if (!st.messageQueue) st.messageQueue = [];
+  st.messageQueue.push({ text, replyTo });
+  await sendLongMessage(token, chatState, `📥 Queued. ${st.messageQueue.length} message(s) in queue. Will be sent when the current task finishes.`);
+}
+
+function recordingLabel(rec) {
+  if (rec.paused) return '⏸ paused';
+  return rec.active ? '🔴 active' : '⏹ inactive';
+}
+
+async function cmdRecord(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const rec = chatState.recording;
+  const ring = chatState.ring;
+
+  // /record N: retroactively buffer last N messages from the always-on ring
+  if (args.length > 0 && /^\d+$/.test(args[0])) {
+    const n = parseInt(args[0], 10);
+    const count = Math.min(n, ring.messages.length);
+    const msgs = ring.messages.slice(-count);
+    for (const m of msgs) {
+      rec.messages.push({ role: m.role, text: m.text });
+      rec.bytes += Buffer.byteLength(m.text, 'utf8');
+    }
+    while (rec.messages.length > MAX_RECORDED_MSGS || rec.bytes > MAX_RECORDED_BYTES) {
+      const oldest = rec.messages.shift();
+      rec.bytes -= Buffer.byteLength(oldest.text, 'utf8');
+    }
+    rec.active = true;
+    rec.paused = false;
+    const label = rec.messages.length > 0 ? `🔴 *active*, ${rec.messages.length} buffered` : '⏹ *inactive*, buffer empty';
+    await sendLongMessage(token, chatState,
+      `${label} (${count} message(s) retroactively loaded from ring).`);
+    return;
+  }
+
+  // /record pause [N]: pause recording, keep buffer, optionally discard last N
+  if (args.length > 0 && args[0].toLowerCase() === 'pause') {
+    if (rec.active && !rec.paused && args.length > 1 && /^\d+$/.test(args[1])) {
+      const n = parseInt(args[1], 10);
+      const count = Math.min(n, rec.messages.length);
+      rec.messages.splice(-count);
+      rec.bytes = rec.messages.reduce((b, m) => b + Buffer.byteLength(m.text, 'utf8'), 0);
+      await sendLongMessage(token, chatState,
+        `⏸ Recording paused. Discarded last ${count} message(s). ${rec.messages.length} remaining.`);
+    } else {
+      rec.paused = true;
+      rec.active = true;
+      await sendLongMessage(token, chatState,
+        `⏸ Recording paused. Buffer preserved (${rec.messages.length} messages).`);
+    }
+    return;
+  }
+
+  // /record flush: clear buffer, keep state
+  if (args.length > 0 && args[0].toLowerCase() === 'flush') {
+    rec.messages = [];
+    rec.bytes = 0;
+    await sendLongMessage(token, chatState,
+      `🧹 Buffer cleared. State: ${recordingLabel(rec)}.`);
+    return;
+  }
+
+  // /record stop: flush + pause = fully stop and clear
+  if (args.length > 0 && args[0].toLowerCase() === 'stop') {
+    rec.active = false;
+    rec.paused = false;
+    rec.messages = [];
+    rec.bytes = 0;
+    await sendLongMessage(token, chatState, '⏹ Recording stopped. Buffer cleared.');
+    return;
+  }
+
+  // /record (no args) or /record continue: toggle/continue
+  if (args.length > 0 && args[0].toLowerCase() === 'continue') {
+    rec.paused = false;
+    rec.active = true;
+    const empty = rec.messages.length === 0;
+    await sendLongMessage(token, chatState,
+      empty
+        ? '🔴 Recording started (buffer was empty).'
+        : `🔴 Recording continued. ${rec.messages.length} buffered message(s) will grow.`);
+    return;
+  }
+
+  // Bare /record: toggle between active ↔ paused (if active), or activate (if inactive)
+  if (!rec.active) {
+    rec.active = true;
+    rec.paused = false;
+    rec.messages = [];
+    rec.bytes = 0;
+    await sendLongMessage(token, chatState, '🔴 Recording started.');
+  } else if (!rec.paused) {
+    rec.paused = true;
+    await sendLongMessage(token, chatState,
+      `⏸ Recording paused. ${rec.messages.length} message(s) preserved.`);
+  } else {
+    rec.paused = false;
+    const empty = rec.messages.length === 0;
+    await sendLongMessage(token, chatState,
+      empty
+        ? '🔴 Recording continued (buffer was empty).'
+        : `🔴 Recording continued. ${rec.messages.length} buffered message(s) will grow.`);
   }
 }
 
+async function cmdFlush(token, chatId, args, chatState) {
+  const st = getState(chatState.serverBase);
+  const server = chatState.serverBase;
+  const q = st.messageQueue || [];
+  const qlen = q.length;
+
+  // Clear the message queue
+  st.messageQueue = [];
+
+  // Clear the agentp queue
+  const aq = agentpQueues[server];
+  let alen = 0;
+  if (aq) {
+    alen = aq.messages.length;
+    aq.messages = [];
+    aq.notified = false;
+    if (aq.notifyTimer) { clearTimeout(aq.notifyTimer); aq.notifyTimer = null; }
+  }
+
+  await sendLongMessage(token, chatState,
+    qlen + alen > 0
+      ? `🧹 Flushed ${qlen} queued message(s) and ${alen} agentp message(s).`
+      : '🧹 No queued messages to flush.');
+}
+
+async function cmdComment(token, chatId, args, chatState) {
+  // No-op: the message is already in the chat. /comment prevents forwarding to the agent.
+  // Replying to a comment with a non-/comment message includes it via the quote mechanism.
+  log.info(`[COMMENT] chat=${chatId} text: ${(args || []).join(' ')}`);
+}
+
+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;
+      }
+    } 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;
+  }
+
+  await sendLongMessage(token, chatState,
+    `♻️ Resurrecting server \`${dir}\`...\n` +
+    `The old server at \`${url}\` will be replaced with a new one.`);
+
+  try {
+    const { url: newUrl } = resurrectServer(dir, false);
+
+    // Update chat state to new URL
+    chatState.serverBase = newUrl;
+
+    // Transfer relevant state from old URL to new URL
+    const oldSt = getState(url);
+    const newSt = getState(newUrl);
+    newSt.activeSessionId = oldSt.activeSessionId;
+    newSt.activeSessionName = oldSt.activeSessionName;
+    newSt.activeAgentName = oldSt.activeAgentName;
+    newSt.thinkingEnabled = oldSt.thinkingEnabled;
+
+    // Update serverOwners to point to the new URL
+    const normOld = normalizeUrl(url);
+    for (const [sfUrl, owner] of Object.entries(serverOwners)) {
+      if (normalizeUrl(sfUrl) === normOld) {
+        serverOwners[newUrl] = owner;
+        delete serverOwners[sfUrl];
+        break;
+      }
+    }
+
+    await sendLongMessage(token, chatState,
+      `✅ Server resurrected.\n` +
+      `New URL: \`${newUrl}\`\n\n` +
+      `Use \`/status\` to check the session.`);
+  } catch (err) {
+    await sendLongMessage(token, chatState,
+      `❌ Resurrection failed: ${err.message}\n` +
+      `Try \`ocmux resurrect\` from the terminal.`);
+  }
+}
+
+async function cmdDisconnect(token, chatId, args, chatState) {
+  const url = chatState.serverBase;
+  if (!url) {
+    await sendLongMessage(token, chatState, '🔌 Not connected to any server.');
+    return;
+  }
+  // Clear ownership if this chat is the owner
+  const key = convKey(chatId, chatState.threadId);
+  for (const [srvUrl, owner] of Object.entries(serverOwners)) {
+    if (String(owner.chatId) === String(chatId) && owner.threadId === chatState.threadId) {
+      delete serverOwners[srvUrl];
+      break;
+    }
+  }
+  chatState.serverBase = null;
+  removeConnection(chatId, chatState.threadId);
+  await sendLongMessage(token, chatState, '👋 Disconnected from `' + url + '`.');
+  log.info(`[chat ${chatId}] Disconnected from server: ${url}`);
+}
+
 const COMMANDS = {
   'help': cmdHelp,
   'servers': cmdServers,
+  'force-switch': cmdForceSwitch,
   'sessions': cmdSessions,
   'session': cmdSessions,
   'agents': cmdAgents,
   'models': cmdModels,
   'think': cmdThink,
+  'record': cmdRecord,
+  'resurrect': cmdResurrect,
+  'queue': cmdQueue,
+  'flush': cmdFlush,
+  'comment': cmdComment,
+  'disconnect': cmdDisconnect,
   'allow': cmdAllow,
   'reject': cmdReject,
   'always': cmdAlways,
@@ -873,7 +1339,7 @@ const COMMANDS = {
 
 const serverState = {};
 function getState(url) {
-  return serverState[url] = serverState[url] || { busy: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, thinkingEnabled: false };
+  return serverState[url] = serverState[url] || { busy: false, serverDead: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, thinkingEnabled: false, messageQueue: [] };
 }
 
 function sessionLabel(st) {
@@ -898,6 +1364,7 @@ async function main() {
       process.exit(0);
     } else if (args[i] === '--dev') {
       DEV_MODE = true;
+      log.verbose = true;
     } else if (args[i] === '--verbose') {
       log.verbose = true;
     } else if (args[i] === '--think') {
@@ -955,6 +1422,26 @@ async function main() {
 
   log.info(`tgagentp v${version} started. OpenCode server: ${serverBase}`);
 
+  // When --dev is active, log all message traffic to stderr
+  let msgLogStream = null;
+  if (DEV_MODE) {
+    try {
+      msgLogStream = fs.createWriteStream('/tmp/tgagentp-msg.log', { flags: 'a' });
+      const hdr = JSON.stringify({ ts: new Date().toISOString(), type: 'startup', version });
+      msgLogStream.write(hdr + '\n');
+    } catch (_) { msgLogStream = null; }
+  }
+  const msgLog = (type, chatId, from, text) => {
+    if (!msgLogStream) return;
+    try {
+      const entry = JSON.stringify({
+        ts: new Date().toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, ''),
+        type, chatId, from: from || '', text: text || '',
+      });
+      msgLogStream.write(entry + '\n');
+    } catch (_) {}
+  };
+
   if (!process.env.OPENCODE_SERVER_PASSWORD) {
     log.error('🔓  Server is not password-protected! Set OPENCODE_SERVER_PASSWORD for better security.');
   }
@@ -966,8 +1453,6 @@ async function main() {
     log.info('Chat allowlist: not configured (all chats accepted)');
   }
 
-  let lockedChatId = null;
-
   getState(serverBase);
 
   log.info('Discovering server state...');
@@ -988,32 +1473,61 @@ async function main() {
 
   log.info('Waiting for Telegram messages... (Ctrl+C to stop)');
 
-  // Start agentp gateway (tiny HTTP server for agentp --tg)
-  const chatIdResolver = () => lockedChatId;
-  const serverBaseResolver = () => serverBase;
-  startAgentpGateway(token, chatIdResolver, serverBaseResolver);
+  // Chat-aware server/session mutation callbacks (defined here for token access)
+  const setServerForChat = async (chatState, url) => {
+    const cs = chatState;
+
+    // Disconnect any other chat still connected to this server (one server → one chat)
+    const normalizedUrl = normalizeUrl(url);
+    for (const key of Object.keys(chatStates)) {
+      const state = chatStates[key];
+      if (state === cs) continue;
+      if (state.serverBase && normalizeUrl(state.serverBase) === normalizedUrl) {
+        state.serverBase = null;
+        removeConnection(state.chatId, state.threadId);
+        log.info(`[chat ${state.chatId}] Disconnected from server: ${url} (taken over by chat ${cs.chatId})`);
+      }
+    }
 
-  const setServer = async (url) => {
-    serverBase = url;
+    // Clear old server ownership when switching away from a server
+    const oldUrl = cs.serverBase;
+    cs.serverBase = url;
+    if (oldUrl && oldUrl !== url) {
+      if (serverOwners[oldUrl] &&
+          String(serverOwners[oldUrl].chatId) === String(cs.chatId)) {
+        delete serverOwners[oldUrl];
+      }
+    }
+    serverOwners[url] = { chatId: cs.chatId, threadId: cs.threadId };
     getState(url);
-    log.info(`Switched to server: ${url}`);
+
+    // Auto-activate tmux window for this server
+    const servers = listServers();
+    const normalized = normalizeUrl(url);
+    const match = servers.find(s => normalizeUrl(s.url) === normalized);
+    if (match) {
+      activateServer(match.dir, match.index, match.url);
+      saveConnection(cs.chatId, cs.threadId, match.dir);
+    }
+
+    log.info(`[chat ${cs.chatId}] Switched to server: ${url}`);
 
     // Flush agentp queue for the new active server
-    flushAgentpQueue(url, token, lockedChatId);
+    flushAgentpQueue(url, token, cs.chatId, cs.threadId);
 
-    const [discovered, agents] = await Promise.all([
+    const [srvDiscovered, srvAgents] = await Promise.all([
       discoverActiveSession(url),
       listAgents(url).catch(() => []),
     ]);
-    if (discovered) {
-      getState(url).activeSessionId = discovered.id;
-      getState(url).activeSessionName = discovered.name;
-      log.info(`  → session: ${discovered.name || discovered.id}`);
+    if (srvDiscovered) {
+      getState(url).activeSessionId = srvDiscovered.id;
+      getState(url).activeSessionName = srvDiscovered.name;
+      log.info(`  → session: ${srvDiscovered.name || srvDiscovered.id}`);
     }
-    const defaultAgent = agents.find(a => a.mode === 'primary') || agents[0];
-    if (defaultAgent) {
-      getState(url).activeAgentName = defaultAgent.name;
-      log.info(`  → agent: ${defaultAgent.name}`);
+    const defaultSrvAgent = srvAgents.find(a => a.mode === 'primary') || srvAgents[0];
+    if (defaultSrvAgent) {
+      getState(url).activeAgentName = defaultSrvAgent.name;
+      log.info(`  → agent: ${defaultSrvAgent.name}`);
     }
     const p = getState(url).pendingResponse;
     if (p) {
@@ -1023,24 +1537,35 @@ async function main() {
     return null;
   };
 
-  const setActiveSession = (id) => {
-    getState(serverBase).activeSessionId = id;
-    log.info(`Switched to session: ${id}`);
+  const setActiveSessionForChat = (chatState, id) => {
+    const server = chatState.serverBase;
+    getState(server).activeSessionId = id;
+    log.info(`[chat ${chatState.chatId}] Switched to session: ${id}`);
+  };
+
+  // Start agentp gateway (tiny HTTP server for agentp --tg)
+  const serverBaseResolver = () => {
+    const entries = Object.entries(serverOwners);
+    if (entries.length === 0) return serverBase;
+    const cs = getChatState(entries[0][1].chatId, entries[0][1].threadId);
+    return cs.serverBase;
   };
+  startAgentpGateway(token, serverBaseResolver);
 
-  async function processMessageAsync(chatId, text, url, useSession, sessionId, myTaskId, replyTo) {
+  async function processMessageAsync(chatId, text, url, useSession, sessionId, myTaskId, replyTo, threadId) {
     const st = getState(url);
     const isCancelled = () => getState(url).taskId !== myTaskId;
     const cancelRef = { current: null };
+    const chatState = { chatId, threadId };
     const sessionCancelRef = { current: null };
+    // Destroy any previous SSE listener so stale forwarding to old chats stops
+    if (st._cancelRef && st._cancelRef.current) { st._cancelRef.current.destroy(); st._cancelRef.current = null; }
+    if (st._sessionReq && st._sessionReq.current) { st._sessionReq.current.destroy(); st._sessionReq.current = null; }
     st._cancelRef = cancelRef;
     st._sessionReq = sessionCancelRef;
     try {
       let answer;
       if (useSession) {
-        // Dual approach:
-        // 1. SSE for permissions/thinking events (connected before sending)
-        // 2. Synchronous sendToSession (POST /session/:id/message) for reliable answer
         const notifiedPerms = new Set();
         let thinkingBuf = '';
         let sseConnected;
@@ -1056,7 +1581,7 @@ async function main() {
             thinkingBuf += chunk;
             if (thinkingBuf.length >= 50 || chunk.endsWith('\n')) {
               const html = '💭 ' + thinkingBuf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-              sendLongMessage(token, chatId, html, replyTo)
+              sendLongMessage(token, chatState, html, replyTo, threadId)
                 .then(() => {})
                 .catch(() => {});
               thinkingBuf = '';
@@ -1078,7 +1603,7 @@ async function main() {
                 + (perm.title ? '**Detail:** ' + perm.title + '\n' : '')
                 + 'Use `/allow` to approve once, `/always` to always allow, or `/reject` to deny.';
               log.debug(`  → sending permission notification to chat ${chatId}`);
-              sendLongMessage(token, chatId, msg, replyTo)
+              sendLongMessage(token, chatState, msg, replyTo, threadId)
                 .then(() => log.debug(`  → permission notification sent OK`))
                 .catch((err) => log.debug(`  → permission notification failed: ${err.message}`));
             } else {
@@ -1090,16 +1615,13 @@ async function main() {
             getState(url).pendingPermission = null;
           },
         }, cancelRef).catch(() => {});
-        // Wait for SSE to connect, then send synchronously
         await onConnected;
         answer = await sendToSession(url, sessionId, `[Telegram] ${text}`, st.activeAgentName, sessionCancelRef);
-        // Flush any remaining thinking buffer
         if (thinkingBuf) {
           const html = '💭 ' + thinkingBuf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-          sendLongMessage(token, chatId, html, replyTo).catch(() => {});
+          sendLongMessage(token, chatState, html, replyTo, threadId).catch(() => {});
           thinkingBuf = '';
         }
-        // Clean up SSE listener
         if (cancelRef.current) { cancelRef.current.destroy(); cancelRef.current = null; }
       } else {
         await sendText(url, `[Telegram] ${text}`);
@@ -1111,16 +1633,21 @@ async function main() {
         return;
       }
       st.pendingPermission = null;
-      if (url === serverBase) {
+      const chatServer = getChatState(chatId, threadId).serverBase;
+      if (url === chatServer) {
         if (answer && answer.trim()) {
-          await sendLongMessage(token, chatId, answer.trim(), replyTo);
+          const trimmed = answer.trim();
+          msgLog('out', chatId, '', trimmed);
+          await sendLongMessage(token, chatState, trimmed, replyTo, threadId);
+          bufferMessage(chatId, threadId, 'assistant', trimmed);
         }
       } else {
         getState(url).pendingResponse = answer;
-        await sendLongMessage(token, chatId, `✅ Server \`${url}\` finished processing. Switch back to see the response.`, replyTo);
+        msgLog('out', chatId, '(switch)', (answer || '').trim());
+        await sendLongMessage(token, chatState, `✅ Server \`${url}\` finished processing. Switch back to see the response.`, replyTo, threadId);
+        if (answer && answer.trim()) bufferMessage(chatId, threadId, 'assistant', answer.trim());
       }
     } catch (err) {
-      // Clean up SSE listener if it's still active
       if (cancelRef.current) { cancelRef.current.destroy(); cancelRef.current = null; }
       if (isCancelled()) {
         log.debug(`  → cancelled, ignoring error from ${url}: ${err.message}`);
@@ -1128,8 +1655,28 @@ async function main() {
         return;
       }
       log.error(`Error processing message (${url}): ${err.message}`);
-      if (url === serverBase) {
-        try { await sendLongMessage(token, chatId, `Error: ${err.message}`, replyTo); } catch (_) {}
+
+      // Detect connection errors (server dead) and requeue the message
+      const isConnError = err.code === 'ECONNREFUSED' || err.code === 'ECONNRESET' ||
+        err.code === 'ETIMEDOUT' || err.message.includes('socket hang up') ||
+        err.message.includes('connect ECONNREFUSED');
+      if (isConnError) {
+        st.serverDead = true;
+        if (!st.messageQueue) st.messageQueue = [];
+        st.messageQueue.unshift({ text, replyTo });
+        log.info(`Server ${url} appears dead. Re-queued message.`);
+      }
+
+      const chatServer = getChatState(chatId, threadId).serverBase;
+      if (url === chatServer) {
+        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` +
+            `• Switch to another server: \`/servers switch <name>\`\n` +
+            `• Flush the queue: \`/flush\``
+          : `Error: ${err.message}`;
+        try { await sendLongMessage(token, chatState, msg, replyTo, threadId); } catch (_) {}
       }
     } finally {
       st.pendingPermission = null;
@@ -1137,83 +1684,244 @@ async function main() {
       if (st._sessionReq === sessionCancelRef) st._sessionReq = null;
       if (!isCancelled()) {
         getState(url).busy = false;
+        // Don't drain the queue if the server is dead — messages stay queued
+        if (st.serverDead) return;
+        const q = st.messageQueue || [];
+        st.messageQueue = [];
+        if (q.length > 0) {
+          const next = q[0];
+          st.messageQueue = q.slice(1);
+          const nextText = next.text;
+          const nextReplyTo = next.replyTo;
+          getState(url).busy = true;
+          const nextTaskId = ++st.taskId;
+          log.debug(`  → processing queued message (task ${nextTaskId})`);
+          processMessageAsync(chatId, nextText, url, !!st.activeSessionId, st.activeSessionId, nextTaskId, nextReplyTo, threadId);
+        }
       }
     }
   }
 
-  const cmdCancel = async (token, chatId) => {
-    const st = getState(serverBase);
+  const cmdCancel = async (token, chatId, cmdArgs, chatState) => {
+    const cs = chatState || getChatState(chatId);
+    if (!cs.serverBase) {
+      await sendLongMessage(token, cs, '🔌 Not connected to any server.');
+      return;
+    }
+    const st = getState(cs.serverBase);
     if (!st.busy) {
-      await sendLongMessage(token, chatId, 'Nothing to cancel.');
+      await sendLongMessage(token, cs, 'Nothing to cancel.');
       return;
     }
     st.taskId++;
     st.busy = false;
-    // Abort the SSE stream so the server stops processing
     if (st._cancelRef && st._cancelRef.current) {
       st._cancelRef.current.destroy();
       st._cancelRef.current = null;
     }
-    // Abort the synchronous session request if in progress
     if (st._sessionReq && st._sessionReq.current) {
       st._sessionReq.current.destroy();
       st._sessionReq.current = null;
     }
-    await sendLongMessage(token, chatId, '✅ Cancelled.');
-    log.debug(`  → /cancel on ${serverBase}`);
+    await sendLongMessage(token, cs, '✅ Cancelled.');
+    log.debug(`[chat ${chatId}] /cancel on ${cs.serverBase}`);
   }
 
-  const cmdStatus = async (token, chatId) => {
-    const st = getState(serverBase);
+  const cmdStatus = async (token, chatId, cmdArgs, chatState) => {
+    const cs = chatState || getChatState(chatId);
+    if (!cs.serverBase) {
+      await sendLongMessage(token, cs, '🔌 Not connected to any server.');
+      return;
+    }
+    const st = getState(cs.serverBase);
+    const deadInfo = st.serverDead ? ' ❌ unreachable' : '';
     const busyInfo = st.busy ? '⏳ busy' : '✅ idle';
-    const dir = serverDir(serverBase);
+    const dir = serverDir(cs.serverBase);
     const lines = ['**Server:**'];
     if (dir) lines.push('  • **Path:** `' + dir + '`');
-    lines.push('  • **URL:** `' + serverBase + '`');
-    lines.push('  • **Status:** ' + busyInfo);
+    lines.push('  • **URL:** `' + cs.serverBase + '`');
+    lines.push('  • **Status:** ' + busyInfo + deadInfo);
     lines.push('**Session:** ' + sessionLabel(st));
     lines.push('**Agent:** ' + (st.activeAgentName ? '`' + st.activeAgentName + '`' : '*default*'));
-    await sendLongMessage(token, chatId, lines.join('\n'));
+    await sendLongMessage(token, cs, lines.join('\n'));
   };
 
-  const cmdShutdown = async (token, chatId, args) => {
-    const st = getState(serverBase);
+  const cmdShutdown = async (token, chatId, args, chatState) => {
+    const cs = chatState || getChatState(chatId);
+    const st = getState(cs.serverBase);
+
+    // Handle /shutdown clear — wipe saved connections before exiting
+    if (args && args.length > 0 && args[0].toLowerCase() === 'clear') {
+      clearConnections();
+      await sendLongMessage(token, cs, '🧹 Connection state cleared.');
+      log.debug('/shutdown clear received, exiting...');
+      try { await getUpdates(token, offset, 1); } catch (_) {}
+      process.exit(0);
+    }
+
     const isForce = args && args.length > 0 && args[0].toLowerCase() === 'force';
     if (st.busy && !isForce) {
-      await sendLongMessage(token, chatId,
+      await sendLongMessage(token, cs,
         '⏳ Server is busy processing a message.\n' +
         'Use `/shutdown force` to shut down anyway (in-flight response will be lost).');
       return;
     }
     const status = st.busy ? '⏳ busy (forced)' : '✅ idle';
-    await sendLongMessage(token, chatId, `👋 Shutting down (state: ${status})...`);
-    try {
-      fs.writeFileSync(STARTUP_CHAT_FILE, String(chatId));
-    } catch (_) {}
+    await sendLongMessage(token, cs, `👋 Shutting down (state: ${status})...`);
     try { await getUpdates(token, offset, 1); } catch (_) {}
     log.debug('/shutdown received, exiting...');
     process.exit(0);
   };
 
-  const cmds = { ...COMMANDS, status: cmdStatus, cancel: cmdCancel };
+  const cmdNote = async (token, chatId, cmdArgs, chatState) => {
+    const text = cmdArgs.join(' ');
+    if (!text) {
+      await sendLongMessage(token, chatState, 'Usage: `/note <message>` — sends a note for the agent to acknowledge.');
+      return;
+    }
+    const url = chatState.serverBase;
+    if (!url) {
+      await sendLongMessage(token, chatState, '🔌 Not connected to any server.');
+      return;
+    }
+    const st = getState(url);
+    if (st.serverDead) {
+      const alive = await isServerAlive(url);
+      if (!alive) {
+        if (!st.messageQueue) st.messageQueue = [];
+        st.messageQueue.push({ text: '📝 **Note:** ' + text, replyTo: null });
+        await sendLongMessage(token, chatState, `⚠️ Server unreachable. Note queued (#${st.messageQueue.length}).`);
+        return;
+      }
+      st.serverDead = false;
+    }
+    if (st.busy) {
+      await sendLongMessage(token, chatState, '⏳ Server is busy. Use `/cancel` to cancel or note again later.');
+      return;
+    }
+    const intro = 'The following information is for your awareness. Reply with only "Ack" and do not take any action:';
+    st.busy = true;
+    const myTaskId = ++st.taskId;
+    log.debug(`  → /note: starting background processing (task ${myTaskId})`);
+    processMessageAsync(chatId, intro + '\n\n' + text, url, !!st.activeSessionId, st.activeSessionId, myTaskId, null, chatState.threadId);
+  };
+
+  const cmds = { ...COMMANDS, status: cmdStatus, cancel: cmdCancel, note: cmdNote };
   if (DEV_MODE) cmds.shutdown = cmdShutdown;
 
   let offset = 0;
 
-  // 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:** ' + sessionLabel(st));
-    lines.push('**Agent:** ' + (st.activeAgentName ? '`' + st.activeAgentName + '`' : '*default*'));
-    try { await sendLongMessage(token, savedChatId, lines.join('\n')); } catch (_) {}
-    lockedChatId = savedChatId;
-    try { fs.unlinkSync(STARTUP_CHAT_FILE); } catch (_) {}
+  // Restore chat↔server connections from persistent state
+  let savedData;
+  let connByOldId = {};
+  try { savedData = JSON.parse(fs.readFileSync(CONNECTIONS_FILE, 'utf8')); } catch {}
+  if (savedData && Array.isArray(savedData.connections)) {
+    // Phase 1: restore chat states and populate serverOwners
+    for (const { chatId, threadId, dir } of savedData.connections) {
+      connByOldId[String(chatId)] = { chatId, threadId, dir };
+    }
+    for (const { chatId, threadId, dir } of savedData.connections) {
+      if (!dir) continue;
+      const cs = getChatState(chatId, threadId);
+      const sf = statefileFor(dir);
+      const state = readState(sf);
+      if (state && state.url) {
+        cs.serverBase = state.url;
+        // Prefer non-thread (private chat) as owner over topic threads
+        const existing = serverOwners[state.url];
+        if (!existing || (!threadId && existing.threadId)) {
+          serverOwners[state.url] = { chatId, threadId };
+        }
+      }
+    }
+    // Phase 2: prune secondary connections per URL (only owner survives)
+    for (const key of Object.keys(chatStates)) {
+      const state = chatStates[key];
+      if (!state.serverBase) continue;
+      const owner = serverOwners[state.serverBase];
+      if (!owner) continue;
+      if (String(owner.chatId) !== String(state.chatId) || owner.threadId !== state.threadId) {
+        const url = state.serverBase;
+        state.serverBase = null;
+        removeConnection(state.chatId, state.threadId);
+        log.info(`[chat ${state.chatId}] Pruned secondary connection to server: ${url}`);
+      }
+    }
+    // Phase 3: send startup notification only to the surviving owner per URL
+    const notifiedUrls = new Set();
+    for (const { chatId, threadId, dir } of savedData.connections) {
+      if (!dir) continue;
+      const cs = getChatState(chatId, threadId);
+      if (!cs.serverBase) continue;
+      const sf = statefileFor(dir);
+      const state = readState(sf);
+      if (state && state.url) {
+        if (notifiedUrls.has(state.url)) {
+          log.info(`[chat ${chatId}] Skipping startup notification for ${dir} (already notified for this URL)`);
+          continue;
+        }
+        notifiedUrls.add(state.url);
+        const alive = await isServerAlive(state.url);
+        if (alive) {
+          const lines = [
+            '✅ Bot started.',
+            '**Server:**',
+            '  • **Path:** `' + dir + '`',
+            '  • **URL:** `' + state.url + '`',
+            '  • **Status:** ✅ restored',
+          ];
+          try { await sendLongMessage(token, cs, lines.join('\n')); } catch (_) {}
+          log.info(`Restored connection: chat ${chatId} → ${dir}`);
+        } else {
+          log.info(`Saved connection for chat ${chatId} → ${dir}, but server ${state.url} is unreachable`);
+          try {
+            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>`.');
+          } catch (_) {}
+        }
+      }
+    }
+  }
+
+  // ── Group migration handler ──────────────────────────────────────
+  // When a regular group is promoted to a supergroup (or topics enabled),
+  // Telegram changes the chat ID. This function updates the stored
+  // connections and allowlist so the bot continues to work transparently.
+  async function handleGroupMigration(oldId, newId) {
+    if (oldId === newId) return;
+    log.info(`Group migration detected: chat ${oldId} → ${newId}`);
+
+    // Update allowlist if the old ID is in it
+    if (allowedChatIds) {
+      const idx = allowedChatIds.indexOf(oldId);
+      if (idx !== -1) {
+        allowedChatIds[idx] = newId;
+        log.info(`Updated allowlist: ${oldId} → ${newId}`);
+      }
+    }
+
+    // Update connections.json: replace all references to oldId with newId
+    try {
+      const data = JSON.parse(fs.readFileSync(CONNECTIONS_FILE, 'utf8'));
+      if (Array.isArray(data.connections)) {
+        let changed = false;
+        for (const conn of data.connections) {
+          if (String(conn.chatId) === oldId) {
+            conn.chatId = newId;
+            changed = true;
+          }
+        }
+        if (changed) {
+          fs.writeFileSync(CONNECTIONS_FILE, JSON.stringify(data, null, 2));
+          log.info(`Updated connection: ${oldId} → ${newId}`);
+        }
+      }
+    } catch (_) {}
+
+    // Update in-memory chat state key (the existing state remains, just
+    // the key changes — new messages from newId will hit a new state)    
   }
 
   // Poll for updates and forward each text message to OpenCode, sending the answer back.
@@ -1237,12 +1945,22 @@ async function main() {
       offset = update.update_id + 1;
 
       const msg = update.message;
-      if (!msg || typeof msg.text !== 'string') {
-        // Ignore non-text messages (photos, stickers, etc.)
+      if (!msg) continue;
+
+      // Handle group → supergroup migration (e.g., when topics are enabled)
+      if (msg.migrate_to_chat_id) {
+        await handleGroupMigration(String(msg.chat.id), String(msg.migrate_to_chat_id));
+        continue;
+      }
+      if (msg.migrate_from_chat_id) {
+        await handleGroupMigration(String(msg.migrate_from_chat_id), String(msg.chat.id));
         continue;
       }
 
+      if (typeof msg.text !== 'string') continue;
+
       const chatId = String(msg.chat.id);
+      const threadId = msg.message_thread_id || null;
       const replyTo = msg.message_id;
       const text = msg.text;
       const from = msg.from?.username
@@ -1251,21 +1969,22 @@ async function main() {
 
       // Enforce chat allowlist if configured
       if (allowedChatIds && !allowedChatIds.includes(chatId)) {
-        log.debug(`[chat ${chatId}] ${from}: blocked (not in allowlist)`);
+        const chatLabel = msg.chat?.title ? ` (${msg.chat.title})` : '';
+        log.debug(`[chat ${chatId}]${chatLabel} ${from}: blocked (not in allowlist)`);
+        // Log a hint if the old chat ID is known in connections.json
+        const blockedDebug = `[chat ${chatId}]${chatLabel} ${from}: blocked (not in allowlist)`;
+        const known = Object.keys(connByOldId);
+        if (known.length > 0) {
+          log.debug(`  Known connections: ${known.join(', ')}. Chat may have been migrated (enable topics → supergroup changes chat ID).`);
+        }
         continue;
       }
 
-      // Lock to the first chat that connects (single-user guard)
-      if (lockedChatId === null) {
-        lockedChatId = chatId;
-        log.debug(`[chat ${chatId}] ${from}: locked to this chat`);
-      } else if (lockedChatId !== chatId) {
-        log.debug(`[chat ${chatId}] ${from}: blocked (locked to ${lockedChatId})`);
-        continue;
-      }
+      // Per-chat state: get or create for this chat (thread-aware)
+      const cs = getChatState(chatId, threadId);
 
       log.debug(`[chat ${chatId}] ${from}: ${text}`);
-      try { fs.writeFileSync(STARTUP_CHAT_FILE, String(chatId)); } catch (_) {}
+      msgLog('in', chatId, from, text);
 
       // Build reply context if this message is a Telegram reply
       const replyContext = quoteReply(msg);
@@ -1277,29 +1996,75 @@ async function main() {
         const cmdArgs = parts.slice(1);
         const handler = cmds[cmd];
         if (handler) {
+          // Disconnected guard: only /help, /servers, /force-switch, /start, /comment, and /shutdown work without a server
+          if (!cs.serverBase && cmd !== 'help' && cmd !== 'servers' && cmd !== 'force-switch' && cmd !== 'start' && cmd !== 'comment' && cmd !== 'shutdown') {
+            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, setServer, setActiveSession, serverBase);
+            await handler(token, chatId, cmdArgs, cs, setServerForChat, setActiveSessionForChat);
           } catch (err) {
             log.error(`Error handling /${cmd}: ${err.message}`);
-            try { await sendLongMessage(token, chatId, `Error: ${err.message}`); } catch (_) {}
+            try { await sendLongMessage(token, cs, `Error: ${err.message}`); } catch (_) {}
           }
         } else {
-          await sendLongMessage(token, chatId,
-            `Unknown command: /${cmd}\n\nAvailable commands: /help, /status, /servers, /sessions, /agents, /models`);
+          await sendLongMessage(token, cs,
+            `Unknown command: /${cmd}\n\nAvailable commands: /help, /status, /servers, /sessions, /agents, /models, /think, /record, /queue, /flush, /note, /comment, /disconnect`);
         }
         continue;
       }
 
+      // Disconnected guard for non-command messages
+      if (!cs.serverBase) {
+        await sendLongMessage(token, cs,
+          '🔌 Not connected to any server.\n\n' +
+          'Use `/servers` to see available servers and `/servers switch <name>` to connect.');
+        continue;
+      }
+
+      // Buffer user messages for /record
+      bufferMessage(chatId, threadId, 'user', replyContext + text);
+
       // Non-command message ─ process in background
-      const st = getState(serverBase);
+      const st = getState(cs.serverBase);
+
+      // Server health check: detect dead servers and auto-reconnect
+      if (st.serverDead) {
+        const alive = await isServerAlive(cs.serverBase);
+        if (alive) {
+          st.serverDead = false;
+          log.info(`Server ${cs.serverBase} is back online`);
+        }
+      }
+      if (st.serverDead) {
+        // Server is dead ─ auto-queue and notify
+        if (!st.messageQueue) st.messageQueue = [];
+        st.messageQueue.push({ text: replyContext + text, replyTo });
+        const qlen = st.messageQueue.length;
+        const servers = listServers();
+        const suggestions = [];
+        suggestions.push(`• Start the server: \`ocmux serve\``);
+        if (servers.length > 0) {
+          suggestions.push(`• Switch to another server: \`/servers switch <name>\``);
+        }
+        suggestions.push(`• Flush the queue: \`/flush\``);
+        await sendLongMessage(token, cs,
+          `⚠️ Server \`${cs.serverBase}\` is not reachable.\n\n` +
+          `Your message has been queued (#${qlen}). It will be sent when the server becomes available.\n\n` +
+          `**Options:**\n${suggestions.join('\n')}`);
+        continue;
+      }
+
       if (st.busy) {
-        await sendLongMessage(token, chatId, '⏳ Server is busy processing a previous message. Please wait for it to finish, or use /cancel to cancel it.');
+        await sendLongMessage(token, cs, '⏳ Server is busy. Use `/cancel` to cancel or `/queue <message>` to queue your message.');
         continue;
       }
       st.busy = true;
       const myTaskId = ++st.taskId;
       log.debug(`  → started background processing (task ${myTaskId})`);
-      processMessageAsync(chatId, replyContext + text, serverBase, !!st.activeSessionId, st.activeSessionId, myTaskId, replyTo);
+      processMessageAsync(chatId, replyContext + text, cs.serverBase, !!st.activeSessionId, st.activeSessionId, myTaskId, replyTo, threadId);
     }
   }
 }