agentp 0.11.9 → 0.11.11

package/README.md

@@ -241,8 +241,12 @@ Non-text Telegram updates (photos, stickers, etc.) are silently ignored.
 | `/always` | Approve and remember for the session |
 | `/answer <number>` | Respond to a question asked by the AI (structured multiple-choice) |
 | `/markdown` | Send the original markdown of the last response as a `.md` file; reply to a message to get that specific response |
+| `/agents list` | List available agents/models |
+| `/agents switch <name>` | Switch the active agent for subsequent messages (synced to server via API) |
 | `/shutdown [force\|clear]` | (requires `--dev`) Stop tgagentp; `clear` also wipes saved connections |
 
+> **Note on model/agent switching:** Changing the model in the OpenCode TUI's prompt dropdown is a **local UI action** — it only takes effect server-side after a message is sent *through the TUI*. If you change the model in the TUI and then send a prompt via `agentp` or Telegram, the old model will still be used. Use `/agents switch <name>` from Telegram (or `tgagentp`) to change models — this explicitly calls the API and syncs correctly.
+
 #### TUI Command Passthrough
 
 Messages starting with `//` are forwarded to the OpenCode TUI as raw keystrokes (not text sent to the AI):

package/bin/ocmux

@@ -309,6 +309,8 @@ function cmdNew(targetDir, longMode, printLogs) {
 }
 
 function doNew(targetDir, longMode, printLogs) {
+  // Normalize to real path so tmux window names are consistent regardless of symlinks
+  try { targetDir = fs.realpathSync(targetDir); } catch {}
   ensureSession();
   const lf = logfileFor(targetDir);
 
@@ -601,13 +603,26 @@ function main() {
       console.error("Error: '--print-logs' is only valid with 'serve'.");
       process.exit(1);
     }
-    // Default mode
-    const sf = findParentStatefile(targetDir);
+    // Default mode — find an existing server and switch to it
+    let sf = findParentStatefile(targetDir);
     if (!sf) {
       console.error(`Error: no opencode server found in ${targetDir} or any of its parents.`);
       console.error("Run 'ocmux serve' to create a new server.");
       process.exit(1);
     }
+
+    // Skip stale state files whose tmux window no longer exists,
+    // and search from the parent directory instead.
+    const state = readState(sf);
+    if (state && state.window_index != null) {
+      const serverDir = path.dirname(sf);
+      const actualName = windowNameByIndex(state.window_index);
+      if (actualName !== serverDir && windowByDir(serverDir) == null) {
+        const parentSf = findParentStatefile(path.dirname(serverDir));
+        if (parentSf) sf = parentSf;
+      }
+    }
+
     ensureSession();
     cmdSwitch(sf, longMode);
   }

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 = {
@@ -308,9 +308,25 @@ async function cmdHelp(token, chatId, args, chatState) {
     }
     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') {
@@ -888,27 +904,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}`);
   }
@@ -1614,6 +1727,115 @@ 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 cmdMarkdown(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat, replyTo, replyToMsgId) {
   let entry = null;
   if (replyToMsgId) {
@@ -1642,6 +1864,7 @@ const COMMANDS = {
   'session': cmdSessions,
   'agents': cmdAgents,
   'models': cmdModels,
+  'model': cmdModel,
   'think': cmdThink,
   'record': cmdRecord,
   'resurrect': cmdResurrect,
@@ -1851,6 +2074,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 +2096,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 +2118,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 +2239,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 +2271,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 +2282,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);
@@ -2143,24 +2422,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) => {
@@ -2335,6 +2622,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;
@@ -2592,7 +2891,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, /sessions, /agents, /models, /model, /think, /record, /queue, /flush, /note, /comment, /disconnect, /serve, /new, /markdown`);
         }
         continue;
       }

package/lib/ocmux.js

@@ -63,11 +63,16 @@ function tuiPaneId(windowIndex) {
 }
 
 function windowByDir(dir) {
+  let realDir;
+  try { realDir = fs.realpathSync(dir); } catch { realDir = dir; }
   const r = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index}\t#{window_name}']);
   if (r.status !== 0) return null;
   for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
     const [idx, name] = line.split('\t');
     if (name === dir) return parseInt(idx, 10);
+    try {
+      if (fs.realpathSync(name) === realDir) return parseInt(idx, 10);
+    } catch {}
   }
   return null;
 }
@@ -216,6 +221,7 @@ function activateServer(dir, index, url) {
 // Delegates to startServer for the actual server creation.
 // Returns { url, dir } on success, throws on error.
 function resurrectServer(dir, printLogs) {
+  try { dir = fs.realpathSync(dir); } catch {}
   const sf = path.join(dir, '.ocmux.json');
   const state = readState(sf);
 
@@ -249,6 +255,8 @@ function resurrectServer(dir, printLogs) {
 // Creates a tmux window, starts opencode serve, waits for the URL,
 // and writes .ocmux.json. Returns { url, dir } on success.
 function startServer(dir, printLogs) {
+  // Normalize to real path so tmux window names are consistent regardless of symlinks
+  try { dir = fs.realpathSync(dir); } catch {}
   ensureSession();
   const lf = logfileFor(dir);
 

package/lib/opencode.js

@@ -217,11 +217,17 @@ async function createSession(server, title) {
   return JSON.parse(responseBody);
 }
 
-// Update a session's properties (e.g. title).
-async function updateSession(server, sessionId, title, agent) {
+// Update a session's properties (e.g. title, agent, model).
+// model can be a string "providerID/modelID" or an object { providerID, modelID }.
+async function updateSession(server, sessionId, title, agent, model) {
   const bodyObj = {};
   if (title != null) bodyObj.title = title;
   if (agent != null) bodyObj.agent = agent;
+  if (model != null) {
+    bodyObj.model = typeof model === 'string'
+      ? model
+      : { providerID: model.providerID, id: model.modelID || model.id };
+  }
   const url = `${server}/session/${encodeURIComponent(sessionId)}`;
   const body = JSON.stringify(bodyObj);
   const { status, body: responseBody } = await makeRequest(buildJsonRequest(url, 'PATCH', body), body);
@@ -297,10 +303,13 @@ async function listProviders(server) {
 }
 
 // Send a message asynchronously (non-blocking). Returns 204 No Content.
-async function sendToSessionAsync(server, sessionId, text, agent) {
+// Optionally specify a model and/or noReply (injects context without AI response).
+async function sendToSessionAsync(server, sessionId, text, agent, model, noReply) {
   const url = `${server}/session/${encodeURIComponent(sessionId)}/prompt_async`;
   const bodyObj = { parts: [{ type: 'text', text }] };
   if (agent) bodyObj.agent = agent;
+  if (model) bodyObj.model = typeof model === 'string' ? model : { providerID: model.providerID, modelID: model.modelID };
+  if (noReply) bodyObj.noReply = true;
   const body = JSON.stringify(bodyObj);
   const { status } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
   if (status !== 204) throw new Error(`Failed to send async message: ${status}`);

package/package.json

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