agentp 0.11.10 → 0.12.0

package/bin/tgagentp

@@ -4,7 +4,7 @@ const http = require('http');
 const fs = require('fs');
 const path = require('path');
 const { version } = require('../package.json');
-const { getAuthHeaders, sendText, listenForFinalAnswer, listSessions, createSession, updateSession, selectSession, sendToSession, sendToSessionAsync, respondToPermission, respondToQuestion, listenForSessionEvents, listAgents, listProviders, isServerAlive } = require('../lib/opencode.js');
+const { getAuthHeaders, makeRequest, buildJsonRequest, sendText, listenForFinalAnswer, listSessions, createSession, updateSession, selectSession, sendToSession, sendToSessionAsync, respondToPermission, respondToQuestion, listenForSessionEvents, listAgents, listProviders, isServerAlive } = require('../lib/opencode.js');
 
 // Logger: info→stdout, error→stderr (always), debug→stderr (--verbose only)
 const log = {
@@ -264,53 +264,103 @@ async function cmdHelp(token, chatId, args, chatState) {
     const topic = args[0].toLowerCase();
     if (topic === 'servers') {
       await sendLongMessage(token, chatState,
-        '`/servers` ─ list all opencode servers (ocmux sessions)\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.');
+        '`/servers` ─ list running servers\n' +
+        '  • Shows alive and dead servers\n' +
+        '  • Your server marked with ▶\n\n' +
+        '`/server <name>` ─ switch to a server by directory path or basename\n' +
+        '`/server --force <name>` ─ take over a server from another chat');
+      return;
+    }
+    if (topic === 'agents') {
+      await sendLongMessage(token, chatState,
+        '`/agents` ─ list primary agents\n' +
+        '  • Current agent marked with ▶\n' +
+        '  • Shows model and description\n\n' +
+        '`/agent <name>` ─ switch to an agent');
+      return;
+    }
+    if (topic === 'sessions') {
+      await sendLongMessage(token, chatState,
+        '`/sessions` ─ list sessions\n' +
+        '  • Primary-agent sessions shown by default (includes subagent sessions to maintain context)\n' +
+        '  • Active session marked with ▶\n' +
+        '  • Grouped by recency: Today, this week, older months\n\n' +
+        '`/session <name-or-number>` ─ switch to a session by name or position\n' +
+        '`/session new [name]` ─ create a new session\n' +
+        '`/session rename <name>` ─ rename the active session');
       return;
     }
     if (topic === 'sessions') {
       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' +
-        '`/sessions rename <name>` ─ rename the active session\n\n' +
+        '`/session <name-or-number>` ─ switch to a session by name or position\n' +
+        '`/session new [name]` ─ create a new session\n' +
+        '`/session rename <name>` ─ rename the active session\n\n' +
         'Switch by number (from the list) or by case-insensitive partial name match.\n' +
         'Use `/sessions` to find session numbers.');
       return;
     }
-    if (topic === 'shutdown') {
+    if (topic === 'servers') {
+      await sendLongMessage(token, chatState,
+        '`/servers` ─ list running servers\n' +
+        '  • Shows alive and dead servers\n' +
+        '  • Your server marked with ▶\n\n' +
+        '`/server <name>` ─ switch to a server by directory path or basename\n' +
+        '`/server --force <name>` ─ take over a server from another chat');
+      return;
+    }
+    if (topic === 'server') {
       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' +
-        'Useful when running tgagentp in a restart loop:\n' +
-        '`while true; do tgagentp --dev; done`');
+        '`/server <name>` ─ switch to a server by directory path or basename.\n' +
+        '`/server --force <name>` ─ take over a server from another chat.\n\n' +
+        'Matches by full directory path, basename, or case-insensitive substring.\n' +
+        'Use `/servers` to see available servers.');
       return;
     }
     if (topic === 'agents') {
       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`).');
+        '`/agent <name>` ─ switch the active agent. Subsequent messages will use this agent.\n\n' +
+        'Agent switching requires an active session (`/session <name>` or `/session new`).');
+      return;
+    }
+    if (topic === 'agent') {
+      await sendLongMessage(token, chatState,
+        '`/agent <name>` ─ switch the active agent.\n\n' +
+        'Matches by exact name first, then case-insensitive substring.\n' +
+        'The agent is synced to the server session via API.\n' +
+        'Use `/agents` to list available agents.');
       return;
     }
     if (topic === 'session') {
       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' +
-        '`/sessions new [name]` ─ create a new session\n' +
-        '`/sessions rename <name>` ─ rename the active session');
+        '`/session <name-or-number>` ─ switch to a session by name or position\n' +
+        '`/session new [name]` ─ create a new session\n' +
+        '`/session rename <name>` ─ rename the active session\n\n' +
+        'Use `/sessions` to list available sessions with numbers.');
       return;
     }
     if (topic === 'models') {
       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.');
+        '`/models` ─ list connected providers.\n' +
+        '  • Shows provider names with model count: `**OpenAI** (*5 models*)`\n' +
+        '  • The current provider is marked with ▶\n' +
+        '  • Includes hint to drill down: `/models <provider>`\n\n' +
+        '`/models <provider>` ─ list all models for a matching provider.\n' +
+        '  • Partial name/ID matching supported\n' +
+        '  • Current model marked with ▶\n' +
+        '  • Shows context limit and input/output costs in parentheses\n\n' +
+        'Use `/model <providerID/modelID>` or `/model <modelID>` to switch the active session model.');
+      return;
+    }
+    if (topic === 'model') {
+      await sendLongMessage(token, chatState,
+        '`/model <providerID/modelID>` ─ switch the active session to a specific model.\n' +
+        '`/model <modelID>` ─ search all connected providers for a model by name.\n\n' +
+        'Examples:\n' +
+        '  `/model opencode/big-pickle` ─ explicit provider/model\n' +
+        '  `/model gpt-4` ─ search across all providers\n\n' +
+        'Use `/models` to see available providers and models.');
       return;
     }
     if (topic === 'allow' || topic === 'reject' || topic === 'always' || topic === 'answer') {
@@ -374,7 +424,7 @@ async function cmdHelp(token, chatId, args, chatState) {
     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.');
+        'Clears the server connection for this chat. Use `/server <name>` to reconnect.');
       return;
     }
     if (topic === 'status') {
@@ -437,7 +487,7 @@ async function cmdHelp(token, chatId, args, chatState) {
       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`, `/help markdown`, or just `/help`.');
+      'Unknown topic. Try `/help servers`, `/help server`, `/help sessions`, `/help session`, `/help agents`, `/help agent`, `/help models`, `/help model`, `/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,
@@ -446,16 +496,16 @@ async function cmdHelp(token, chatId, args, chatState) {
     '`/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' +
-    '`/sessions rename <name>` ─ rename the active session\n' +
-    '`/session` ─ alias for `/sessions`\n' +
+    '`/server <name>` ─ switch to a different server\n' +
+    '`/server --force <name>` ─ take over a server from another chat\n' +
+    '`/sessions` ─ list sessions\n' +
+    '`/session <name-or-number>` ─ switch to a session\n' +
+    '`/session new [name]` ─ create a new session\n' +
+    '`/session rename <name>` ─ rename the active session\n' +
     '`/agents` ─ list available agents\n' +
-    '`/agents switch <name>` ─ switch active agent\n' +
+    '`/agent <name>` ─ switch active agent\n' +
     '`/models` ─ list providers and models\n' +
+    '`/model <provider/model>` ─ switch session model\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' +
@@ -473,90 +523,18 @@ async function cmdHelp(token, chatId, args, chatState) {
     'Everything else is forwarded to the active server as `[Telegram] <text>`.');
 }
 
-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 = switchArgs.join(' ');
-    const servers = listServers();
-    if (servers.length === 0) {
-      await sendLongMessage(token, chatState, 'No servers running.');
-      return;
-    }
-
-    // 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).toLowerCase() === name.toLowerCase());
-    }
-    // Fallback: case-insensitive substring match
-    if (matches.length === 0) {
-      const lowerName = name.toLowerCase();
-      matches = servers.filter(s => s.dir.toLowerCase().includes(lowerName) || path.basename(s.dir).toLowerCase().includes(lowerName));
-    }
-
-    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;
-      }
-    }
-    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;
+  // Backward compatibility: redirect old subcommands to singular commands
+  if (args.length > 0) {
+    const sub = args[0].toLowerCase();
+    if (sub === 'switch') {
+      const rest = args.slice(1).filter(a => a !== '--force');
+      const force = args.includes('--force');
+      return cmdServer(token, chatId, force ? ['--force', ...rest] : rest, chatState, setServerForChat, setActiveSessionForChat);
     }
-    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, chatState, msg);
-      await sendLongMessage(token, chatState, pending.trim());
-    } else {
-      await sendLongMessage(token, chatState, msg);
+    if (sub === 'force-switch') {
+      return cmdServer(token, chatId, ['--force', ...args.slice(1)], chatState, setServerForChat, setActiveSessionForChat);
     }
-    return;
   }
 
   // Default: list servers (alive + dead)
@@ -634,106 +612,19 @@ async function discoverActiveSession(server) {
 
 async function cmdSessions(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
   const server = chatState.serverBase;
+  // Backward compatibility: redirect old subcommands to singular commands
   if (args.length > 0) {
     const sub = args[0].toLowerCase();
-
-    if (sub === 'new') {
-      const title = args.slice(1).join(' ') || undefined;
-      try {
-        const session = await createSession(server, title);
-        const name = session.title || session.slug || session.id;
-        setActiveSessionForChat(chatState, session.id, name);
-        selectSession(server, session.id);
-        await sendLongMessage(token, chatState,
-          `Created session: \`${name}\`\nIt is now the active session.`);
-      } catch (err) {
-        await sendLongMessage(token, chatState, `Error creating session: ${err.message}`);
-      }
-      return;
-    }
-
-    if (sub === 'rename') {
-      if (args.length < 2) {
-        await sendLongMessage(token, chatState, 'Usage: `/sessions rename <name>`');
-        return;
-      }
-      const st = getState(server);
-      if (!st.activeSessionId) {
-        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, chatState,
-          `Renamed session to: \`${name}\``);
-      } catch (err) {
-        await sendLongMessage(token, chatState, `Error renaming session: ${err.message}`);
-      }
-      return;
-    }
-
-    if (sub === 'switch') {
-      if (args.length < 2) {
-        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;
-      }
-      const query = args.slice(1).join(' ');
-      try {
-        const projectDir = serverDir(server);
-        const sessions = await listSessions(server, projectDir);
-        const activeId = getState(server).activeSessionId;
-        const filtered = sessions.filter(s =>
-          (s.agent || s.directory || s.id === activeId) && (!projectDir || s.directory === projectDir));
-        const sorted = sortedSessions(filtered, 50);
-
-        // Try by position number first
-        const num = parseInt(query, 10);
-        if (/^\d+$/.test(query) && num >= 1 && num <= sorted.length) {
-          const target = sorted[num - 1];
-          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.`);
-          return;
-        }
-
-        // Try by name (case-insensitive partial match)
-        const q = query.toLowerCase();
-        const matches = sorted.filter(s => sessionName(s).toLowerCase().includes(q));
-        if (matches.length === 0) {
-          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, chatState,
-            `Multiple matches for "${query}":\n${list}\n\nPlease be more specific or use a number.`);
-          return;
-        }
-        const target = matches[0];
-        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.`);
-      } catch (err) {
-        await sendLongMessage(token, chatState, `Error switching session: ${err.message}`);
-      }
-      return;
+    if (sub === 'switch' || sub === 'new' || sub === 'rename') {
+      return cmdSession(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat);
     }
-
-    // Unknown subcommand
     await sendLongMessage(token, chatState,
       `Unknown subcommand: /sessions ${sub}\n\n` +
       'Usage:\n' +
       '  `/sessions` ─ list sessions\n' +
-      '  `/sessions switch <number-or-name>` ─ switch to a session\n' +
-      '  `/sessions new [name]` ─ create a new session\n' +
-      '  `/sessions rename <name>` ─ rename the active session');
+      '  `/session <name-or-number>` ─ switch to a session\n' +
+      '  `/session new [name]` ─ create a new session\n' +
+      '  `/session rename <name>` ─ rename the active session');
     return;
   }
 
@@ -807,48 +698,9 @@ async function cmdSessions(token, chatId, args, chatState, setServerForChat, set
 
 async function cmdAgents(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
   const server = chatState.serverBase;
+  // Backward compatibility: redirect /agents switch to /agent
   if (args.length > 0 && args[0].toLowerCase() === 'switch') {
-    if (args.length < 2) {
-      await sendLongMessage(token, chatState,
-        'Usage: `/agents switch <name>`\n' +
-        'Use `/agents` to list available agents.');
-      return;
-    }
-    const name = args.slice(1).join(' ');
-    try {
-      const agents = await listAgents(server);
-      if (!agents || agents.length === 0) {
-        await sendLongMessage(token, chatState, 'No agents available.');
-        return;
-      }
-      let matches = agents.filter(a => a.name === name);
-      if (matches.length === 0) {
-        matches = agents.filter(a => a.name.toLowerCase().includes(name.toLowerCase()));
-      }
-      if (matches.length === 0) {
-        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, chatState,
-          `Multiple matches for "${name}":\n${list}\n\nPlease be more specific.`);
-        return;
-      }
-      const target = matches[0];
-      getState(server).activeAgentName = target.name;
-      const st = getState(server);
-      if (st.activeSessionId) {
-        updateSession(server, st.activeSessionId, undefined, target.name);
-        selectSession(server, st.activeSessionId);
-      }
-      const model = target.model ? ` ─ \`${target.model.providerID}/${target.model.modelID}\`` : '';
-      await sendLongMessage(token, chatState,
-        `Switched to agent: **${target.name}**${model}\nSubsequent messages will use this agent.`);
-    } catch (err) {
-      await sendLongMessage(token, chatState, `Error switching agent: ${err.message}`);
-    }
-    return;
+    return cmdAgent(token, chatId, args.slice(1), chatState, setServerForChat, setActiveSessionForChat);
   }
 
   try {
@@ -888,27 +740,124 @@ async function cmdModels(token, chatId, args, chatState, setServerForChat, setAc
       return;
     }
 
-    const lines = [];
-
-    for (const provider of filtered) {
-      lines.push('');
-      lines.push('**' + provider.name + '** ✅');
+    // Determine current model: session model first (the real in-use model,
+    // including manual /model TUI switches), then fall back to the agent's
+    // configured default model.
+    let currentProviderID = null;
+    let currentModelID = null;
+    const st = getState(server);
+    let activeSid = st.activeSessionId;
+    log.info(`[cmdModels] activeSessionId=${activeSid} activeAgentName=${st.activeAgentName}`);
+    // Auto-discover active session if not set
+    if (!activeSid) {
+      try {
+        const discovered = await discoverActiveSession(server);
+        if (discovered) {
+          st.activeSessionId = discovered.id;
+          st.activeSessionName = discovered.name;
+          activeSid = discovered.id;
+          log.info(`[cmdModels] auto-discovered session: ${discovered.name || discovered.id}`);
+        }
+      } catch (err) {
+        log.info(`[cmdModels] auto-discover error: ${err.message}`);
+      }
+    }
+    if (activeSid) {
+      try {
+        const sessions = await listSessions(server);
+        const session = sessions.find(s => String(s.id) === String(activeSid));
+        if (session && session.model) {
+          const m = session.model;
+          log.info(`[cmdModels] session model: ${JSON.stringify(m)}`);
+          if (typeof m === 'object' && m.providerID) {
+            currentProviderID = m.providerID;
+            currentModelID = m.modelID || m.id;
+          } else if (typeof m === 'string') {
+            const parts = m.split('/');
+            if (parts.length === 2) {
+              currentProviderID = parts[0];
+              currentModelID = parts[1];
+            }
+          }
+        } else {
+          log.info(`[cmdModels] session found=${!!session}, has model=${session && !!session.model}`);
+        }
+      } catch (err) {
+        log.info(`[cmdModels] listSessions error: ${err.message}`);
+      }
+    }
+    // Fallback: active agent's configured model
+    if (!currentModelID) {
+      const activeAgentName = st.activeAgentName;
+      if (activeAgentName) {
+        try {
+          const agents = await listAgents(server);
+          const activeAgent = agents.find(a => a.name === activeAgentName);
+          if (activeAgent && activeAgent.model) {
+            const am = activeAgent.model;
+            log.info(`[cmdModels] agent model: ${JSON.stringify(am)}`);
+            currentProviderID = am.providerID;
+            currentModelID = am.modelID || am.id;
+          } else {
+            log.info(`[cmdModels] agent found=${!!activeAgent}, has model=${activeAgent && !!activeAgent.model}`);
+          }
+        } catch (err) {
+          log.info(`[cmdModels] listAgents error: ${err.message}`);
+        }
+      }
+    }
+    log.info(`[cmdModels] result: provider=${currentProviderID} model=${currentModelID}`);
 
+    // /models <provider> — list all models for a matching provider
+    if (args.length > 0) {
+      const query = args.join(' ');
+      const matches = filtered.filter(p =>
+        p.name.toLowerCase().includes(query.toLowerCase()) ||
+        p.id.toLowerCase().includes(query.toLowerCase())
+      );
+      if (matches.length === 0) {
+        await sendLongMessage(token, chatState, `No provider matching "${query}".`);
+        return;
+      }
+      if (matches.length > 1) {
+        const list = matches.map(p => '  `' + p.name + '`').join('\n');
+        await sendLongMessage(token, chatState,
+          `Multiple matches for "${query}":\n${list}\n\nPlease be more specific.`);
+        return;
+      }
+      const provider = matches[0];
       const modelEntries = Object.entries(provider.models || {});
-      if (modelEntries.length === 0) continue;
-
-      const shown = modelEntries.slice(0, 5);
-      for (const [id, model] of shown) {
-        const ctx = model.limit ? Math.round(model.limit.context / 1000) + 'K' : '';
-        const cost = model.cost ? ` $${model.cost.input}/${model.cost.output}` : '';
-        lines.push('  `' + id + '`' + (ctx ? ' ' + ctx : '') + cost);
+      if (modelEntries.length === 0) {
+        await sendLongMessage(token, chatState,
+          '**' + provider.name + '** has no models configured.');
+        return;
       }
-      if (modelEntries.length > 5) {
-        lines.push('  *…and ' + (modelEntries.length - 5) + ' more*');
+      const lines = ['**' + provider.name + '** models:'];
+      for (const [id, model] of modelEntries) {
+        const isCurrent = currentProviderID === provider.id && currentModelID === id;
+        const bullet = isCurrent ? '\u25b6 ' : '\u00b7 ';
+        const extras = [];
+        if (model.limit) extras.push(Math.round(model.limit.context / 1000) + 'K ctx');
+        if (model.cost) extras.push(`$${model.cost.input}/$${model.cost.output}`);
+        const suffix = extras.length > 0 ? ` (*${extras.join(', ')}*)` : '';
+        lines.push(bullet + '`' + id + '`' + suffix);
       }
+      await sendLongMessage(token, chatState, lines.join('\n'));
+      return;
     }
 
-    await sendLongMessage(token, chatState, 'Connected providers:\n' + lines.join('\n'));
+    // Default: list providers with model count per provider
+    const lines = ['**Connected providers:**'];
+    for (const provider of filtered) {
+      const modelCount = Object.keys(provider.models || {}).length;
+      const isCurrentProvider = currentProviderID === provider.id;
+      const bullet = isCurrentProvider ? '\u25b6 ' : '\u00b7 ';
+      lines.push(bullet + '**' + provider.name + '**' +
+        (modelCount > 0 ? ` (*${modelCount} models*)` : ' *No models*'));
+    }
+    lines.push('');
+    lines.push('\u{1f4a1} Use `/models <provider>` to list the models it provides.');
+    await sendLongMessage(token, chatState, lines.join('\n'));
   } catch (err) {
     await sendLongMessage(token, chatState, `Error listing models: ${err.message}`);
   }
@@ -1525,7 +1474,7 @@ async function cmdServe(token, chatId, args, chatState, setServerForChat, setAct
     } else {
       await sendLongMessage(token, chatState,
         `⚠️ Server already exists for \`${relPath}\`.\n` +
-        'Use `/servers switch <name>` to connect to it.');
+        'Use `/server <name>` to connect to it.');
     }
     return;
   }
@@ -1614,6 +1563,319 @@ async function cmdNew(token, chatId, args, chatState, setServerForChat, setActiv
   log.info(`[chat ${chatId}] Created ${targetDir} → ${url}`);
 }
 
+async function cmdModel(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const server = chatState.serverBase;
+  const st = getState(server);
+  // Auto-discover active session if not set
+  if (!st.activeSessionId) {
+    try {
+      const discovered = await discoverActiveSession(server);
+      if (discovered) {
+        st.activeSessionId = discovered.id;
+        st.activeSessionName = discovered.name;
+      }
+    } catch (err) {
+      log.info(`[cmdModel] auto-discover error: ${err.message}`);
+    }
+  }
+  if (args.length === 0) {
+    await sendLongMessage(token, chatState,
+      'Usage: `/model <providerID/modelID>` or `/model <modelID>` to search.\n' +
+      'Example: `/model opencode/big-pickle` or `/model gpt-4`');
+    return;
+  }
+  if (!st.activeSessionId) {
+    await sendLongMessage(token, chatState, 'No active session. Use `/sessions` to select one.');
+    return;
+  }
+  const query = args[0];
+  let providerID, modelID;
+
+  // Try "providerID/modelID" format first
+  if (query.includes('/')) {
+    const parts = query.split('/');
+    const rawProviderID = parts[0];
+    modelID = parts[1];
+    providerID = rawProviderID;
+
+    // Validate provider ID exists, or try partial match (e.g. "go" → "opencode-go")
+    try {
+      const result = await listProviders(server);
+      const all = result.all || [];
+      const connectedIds = result.connected || [];
+      const connected = all.filter(p => connectedIds.includes(p.id));
+      const exists = connected.some(p => p.id === rawProviderID);
+      if (!exists) {
+        const match = connected.find(p =>
+          (p.name && p.name.toLowerCase().includes(rawProviderID.toLowerCase())) ||
+          (p.id && p.id.toLowerCase().includes(rawProviderID.toLowerCase()))
+        );
+        if (match) {
+          providerID = match.id;
+          log.info(`[cmdModel] resolved "${rawProviderID}" → "${match.id}"`);
+        } else {
+          await sendLongMessage(token, chatState,
+            `Provider "${rawProviderID}" not found. Use \`/models\` to list available providers.`);
+          return;
+        }
+      }
+      // Verify model exists under this provider
+      const provider = all.find(p => p.id === providerID);
+      if (!provider || !provider.models || !provider.models[modelID]) {
+        const availableModels = provider && provider.models ? Object.keys(provider.models).join(', ') : 'unknown';
+        log.info(`[cmdModel] model "${modelID}" not found in ${providerID}, available: ${availableModels}`);
+        await sendLongMessage(token, chatState,
+          `Model "${modelID}" not found under provider \`${providerID}\`. Use \`/models\` to list available models.`);
+        return;
+      }
+    } catch (err) {
+      log.info(`[cmdModel] provider validation error: ${err.message}`);
+      // Continue with what we have — may still work
+    }
+  } else {
+    // Search across all connected providers to resolve to providerID/modelID
+    try {
+      const result = await listProviders(server);
+      const all = result.all || [];
+      const connectedIds = result.connected || [];
+      const connected = all.filter(p => connectedIds.includes(p.id));
+      for (const provider of connected) {
+        const models = Object.keys(provider.models || {});
+        const match = models.find(m => m.toLowerCase() === query.toLowerCase());
+        if (match) {
+          providerID = provider.id;
+          modelID = match;
+          break;
+        }
+      }
+    } catch (err) {
+      log.info(`[cmdModel] listProviders error: ${err.message}`);
+    }
+    if (!modelID) {
+      await sendLongMessage(token, chatState,
+        `No model matching "${query}" found in any connected provider. Use \`/models\` to list available models.`);
+      return;
+    }
+  }
+
+  // Send an async no-reply message with the desired model.
+  // This triggers createUserMessage which fires ModelSwitched when the model differs,
+  // persisting it as the session's current model.
+  try {
+    await sendToSessionAsync(server, st.activeSessionId, '.', null, { providerID, modelID }, true);
+    const label = providerID ? `\`${providerID}/${modelID}\`` : `\`${modelID}\``;
+    await sendLongMessage(token, chatState,
+      `✅ Switched to model ${label}.`);
+    log.info(`[chat ${chatId}] Switched to model ${providerID || '?'}/${modelID}`);
+  } catch (err) {
+    await sendLongMessage(token, chatState, `Error switching model: ${err.message}`);
+  }
+}
+
+async function cmdServer(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  if (args.length === 0) {
+    await sendLongMessage(token, chatState,
+      'Usage: `/server <name>`\n' +
+      'To force-switch (take over a server from another chat), use `/server --force <name>`.\n' +
+      '`<name>` can be a full directory path or a basename.\n' +
+      'Use `/servers` to list available servers.');
+    return;
+  }
+  const forceIdx = args.indexOf('--force');
+  const force = forceIdx !== -1;
+  const nameArgs = args.filter((a, i) => a !== '--force');
+  if (nameArgs.length === 0) {
+    await sendLongMessage(token, chatState,
+      'Usage: `/server <name>`\n' +
+      'To force-switch, use `/server --force <name>`.');
+    return;
+  }
+  const name = nameArgs.join(' ');
+  const servers = listServers();
+  if (servers.length === 0) {
+    await sendLongMessage(token, chatState, 'No servers running.');
+    return;
+  }
+  let matches = servers.filter(s => s.dir.toLowerCase() === name.toLowerCase());
+  if (matches.length === 0) {
+    matches = servers.filter(s => path.basename(s.dir).toLowerCase() === name.toLowerCase());
+  }
+  if (matches.length === 0) {
+    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, chatState, `No server found matching "${name}".`);
+    return;
+  }
+  if (matches.length > 1) {
+    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;
+    }
+  }
+  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 \`/server --force ${name}\` to take over (the other chat will be disconnected).`);
+    return;
+  }
+  if (force && existing && existing.chatId !== chatState.chatId) {
+    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, chatState, msg);
+    await sendLongMessage(token, chatState, pending.trim());
+  } else {
+    await sendLongMessage(token, chatState, msg);
+  }
+}
+
+async function cmdSession(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const server = chatState.serverBase;
+  if (args.length === 0) {
+    await sendLongMessage(token, chatState,
+      '`/session <name-or-number>` ─ switch to a session\n' +
+      '`/session new [name]` ─ create a new session\n' +
+      '`/session rename <name>` ─ rename the active session\n' +
+      'Use `/sessions` to list available sessions.');
+    return;
+  }
+  const sub = args[0].toLowerCase();
+  if (sub === 'new') {
+    const title = args.slice(1).join(' ') || undefined;
+    try {
+      const session = await createSession(server, title);
+      const name = session.title || session.slug || session.id;
+      setActiveSessionForChat(chatState, session.id, name);
+      selectSession(server, session.id);
+      await sendLongMessage(token, chatState,
+        `Created session: \`${name}\`\nIt is now the active session.`);
+    } catch (err) {
+      await sendLongMessage(token, chatState, `Error creating session: ${err.message}`);
+    }
+    return;
+  }
+  if (sub === 'rename') {
+    if (args.length < 2) {
+      await sendLongMessage(token, chatState, 'Usage: `/session rename <name>`');
+      return;
+    }
+    const st = getState(server);
+    if (!st.activeSessionId) {
+      await sendLongMessage(token, chatState, 'No active session. Use `/session <name>` to select one 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, chatState, `Renamed session to: \`${name}\``);
+    } catch (err) {
+      await sendLongMessage(token, chatState, `Error renaming session: ${err.message}`);
+    }
+    return;
+  }
+  // Switch to session by name or number
+  const query = args.join(' ');
+  try {
+    const projectDir = serverDir(server);
+    const sessions = await listSessions(server, projectDir);
+    const activeId = getState(server).activeSessionId;
+    const filtered = sessions.filter(s =>
+      (s.agent || s.directory || s.id === activeId) && (!projectDir || s.directory === projectDir));
+    const sorted = sortedSessions(filtered, 50);
+    const num = parseInt(query, 10);
+    if (/^\d+$/.test(query) && num >= 1 && num <= sorted.length) {
+      const target = sorted[num - 1];
+      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.`);
+      return;
+    }
+    const q = query.toLowerCase();
+    const matches = sorted.filter(s => sessionName(s).toLowerCase().includes(q));
+    if (matches.length === 0) {
+      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, chatState,
+        `Multiple matches for "${query}":\n${list}\n\nPlease be more specific or use a number.`);
+      return;
+    }
+    const target = matches[0];
+    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.`);
+  } catch (err) {
+    await sendLongMessage(token, chatState, `Error switching session: ${err.message}`);
+  }
+}
+
+async function cmdAgent(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const server = chatState.serverBase;
+  if (args.length === 0) {
+    await sendLongMessage(token, chatState,
+      'Usage: `/agent <name>`\n' +
+      'Use `/agents` to list available agents.');
+    return;
+  }
+  const name = args.join(' ');
+  try {
+    const agents = await listAgents(server);
+    if (!agents || agents.length === 0) {
+      await sendLongMessage(token, chatState, 'No agents available.');
+      return;
+    }
+    let matches = agents.filter(a => a.name === name);
+    if (matches.length === 0) {
+      matches = agents.filter(a => a.name.toLowerCase().includes(name.toLowerCase()));
+    }
+    if (matches.length === 0) {
+      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, chatState,
+        `Multiple matches for "${name}":\n${list}\n\nPlease be more specific.`);
+      return;
+    }
+    const target = matches[0];
+    getState(server).activeAgentName = target.name;
+    const st = getState(server);
+    if (st.activeSessionId) {
+      updateSession(server, st.activeSessionId, undefined, target.name);
+      selectSession(server, st.activeSessionId);
+    }
+    const model = target.model ? ` ─ \`${target.model.providerID}/${target.model.modelID}\`` : '';
+    await sendLongMessage(token, chatState,
+      `Switched to agent: **${target.name}**${model}\nSubsequent messages will use this agent.`);
+  } catch (err) {
+    await sendLongMessage(token, chatState, `Error switching agent: ${err.message}`);
+  }
+}
+
 async function cmdMarkdown(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat, replyTo, replyToMsgId) {
   let entry = null;
   if (replyToMsgId) {
@@ -1637,11 +1899,13 @@ async function cmdMarkdown(token, chatId, args, chatState, setServerForChat, set
 const COMMANDS = {
   'help': cmdHelp,
   'servers': cmdServers,
-  'force-switch': cmdForceSwitch,
+  'server': cmdServer,
   'sessions': cmdSessions,
-  'session': cmdSessions,
+  'session': cmdSession,
   'agents': cmdAgents,
+  'agent': cmdAgent,
   'models': cmdModels,
+  'model': cmdModel,
   'think': cmdThink,
   'record': cmdRecord,
   'resurrect': cmdResurrect,
@@ -1851,6 +2115,7 @@ async function main() {
     if (srvDiscovered) {
       getState(url).activeSessionId = srvDiscovered.id;
       getState(url).activeSessionName = srvDiscovered.name;
+      startSessionMonitor(url, srvDiscovered.id);
       log.info(`  → session: ${srvDiscovered.name || srvDiscovered.id}`);
     }
     const defaultSrvAgent = srvAgents.find(a => a.mode === 'primary') || srvAgents[0];
@@ -1872,7 +2137,10 @@ async function main() {
     getState(server).activeSessionId = id;
     if (name) getState(server).activeSessionName = name;
     log.info(`[chat ${chatState.chatId}] Switched to session: ${name || id}`);
-    if (id !== prevId) sendGreeting(chatState);
+    if (id !== prevId) {
+      sendGreeting(chatState);
+      startSessionMonitor(server, id);
+    }
   };
 
   const TELEGRAM_GREETING_BODY = (sessionName) =>
@@ -1891,6 +2159,90 @@ async function main() {
     'For more details about a command:\n' +
     '[Telegram]{"command":"help","topic":"<upload|download|help>"}';
 
+  /**
+   * Start a persistent SSE session monitor that catches question.asked,
+   * permission_asked, and permission_replied events in the background,
+   * even when the AI was triggered by agentp (--tg) rather than by tgagentp.
+   * Automatically restarted when the session or server changes.
+   */
+  function startSessionMonitor(server, sessionId) {
+    const st = getState(server);
+    if (st._monitorRef && st._monitorRef.current) {
+      st._monitorRef.current.destroy();
+      st._monitorRef.current = null;
+    }
+    const monRef = { current: null };
+    st._monitorRef = monRef;
+    st._monitorStarted = true;
+
+    const notifiedPerms = new Set();
+
+    listenForSessionEvents(server, sessionId, {
+      onText: null,
+      onConnected: null,
+      onThinking: null,
+      onPermission: (perm) => {
+        const st2 = getState(server);
+        const permDump = JSON.stringify(perm);
+        log.debug(`  [monitor] -> permission_asked callback: ${permDump}`);
+        st2.pendingPermission = { server, sessionId, permissionId: perm.id, type: perm.permission || 'unspecified', pattern: perm.patterns || perm.pattern, title: perm.title };
+        const ownerChat = Object.entries(serverOwners).find(([url]) => normalizeUrl(url) === normalizeUrl(server))?.[1];
+        if (ownerChat && !notifiedPerms.has(perm.id)) {
+          notifiedPerms.add(perm.id);
+          const toolStr = perm.permission || 'unspecified';
+          const patternArr = perm.patterns || (perm.pattern ? [perm.pattern] : []);
+          const patternStr = patternArr.join(', ');
+          const msg = '\u{1f510}**Permission needed**\n'
+            + '**Tool:** `' + toolStr + '`\n'
+            + (patternStr ? '**Target:** `' + patternStr + '`\n' : '')
+            + (perm.title ? '**Detail:** ' + perm.title + '\n' : '')
+            + 'Use `/allow` to approve once, `/always` to always allow, or `/reject` to deny.';
+          log.debug(`  [monitor] -> sending permission notification to chat ${ownerChat.chatId}`);
+          sendLongMessage(token, { chatId: ownerChat.chatId, threadId: ownerChat.threadId }, msg)
+            .then(() => log.debug(`  [monitor] -> permission notification sent OK`))
+            .catch((err) => log.debug(`  [monitor] -> permission notification failed: ${err.message}`));
+        } else if (ownerChat) {
+          log.debug(`  [monitor] -> permission ${perm.id} already notified, updating pendingPermission only`);
+        } else {
+          log.debug(`  [monitor] -> no owner chat found for server ${server}, skipping notification`);
+        }
+      },
+      onPermissionReplied: () => {
+        log.debug(`  [monitor] -> permission_replied: clearing pendingPermission`);
+        getState(server).pendingPermission = null;
+      },
+      onQuestion: (q) => {
+        const st2 = getState(server);
+        const qDump = JSON.stringify(q);
+        log.debug(`  [monitor] -> question_asked callback: ${qDump}`);
+        st2.pendingQuestion = { server, sessionId, questionId: q.id, question: q.question || 'Unknown question', options: q.options || [] };
+        const ownerChat = Object.entries(serverOwners).find(([url]) => normalizeUrl(url) === normalizeUrl(server))?.[1];
+        if (ownerChat) {
+          const options = (q.options || []).map((opt, i) => `${i + 1}. ${opt.text || opt}`).join('\n');
+          const msg = '\u2753**Question from the AI**\n\n'
+            + (q.question || 'Choose an option:') + '\n\n'
+            + (options ? options + '\n\n' : '')
+            + 'Use `/answer <number>` to respond.';
+          log.debug(`  [monitor] -> sending question notification to chat ${ownerChat.chatId}`);
+          sendLongMessage(token, { chatId: ownerChat.chatId, threadId: ownerChat.threadId }, msg)
+            .then(() => log.debug(`  [monitor] -> question notification sent OK`))
+            .catch((err) => log.debug(`  [monitor] -> question notification failed: ${err.message}`));
+        } else {
+          log.debug(`  [monitor] -> no owner chat found for server ${server}, skipping question notification`);
+        }
+      },
+    }, monRef).then(() => {
+      // Normal completion (90s safety timeout or stream ended)
+    }, (err) => {
+      log.debug(`  [monitor] SSE listener for session ${sessionId} ended: ${err.message}`);
+    }).finally(() => {
+      if (getState(server)._monitorRef === monRef) {
+        getState(server)._monitorRef = null;
+        getState(server)._monitorStarted = false;
+      }
+    });
+  }
+
   async function sendGreeting(chatState) {
     const st = getState(chatState.serverBase);
     if (!st.activeSessionId) {
@@ -1928,10 +2280,17 @@ async function main() {
     if (st._sessionReq && st._sessionReq.current) { st._sessionReq.current.destroy(); st._sessionReq.current = null; }
     st._cancelRef = cancelRef;
     st._sessionReq = sessionCancelRef;
+
+    // Ensure the persistent session monitor is running so question/permission
+    // events from any source (agentp, tgagentp, TUI) are caught, not just
+    // those triggered by this message's per-request SSE listener.
+    if (useSession && sessionId && !st._monitorStarted) {
+      startSessionMonitor(url, sessionId);
+    }
+
     try {
       let answer;
       if (useSession) {
-        const notifiedPerms = new Set();
         let sseConnected;
         const onConnected = Promise.race([
           new Promise((resolve) => { sseConnected = resolve; }),
@@ -1953,48 +2312,9 @@ async function main() {
                 .catch(() => {});
             }
           },
-          onPermission: (perm) => {
-            const st2 = getState(url);
-            const permDump = JSON.stringify(perm);
-            log.debug(`  → permission_asked callback: ${permDump}`);
-            st2.pendingPermission = { server: url, sessionId, permissionId: perm.id, type: perm.permission || 'unspecified', pattern: perm.patterns || perm.pattern, title: perm.title };
-            if (!notifiedPerms.has(perm.id)) {
-              notifiedPerms.add(perm.id);
-              const toolStr = perm.permission || 'unspecified';
-              const patternArr = perm.patterns || (perm.pattern ? [perm.pattern] : []);
-              const patternStr = patternArr.join(', ');
-              const msg = '🔐 **Permission needed**\n'
-                + '**Tool:** `' + toolStr + '`\n'
-                + (patternStr ? '**Target:** `' + patternStr + '`\n' : '')
-                + (perm.title ? '**Detail:** ' + perm.title + '\n' : '')
-                + 'Use `/allow` to approve once, `/always` to always allow, or `/reject` to deny.';
-              log.debug(`  → sending permission notification to chat ${chatId}`);
-              sendLongMessage(token, chatState, msg, replyTo, threadId)
-                .then(() => log.debug(`  → permission notification sent OK`))
-                .catch((err) => log.debug(`  → permission notification failed: ${err.message}`));
-            } else {
-              log.debug(`  → permission ${perm.id} already notified, updating pendingPermission only`);
-            }
-          },
-          onPermissionReplied: () => {
-            log.debug(`  → permission_replied: clearing pendingPermission`);
-            getState(url).pendingPermission = null;
-          },
-          onQuestion: (q) => {
-            const st2 = getState(url);
-            const qDump = JSON.stringify(q);
-            log.debug(`  → question_asked callback: ${qDump}`);
-            st2.pendingQuestion = { server: url, sessionId, questionId: q.id, question: q.question || 'Unknown question', options: q.options || [] };
-            const options = (q.options || []).map((opt, i) => `${i + 1}. ${opt.text || opt}`).join('\n');
-            const msg = '❓ **Question from the AI**\n\n'
-              + (q.question || 'Choose an option:') + '\n\n'
-              + (options ? options + '\n\n' : '')
-              + 'Use `/answer <number>` to respond.';
-            log.debug(`  → sending question notification to chat ${chatId}`);
-            sendLongMessage(token, chatState, msg, replyTo, threadId)
-              .then(() => log.debug(`  → question notification sent OK`))
-              .catch((err) => log.debug(`  → question notification failed: ${err.message}`));
-          },
+          // onPermission, onPermissionReplied, and onQuestion are handled by
+          // the persistent session monitor (startSessionMonitor) so they are
+          // caught even when agentp (--tg) triggers the AI response.
         }, cancelRef).catch(() => {});
         await onConnected;
         answer = await sendToSession(url, sessionId, `[Telegram] ${text}`, st.activeAgentName, sessionCancelRef);
@@ -2003,8 +2323,8 @@ async function main() {
           sendLongMessage(token, chatState, html, replyTo, threadId).catch(() => {});
           st._thinkingBuf = '';
         }
-        // Keep the SSE listener alive so subsequent permission/question events
-        // that arrive after sendToSession returns are still forwarded to Telegram.
+        // Keep the per-request SSE listener alive for streaming text events.
+        // Questions and permissions are handled by the persistent monitor.
       } else {
         await sendText(url, `[Telegram] ${text}`);
         answer = await listenForFinalAnswer(url, null, cancelRef);
@@ -2059,7 +2379,7 @@ async function main() {
           ? `⚠️ Server \`${url}\` is unreachable. The message has been requeued and will be sent when the server is available again.\n\n` +
             `**Options:**\n` +
             `• Restart it: \`/resurrect\`\n` +
-            `• Switch to another server: \`/servers switch <name>\`\n` +
+            `• Switch to another server: \`/server <name>\`\n` +
             `• Flush the queue: \`/flush\``
           : `Error: ${err.message}`;
         try { await sendLongMessage(token, chatState, msg, replyTo, threadId); } catch (_) {}
@@ -2143,24 +2463,32 @@ async function main() {
     // 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 (_) {}
+      await sendLongMessage(token, cs, '\u{1f9f9} Connection state cleared.').catch(() => {});
+      log.info('/shutdown clear: exiting');
       process.exit(0);
     }
 
-    const isForce = args && args.length > 0 && args[0].toLowerCase() === 'force';
+    // Parse numeric exit code from args (default 0). Uses regex /^\d+$/
+    // to robustly match only pure-digit arguments.
+    let exitCode = 0;
+    for (const arg of (args || [])) {
+      if (/^\d+$/.test(arg)) {
+        exitCode = parseInt(arg, 10);
+        break;
+      }
+    }
+
+    const isForce = args && args.some(a => a.toLowerCase() === 'force');
     if (st.busy && !isForce) {
       await sendLongMessage(token, cs,
-        '⏳ Server is busy processing a message.\n' +
-        'Use `/shutdown force` to shut down anyway (in-flight response will be lost).');
+        '\u23f3 Server is busy processing a message.\n' +
+        'Use `/shutdown force` to shut down anyway (in-flight response will be lost).').catch(() => {});
       return;
     }
-    const status = st.busy ? '⏳ busy (forced)' : '✅ idle';
-    await sendLongMessage(token, cs, `👋 Shutting down (state: ${status})...`);
-    try { await getUpdates(token, offset, 1); } catch (_) {}
-    log.debug('/shutdown received, exiting...');
-    process.exit(0);
+    const status = st.busy ? '\u23f3 busy (forced)' : '\u2705 idle';
+    await sendLongMessage(token, cs, `\u{1f44b} Shutting down (state: ${status}, exit ${exitCode})...`).catch(() => {});
+    log.info(`/shutdown: exiting with code ${exitCode}`);
+    process.exit(exitCode);
   };
 
   const cmdNote = async (token, chatId, cmdArgs, chatState) => {
@@ -2289,7 +2617,7 @@ async function main() {
             await sendLongMessage(token, cs,
               '🔄 Bot started. Previously connected to `' + dir + '`.\n' +
               '⚠️ The server at `' + state.url + '` is not reachable.\n' +
-              'Use `/resurrect` to restart it, or `/servers switch <name>` to connect elsewhere.');
+              'Use `/resurrect` to restart it, or `/server <name>` to connect elsewhere.');
           } catch (_) {}
         }
       }
@@ -2335,6 +2663,18 @@ async function main() {
     // the key changes — new messages from newId will hit a new state)    
   }
 
+  // Drain stale updates from previous sessions before entering the poll loop.
+  // Using timeout=1 to return immediately without long-polling.
+  try {
+    const drainResult = await getUpdates(token, 0, 1);
+    if (drainResult && drainResult.ok && drainResult.result) {
+      for (const u of drainResult.result) {
+        offset = Math.max(offset, u.update_id + 1);
+      }
+      log.info(`Drained ${drainResult.result.length} stale update(s), offset ${offset}`);
+    }
+  } catch (_) {}
+
   // Poll for updates and forward each text message to OpenCode, sending the answer back.
   while (true) {
     let result;
@@ -2426,7 +2766,7 @@ async function main() {
               `Your file upload has been queued (#${qlen}). It will be sent when the server becomes available.\n\n` +
               `**Options:**\n` +
               `• Restart it: \`/resurrect\`\n` +
-              `• Switch to another server: \`/servers switch <name>\`\n` +
+              `• Switch to another server: \`/server <name>\`\n` +
               `• Flush the queue: \`/flush\``);
             continue;
           }
@@ -2576,11 +2916,11 @@ 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, /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') {
+          // Disconnected guard: /help, /servers, /server, /start, /comment, /shutdown, /serve, /new, and /resurrect work without a server
+          if (!cs.serverBase && cmd !== 'help' && cmd !== 'servers' && cmd !== 'server' && 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.');
+              'Use `/servers` to see available servers and `/server <name>` to connect.');
             continue;
           }
           try {
@@ -2592,7 +2932,7 @@ async function main() {
           }
         } 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, /markdown`);
+            `Unknown command: /${cmd}\n\nAvailable commands: /help, /status, /servers, /server, /sessions, /session, /agents, /agent, /models, /model, /think, /record, /queue, /flush, /note, /comment, /disconnect, /serve, /new, /markdown`);
         }
         continue;
       }
@@ -2601,7 +2941,7 @@ async function main() {
       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.');
+          'Use `/servers` to see available servers and `/server <name>` to connect.');
         continue;
       }
 
@@ -2628,7 +2968,7 @@ async function main() {
         const suggestions = [];
         suggestions.push(`• Restart it: \`/resurrect\``);
         if (servers.length > 0) {
-          suggestions.push(`• Switch to another server: \`/servers switch <name>\``);
+          suggestions.push(`• Switch to another server: \`/server <name>\``);
         }
         suggestions.push(`• Flush the queue: \`/flush\``);
         await sendLongMessage(token, cs,