open-agents-ai 0.187.583 → 0.187.585

package/README.md

@@ -3365,7 +3365,7 @@ All settings commands accept `--local` to save to project `.oa/settings.json` in
 
 `/platforms menu` opens a keyboard-driven connectivity surface for platform status and onboarding. The same surface is available through `/gateway menu`.
 
-Supported adapter IDs are `telegram`, `discord`, `slack`, `matrix`, and `webhook`. Telegram is wired into the existing bridge controls, so the menu can save the bot token, save the admin user ID, start the bridge, stop it, and show status. The other platform adapters expose the shared connector configuration surface: enable/disable, token environment variable, base URL or webhook URL, default target/channel/room, polling vs webhook mode, redacted config display, and status/health reporting.
+Supported adapter IDs are `telegram`, `discord`, `slack`, `matrix`, and `webhook`. Telegram is wired into the existing bridge controls, so the menu can save the bot token, save the admin user ID, set the interaction mode, start the bridge, stop it, and show status. The other platform adapters expose the shared connector configuration surface: enable/disable, token environment variable, base URL or webhook URL, default target/channel/room, polling vs webhook mode, redacted config display, and status/health reporting.
 
 Use environment variables for credentials:
 
@@ -3416,7 +3416,7 @@ The steering sub-agent uses the same model and backend as the main agent with `m
 
 <div align="right"><a href="#top">back to top</a></div>
 
-Connect the agent to a Telegram bot. Each incoming message spawns a dedicated sub-agent that handles the conversation independently — visible in the terminal waterfall alongside other agent activity.
+Connect the agent to a Telegram bot. Telegram can run in auto, chat, or action mode: conversational messages get rapid streamed replies in chat mode, while codebase/file/run requests use dedicated action sub-agents that are visible in the terminal waterfall alongside other agent activity.
 
 ```bash
 /telegram --key <token>     # Save bot token (persisted to .oa/settings.json)
@@ -3424,6 +3424,7 @@ Connect the agent to a Telegram bot. Each incoming message spawns a dedicated su
 /telegram                   # Toggle bridge on/off (uses saved key)
 /telegram status            # Show connection status + active sub-agents
 /telegram stop              # Disconnect and kill all sub-agents
+/telegram mode auto|chat|action # Set interaction routing profile
 /telegram auth              # Show a one-time TUI-only admin auth code
 /telegram auth cancel       # Cancel the pending admin auth code
 /telegram bot <username> <text>              # Send bot-to-bot message by @username
@@ -3438,7 +3439,17 @@ Connect the agent to a Telegram bot. Each incoming message spawns a dedicated su
 /telegram delete-reactions <chat> --user <id>      # Delete recent reactions
 ```
 
-The bot token and admin ID are persisted to project settings, so you only need to set them once. After that, bare `/telegram` toggles the bridge on and off like a service watchdog.
+The bot token, admin ID, and interaction mode are persisted to settings, so you only need to set them once. After that, bare `/telegram` toggles the bridge on and off like a service watchdog.
+
+### Telegram Interaction Modes
+
+Use `/telegram mode auto|chat|action` to control how inbound Telegram messages are routed:
+
+- **auto** — short greetings, quick questions, playful messages, and conversational turns use fast streamed chat replies; explicit codebase/file/command/run/test requests use action sub-agents.
+- **chat** — every non-command message gets a direct quick-chat completion with no tool loop. This is best for rapid back-and-forth conversation.
+- **action** — every non-command message runs through the Telegram sub-agent path with the configured tool policy.
+
+Telegram quick-chat views and action sub-agent views both appear as blue plane-labeled items in the systems header. Clicking one swaps the main scrollable window to that Telegram-only content buffer; press Esc to return to the primary view.
 
 ### Telegram Admin Authentication
 
@@ -3462,7 +3473,7 @@ The Telegram bridge handles modern Bot API traffic directly:
 - **Direct-message channels** — direct-message channel/topic metadata is preserved on normalized Telegram messages for routing and future adapter logic.
 - **Drafts and profile chat reads** — `/telegram draft` can set or clear message drafts, and `/telegram personal <user_id> <limit>` fetches recent messages from a user's profile personal chat.
 - **Reactions/admin helpers** — `/telegram delete-reaction` removes a message reaction, `/telegram delete-reactions` removes recent reactions by a user/chat, and `/telegram admins <chat> [--bots]` can include bot administrators.
-- **TUI sub-agent visibility** — Telegram conversations register as blue plane-labeled sub-agent views in the systems panel and show an active plane indicator in the footer while the bridge or Telegram sub-agents are active.
+- **TUI Telegram visibility** — Telegram quick-chat and action conversations register as blue plane-labeled views in the systems panel; clicking a view swaps the main scrollable window to that Telegram-only buffer, and the footer shows an active plane indicator while the bridge or Telegram work is active.
 
 ### Admin Slash Command Passthrough
 

package/dist/index.js

@@ -528118,6 +528118,7 @@ var init_agenticRunner = __esm({
           compactionThreshold: options2?.compactionThreshold ?? 4e4,
           deepContext: options2?.deepContext ?? false,
           dynamicContext: options2?.dynamicContext ?? "",
+          sessionId: options2?.sessionId ?? "",
           streamEnabled: options2?.streamEnabled ?? false,
           thinking: options2?.thinking ?? true,
           bruteForce: options2?.bruteForce ?? true,
@@ -528792,7 +528793,7 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
       }
       readSessionTodos() {
         try {
-          const sid = process.env["OA_SESSION_ID"] || this._sessionId || "default";
+          const sid = this._sessionId || process.env["OA_SESSION_ID"] || "default";
           const safe = sid.replace(/[^a-zA-Z0-9_.-]/g, "_");
           const fp = _pathJoin(_osHomedir(), ".open-agents", "todos", `${safe}.json`);
           if (!_fsExistsSync(fp))
@@ -530787,7 +530788,7 @@ Respond with your assessment, then take action.`;
         }
         this._fileRegistry.clear();
         this._memexArchive.clear();
-        this._sessionId = process.env["OA_SESSION_ID"] && String(process.env["OA_SESSION_ID"]) || `session-${Date.now()}`;
+        this._sessionId = this.options.sessionId && String(this.options.sessionId) || process.env["OA_SESSION_ID"] && String(process.env["OA_SESSION_ID"]) || `session-${Date.now()}`;
         this._appState = createAppState({
           sessionId: this._sessionId,
           model: this.backend.model ?? "",
@@ -530935,7 +530936,7 @@ TASK: ${task}` : task;
               messages2.push({ role: "system", content: _directive });
               const _todos = buildDecompositionTodos(_decomp.modules);
               try {
-                const sid = process.env["OA_SESSION_ID"] || this._sessionId || "default";
+                const sid = this._sessionId || process.env["OA_SESSION_ID"] || "default";
                 const safe = sid.replace(/[^a-zA-Z0-9_.-]/g, "_");
                 const fp = _pathJoin(_osHomedir(), ".open-agents", "todos", `${safe}.json`);
                 const dir = _pathJoin(_osHomedir(), ".open-agents", "todos");
@@ -536441,7 +536442,7 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
        */
       formatCompletedTodoAnchors() {
         try {
-          const sessionId = process.env["OA_SESSION_ID"] || this._sessionId;
+          const sessionId = this._sessionId || process.env["OA_SESSION_ID"] || "default";
           const todos = readTodos(sessionId);
           if (todos.length === 0)
             return "";
@@ -549063,6 +549064,7 @@ var init_command_registry = __esm({
       ["/telegram", "Toggle Telegram bridge on/off (uses saved key)"],
       ["/telegram status", "Show Telegram bridge status"],
       ["/telegram stop", "Disconnect Telegram bridge"],
+      ["/telegram mode auto|chat|action", "Set Telegram interaction routing: auto, fast chat, or action sub-agent"],
       ["/telegram auth", "Show a TUI-only one-time code for Telegram admin authentication"],
       ["/telegram auth cancel", "Cancel the pending Telegram admin authentication code"],
       ["/telegram bot <username> <text>", "Send a Bot API bot-to-bot message by @username"],
@@ -558482,6 +558484,8 @@ var init_status_bar = __esm({
           zones.push({ w: 2, render: () => "" });
           const voiceLabel = this._voiceActive ? ` ${this._voiceModelId || "voice"} ` : " voice ";
           zones.push({ w: voiceLabel.length + 2, render: () => "" });
+          const telegramLabel = this._telegramStatus.activeSubAgents > 0 ? ` ✈ tg ${this._telegramStatus.activeSubAgents} ` : " ✈ tg ";
+          zones.push({ w: telegramLabel.length + 2, render: () => "" });
           zones.push({ w: 9, render: () => "" });
           let pages = [];
           let cur = [];
@@ -559608,7 +559612,7 @@ var init_status_bar = __esm({
        *  If currently on the "systems" panel, re-render to show updated agent list. */
       renderAgentTabs() {
         if (!this.active) return;
-        if (this.currentHeaderPanel === "systems") {
+        if (String(this.currentHeaderPanel).startsWith("sys-")) {
           this.refreshHeaderContent();
         }
       }
@@ -579313,6 +579317,7 @@ sleep 1
     case "telegram":
     case "tg": {
       const parts = arg ? arg.split(/\s+/) : [];
+      const isLocal = hasLocal;
       if (parts[0] === "stop" || parts[0] === "off") {
         if (ctx3.isTelegramActive?.()) {
           ctx3.telegramStop?.();
@@ -579325,6 +579330,23 @@ sleep 1
         ctx3.telegramStatus?.();
         return "handled";
       }
+      if (parts[0] === "mode" || parts[0] === "profile") {
+        const requested = parts.slice(1).find((part) => !part.startsWith("--"));
+        if (!requested) {
+          const current = ctx3.getTelegramSettings?.()?.mode ?? "auto";
+          renderInfo(`Telegram interaction mode: ${c3.bold(current)}`);
+          renderInfo("Modes: auto (chat vs action), chat (fast replies), action (sub-agent tool loop).");
+          return "handled";
+        }
+        if (requested !== "auto" && requested !== "chat" && requested !== "action") {
+          renderWarning("Usage: /telegram mode auto|chat|action [--local]");
+          return "handled";
+        }
+        ctx3.saveTelegramSettings?.({ mode: requested, local: isLocal });
+        ctx3.telegramSetInteractionMode?.(requested);
+        renderInfo(`Telegram interaction mode set to ${c3.bold(requested)}${isLocal ? " (project)" : " (global)"}.`);
+        return "handled";
+      }
       if (parts[0] === "auth" || parts[0] === "authenticate") {
         if (parts[1] === "cancel") {
           const cancelled = ctx3.telegramCancelAdminAuth?.() ?? false;
@@ -579500,7 +579522,6 @@ sleep 1
         }
         return "handled";
       }
-      const isLocal = parts.includes("--local");
       const keyIdx = parts.indexOf("--key");
       const adminIdx = parts.indexOf("--admin");
       if (keyIdx !== -1 || adminIdx !== -1) {
@@ -579570,6 +579591,7 @@ sleep 1
       renderInfo("  /telegram                 Toggle on/off");
       renderInfo("  /telegram stop            Stop bridge");
       renderInfo("  /telegram status          Show status");
+      renderInfo("  /telegram mode auto|chat|action  Set interaction routing profile");
       renderInfo("  /telegram auth            Show one-time admin auth code");
       renderInfo("  /telegram auth cancel     Cancel pending admin auth code");
       renderInfo("  /telegram bot <username> <text>  Send bot-to-bot message");
@@ -580072,6 +580094,15 @@ async function showConfigEditor(ctx3) {
       value: String(merged.telegramAdmin ?? "[not set]"),
       detail: String(merged.telegramAdmin ?? "[not set]")
     },
+    {
+      key: "telegramMode",
+      label: "telegramMode",
+      kind: "enum",
+      value: String(merged.telegramMode ?? "auto"),
+      detail: String(merged.telegramMode ?? "auto"),
+      options: ["auto", "chat", "action"],
+      settingsKey: "telegramMode"
+    },
     // -- Actions --
     {
       key: "__h_actions__",
@@ -580337,6 +580368,7 @@ async function showPlatformOnboardingMenu(ctx3, id) {
     { key: "telegram-status", label: "Status", detail: "Show bridge status" },
     { key: "telegram-token", label: "Set bot token", detail: "Saved to existing Telegram settings" },
     { key: "telegram-admin", label: "Set admin user id", detail: "Restricts remote admin controls" },
+    { key: "telegram-mode", label: "Interaction mode", detail: ctx3.getTelegramSettings?.()?.mode ?? "auto" },
     { key: "telegram-start", label: "Start bridge", detail: "Uses saved token" },
     { key: "telegram-stop", label: "Stop bridge", detail: "Disconnect long polling" }
   ] : [
@@ -580415,7 +580447,13 @@ async function showPlatformOnboardingMenu(ctx3, id) {
   if (!result.confirmed || !result.key) return;
   if (id === "telegram") {
     if (result.key === "telegram-status") ctx3.telegramStatus?.();
-    else if (result.key === "telegram-start") {
+    else if (result.key === "telegram-mode") {
+      const current2 = ctx3.getTelegramSettings?.()?.mode ?? "auto";
+      const next = current2 === "auto" ? "chat" : current2 === "chat" ? "action" : "auto";
+      ctx3.saveTelegramSettings?.({ mode: next });
+      ctx3.telegramSetInteractionMode?.(next);
+      renderInfo(`Telegram interaction mode set to ${next}.`);
+    } else if (result.key === "telegram-start") {
       const settings = ctx3.getTelegramSettings?.() ?? {};
       if (!settings.key) renderWarning("No Telegram bot token configured.");
       else await ctx3.telegramStart?.(settings.key, settings.admin);
@@ -590782,7 +590820,7 @@ function getDefaultPolicy(context2) {
     case "terminal":
       return { blocked: /* @__PURE__ */ new Set(), allowed: /* @__PURE__ */ new Set() };
     case "telegram-admin-dm":
-      return { blocked: /* @__PURE__ */ new Set(["shell"]), allowed: /* @__PURE__ */ new Set() };
+      return { blocked: /* @__PURE__ */ new Set(), allowed: /* @__PURE__ */ new Set() };
     case "telegram-admin-group":
       return { blocked: /* @__PURE__ */ new Set(), allowed: SAFE_GROUP_ADMIN_TOOLS };
     case "telegram-public":
@@ -590829,6 +590867,8 @@ var init_tool_policy = __esm({
       "memory_read",
       "memory_write",
       "memory_search",
+      "todo_read",
+      "todo_write",
       "web_search",
       "web_fetch",
       "task_complete"
@@ -590837,6 +590877,8 @@ var init_tool_policy = __esm({
       "memory_read",
       "memory_write",
       "memory_search",
+      "todo_read",
+      "todo_write",
       "web_search",
       "web_fetch",
       "web_crawl",
@@ -590857,6 +590899,28 @@ import { mkdirSync as mkdirSync58, existsSync as existsSync100, unlinkSync as un
 import { join as join117, resolve as resolve35, basename as basename21 } from "node:path";
 import { writeFile as writeFileAsync } from "node:fs/promises";
 import { createHash as createHash18, randomInt } from "node:crypto";
+function classifyTelegramInteraction(text, mode = "auto", options2 = {}) {
+  if (mode === "chat") return "chat";
+  if (mode === "action") return "action";
+  const trimmed = text.trim();
+  if (!trimmed) return "chat";
+  if (options2.isSlashCommand || trimmed.startsWith("/")) return "action";
+  if (options2.hasMedia) return "action";
+  const hasAction = TELEGRAM_ACTION_INTENT_RE.test(trimmed);
+  const hasCodebaseContext = TELEGRAM_CODEBASE_CONTEXT_RE.test(trimmed) || TELEGRAM_COMMANDISH_RE.test(trimmed) || /[`'"]?[\w./-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|py|rs|go|java|css|scss|html|yml|yaml|toml|sh|sql)[`'"]?/i.test(trimmed);
+  if (hasAction && hasCodebaseContext) return "action";
+  if (/^(please\s+|pls\s+|can you\s+|could you\s+|we need to\s+|i need you to\s+)?(fix|implement|patch|edit|refactor|run|test|build|install|debug|commit|deploy|publish)\b/i.test(trimmed)) {
+    return "action";
+  }
+  if (TELEGRAM_COMMANDISH_RE.test(trimmed)) return "action";
+  if (trimmed.includes("```") && hasAction) return "action";
+  if (trimmed.length > 360 && hasAction) return "action";
+  if (/\b(write|draft)\b.*\b(poem|story|joke|email|message|caption|song|haiku)\b/i.test(trimmed)) return "chat";
+  if (TELEGRAM_CHAT_INTENT_RE.test(trimmed)) return "chat";
+  if (/[?？]\s*$/.test(trimmed) && !hasAction) return "chat";
+  if (trimmed.length <= 180 && !hasCodebaseContext && !hasAction) return "chat";
+  return hasAction ? "action" : "chat";
+}
 function convertMarkdownToTelegramHTML(md) {
   let html = md;
   html = html.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -590886,6 +590950,60 @@ function sanitizeTelegramProgressText(text, maxLength) {
   const compact = stripTelegramHiddenThinking(text).replace(/\s+/g, " ").trim();
   return compact.length > maxLength ? compact.slice(0, Math.max(0, maxLength - 3)) + "..." : compact;
 }
+function truncateTelegramContext(text, maxLength) {
+  const trimmed = text.trim();
+  if (trimmed.length <= maxLength) return trimmed;
+  return `${trimmed.slice(0, Math.max(0, maxLength - 80)).trimEnd()}
+
+[Telegram context truncated; use tools for full detail.]`;
+}
+function buildTelegramRuntimeContext(now = /* @__PURE__ */ new Date(), repoRoot) {
+  const date = new Intl.DateTimeFormat("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  }).format(now);
+  const time = new Intl.DateTimeFormat("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+    second: "2-digit",
+    timeZoneName: "short"
+  }).format(now);
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || process.env["TZ"] || "system";
+  return [
+    `Current date: ${date}`,
+    `Current time: ${time}`,
+    `Current ISO timestamp: ${now.toISOString()}`,
+    `Timezone: ${timezone}`,
+    repoRoot ? `Working directory: ${repoRoot}` : ""
+  ].filter(Boolean).join("\n");
+}
+function telegramSessionIdFromKey(sessionKey) {
+  return `telegram-${createHash18("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
+}
+function formatTelegramConversationHistory(history, maxEntries = 12) {
+  const recent = history.filter((entry) => entry.text.trim()).slice(-maxEntries);
+  if (recent.length === 0) return "";
+  return recent.map((entry) => {
+    const who = entry.role === "assistant" ? "Assistant" : "Telegram user";
+    const mode = entry.mode ? `/${entry.mode}` : "";
+    return `${who}${mode}: ${entry.text.trim()}`;
+  }).join("\n");
+}
+function selectTelegramFinalResponse(args) {
+  const candidates = [
+    args.assistantText,
+    args.streamText,
+    args.accumulated,
+    args.summary
+  ];
+  for (const candidate of candidates) {
+    const cleaned = stripTelegramHiddenThinking(candidate || "").trim();
+    if (cleaned) return cleaned;
+  }
+  return "";
+}
 function formatTelegramProgressEvent(event) {
   if (event.type === "tool_call" && event.toolName === "task_complete") return null;
   if (event.type === "tool_result" && event.toolName === "task_complete") return null;
@@ -591126,14 +591244,24 @@ function normalizeTelegramUpdate(update2) {
     sourceUpdateType
   };
 }
-function adaptTool5(tool) {
+function adaptTool5(tool, todoSessionId) {
   return {
     name: tool.name,
     description: tool.description,
     parameters: tool.parameters,
     async execute(args) {
-      const result = await tool.execute(args);
-      return { success: result.success, output: result.output, error: result.error };
+      const previousTodoSession = todoSessionId ? getTodoSessionId() : "";
+      if (todoSessionId && (tool.name === "todo_write" || tool.name === "todo_read")) {
+        setTodoSessionId(todoSessionId);
+      }
+      try {
+        const result = await tool.execute(args);
+        return { success: result.success, output: result.output, error: result.error };
+      } finally {
+        if (todoSessionId && (tool.name === "todo_write" || tool.name === "todo_read")) {
+          setTodoSessionId(previousTodoSession);
+        }
+      }
     }
   };
 }
@@ -591160,11 +591288,13 @@ function mimeForPath(path11, fallbackKind) {
   if (fallbackKind === "video") return "video/mp4";
   return "application/octet-stream";
 }
-function renderTelegramStart(botUsername, adminId) {
+function renderTelegramStart(botUsername, adminId, mode = "auto") {
   process.stdout.write(`
   ${c3.cyan("✈")} ${c3.bold("Telegram Bridge")} connected as @${botUsername}
 `);
-  process.stdout.write(`    ${c3.dim("Sub-agent mode: each message spawns a dedicated agent")}
+  process.stdout.write(`    ${c3.dim(`Interaction mode: ${mode}`)}
+`);
+  process.stdout.write(`    ${c3.dim("Auto mode uses quick chat for conversational turns and sub-agents for action requests")}
 `);
   if (adminId) {
     process.stdout.write(`    ${c3.dim(`Admin: ${adminId} (full memory + tools)`)}
@@ -591178,17 +591308,19 @@ function renderTelegramStart(botUsername, adminId) {
 
 `);
 }
-function renderTelegramStatus(active, botUsername, adminId, activeSubAgents) {
+function renderTelegramStatus(active, botUsername, adminId, activeSubAgents, mode = "auto") {
   if (active) {
     process.stdout.write(`
   ${c3.green("●")} Telegram bridge: ${c3.bold("ACTIVE")} (@${botUsername ?? "?"})
+`);
+    process.stdout.write(`    Mode: ${mode}
 `);
     if (adminId) {
       process.stdout.write(`    Admin: ${adminId}
 `);
     }
     if (activeSubAgents && activeSubAgents > 0) {
-      process.stdout.write(`    Active sub-agents: ${activeSubAgents}
+      process.stdout.write(`    Active Telegram work: ${activeSubAgents}
 `);
     }
     process.stdout.write(`    ${c3.dim("Use /telegram to toggle off")}
@@ -591246,7 +591378,7 @@ function renderTelegramSubAgentError(username, error) {
   process.stdout.write(`    ${c3.dim("⎿")} ${c3.red("✘")} @${username}: ${c3.dim(preview)}
 `);
 }
-var TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, GROUP_REPLY_DISCRETION_PROMPT, MEDIA_CACHE_TTL_MS, TelegramBridge;
+var TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_ACTION_INTENT_RE, TELEGRAM_CODEBASE_CONTEXT_RE, TELEGRAM_COMMANDISH_RE, TELEGRAM_CHAT_INTENT_RE, MEDIA_CACHE_TTL_MS, TelegramBridge;
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
@@ -591306,6 +591438,37 @@ REPLY DISCRETION: You are in a group chat. Only respond if:
 If the message is casual group chatter not directed at you, use task_complete
 with summary "no_reply" to silently skip without responding.
 `.trim();
+    TELEGRAM_CHAT_MODE_PROMPT = `
+You are Open Agents replying in Telegram quick-chat mode.
+
+Rules:
+1. Reply directly to the Telegram user, conversationally and concisely.
+2. For public/group users, do not inspect, summarize, or expose local files, paths, secrets, tool output, or runtime internals.
+3. For admin private DMs, quick-chat is a response style, not a capability downgrade: use the provided context and tools when needed.
+4. For ordinary chat, status questions, greetings, quick explanations, and playful messages, answer immediately without tool-use narration.
+5. For date/time questions, use the authoritative runtime context in this request. Do not infer dates from prior messages.
+`.trim();
+    ADMIN_CHAT_PROFILE_PROMPT = `
+You are replying to the authenticated Telegram admin in a private DM.
+Quick-chat is a conversational response profile, not a restricted mode.
+
+Capabilities:
+1. You have the same admin-grade context and tools as an action run.
+2. Use tools when they are required to answer accurately. Do not claim you lack logs, history, workspace access, or tooling if the context/tools provide a way to inspect them.
+3. If the message is a substantial codebase task, delegate focused work with full_sub_agent or another available agent tool, then report the spawned agent/status or result.
+4. If the message is a simple conversational question, answer directly from context without unnecessary tool use.
+5. The final Telegram message must be the answer to send to the admin, not a meta-summary such as "answered the question".
+`.trim();
+    TELEGRAM_ACTION_RESPONSE_CONTRACT = `
+Telegram response contract:
+- The final task_complete summary is the exact message that will be sent to Telegram.
+- Do not summarize the fact that you answered; send the answer itself.
+- If you delegated long-running work, include the sub-agent id/status and what the admin should expect next.
+`.trim();
+    TELEGRAM_ACTION_INTENT_RE = /\b(implement|fix|patch|edit|write|create|delete|remove|refactor|run|execute|test|build|install|debug|investigate|diagnose|validate|commit|push|pull|merge|rebase|deploy|publish|read|open|inspect|grep|search|find|list|apply|change|update)\b/i;
+    TELEGRAM_CODEBASE_CONTEXT_RE = /\b(repo|repository|codebase|workspace|working directory|file|files|folder|directory|src|source|test|tests|package|pnpm|npm|node|git|branch|commit|pr|pull request|issue|shell|terminal|cli|command|function|class|component|endpoint|api)\b/i;
+    TELEGRAM_COMMANDISH_RE = /(^|\s)(pnpm|npm|node|git|rg|grep|sed|cat|ls|cd|mkdir|rm|mv|cp|curl|docker|pytest|vitest|tsc)\b/i;
+    TELEGRAM_CHAT_INTENT_RE = /\b(hi|hello|hey|thanks|thank you|lol|haha|joke|how are you|what's up|whats up|can you hear|are you there|explain|what is|what are|why|how does|tell me|opinion|quick question)\b/i;
     MEDIA_CACHE_TTL_MS = 30 * 60 * 1e3;
     TelegramBridge = class {
       constructor(botToken, onMessage, agentConfig, repoRoot, toolPolicyConfig) {
@@ -591327,6 +591490,7 @@ with summary "no_reply" to silently skip without responding.
         active: false,
         botUsername: "",
         supportsGuestQueries: false,
+        interactionMode: "auto",
         startedAt: "",
         messagesReceived: 0,
         messagesSent: 0,
@@ -591336,6 +591500,12 @@ with summary "no_reply" to silently skip without responding.
       adminUserId = null;
       /** Active sub-agents by chat/guest session key */
       subAgents = /* @__PURE__ */ new Map();
+      /** Active direct chat completions, counted with Telegram activity in the TUI */
+      activeChatViews = /* @__PURE__ */ new Set();
+      /** Lightweight chat history by chat/guest session key */
+      chatHistory = /* @__PURE__ */ new Map();
+      /** Telegram interaction routing profile */
+      interactionMode = "auto";
       /** Event handler for forwarding sub-agent events to parent TUI */
       onSubAgentEvent = null;
       /** Tool policy config — user overrides from config */
@@ -591375,6 +591545,13 @@ with summary "no_reply" to silently skip without responding.
       setAdmin(userId) {
         this.adminUserId = userId;
       }
+      setInteractionMode(mode) {
+        this.interactionMode = mode;
+        this.state.interactionMode = mode;
+      }
+      getInteractionMode() {
+        return this.interactionMode;
+      }
       /** Update tool policy config at runtime (e.g., from /disable command) */
       setToolPolicyConfig(config) {
         this.toolPolicyConfig = config;
@@ -591418,7 +591595,7 @@ with summary "no_reply" to silently skip without responding.
         return this.polling;
       }
       get stats() {
-        return { ...this.state, activeSubAgents: this.subAgents.size };
+        return { ...this.state, activeSubAgents: this.activeTelegramInteractionCount() };
       }
       get botUsername() {
         return this.state.botUsername;
@@ -591476,9 +591653,110 @@ with summary "no_reply" to silently skip without responding.
         if (msg.guestQueryId) return `guest:${msg.guestQueryId}`;
         return `chat:${String(msg.chatId)}`;
       }
+      activeTelegramInteractionCount() {
+        return this.subAgents.size + this.activeChatViews.size;
+      }
+      refreshActiveTelegramInteractionCount() {
+        this.state.activeSubAgents = this.activeTelegramInteractionCount();
+      }
       canUseChatActions(msg) {
         return !msg.guestQueryId && (typeof msg.chatId === "number" || String(msg.chatId).startsWith("@"));
       }
+      recordChatHistory(sessionKey, entry) {
+        const existing = this.chatHistory.get(sessionKey) ?? [];
+        existing.push({ ...entry, ts: entry.ts ?? Date.now() });
+        if (existing.length > 16) existing.splice(0, existing.length - 16);
+        this.chatHistory.set(sessionKey, existing);
+      }
+      buildTelegramWorkspaceContext(modelTier, budget = 14e3) {
+        if (!this.repoRoot) return "";
+        try {
+          const ctx3 = buildProjectContext(this.repoRoot);
+          return truncateTelegramContext(formatContextForPrompt(ctx3, modelTier), budget);
+        } catch (err) {
+          const reason = err instanceof Error ? err.message : String(err);
+          return `Workspace context unavailable: ${reason}`;
+        }
+      }
+      buildPrimaryTuiSessionContext(telegramSessionId) {
+        const primarySessionId = process.env["OA_SESSION_ID"] || process.env["OA_TUI_SESSION_ID"] || "";
+        if (!primarySessionId || primarySessionId === telegramSessionId) return "";
+        try {
+          const todos = readTodos(primarySessionId);
+          if (todos.length === 0) {
+            return `Primary TUI session id: ${primarySessionId}
+No active checklist items are recorded for that session.`;
+          }
+          const lines = todos.slice(0, 18).map((todo) => {
+            const blocker = todo.blocker ? ` - blocked: ${todo.blocker}` : "";
+            return `- [${todo.status}] ${todo.content}${blocker}`;
+          });
+          const suffix = todos.length > lines.length ? `
+... ${todos.length - lines.length} more item(s)` : "";
+          return `Primary TUI session id: ${primarySessionId}
+Current checklist:
+${lines.join("\n")}${suffix}`;
+        } catch (err) {
+          const reason = err instanceof Error ? err.message : String(err);
+          return `Primary TUI session id: ${primarySessionId}
+Checklist unavailable: ${reason}`;
+        }
+      }
+      buildTelegramSessionContext(msg, toolContext, profile, modelTier) {
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const sessionId = telegramSessionIdFromKey(sessionKey);
+        const isAdminDM = toolContext === "telegram-admin-dm";
+        const isAdminGroup = toolContext === "telegram-admin-group";
+        const history = formatTelegramConversationHistory(this.chatHistory.get(sessionKey) ?? [], isAdminDM ? 14 : 8);
+        const chatLabel = msg.chatType !== "private" ? `Telegram group: ${msg.chatTitle || "unknown"}` : "Telegram private chat";
+        const sections = [
+          `## Telegram Runtime Context
+
+${buildTelegramRuntimeContext(/* @__PURE__ */ new Date(), isAdminDM ? this.repoRoot : void 0)}`,
+          `## Telegram Session
+
+Session key: ${sessionKey}
+Todo/session id: ${sessionId}
+Profile: ${profile}
+Tool context: ${toolContext}
+${chatLabel}`,
+          TELEGRAM_ACTION_RESPONSE_CONTRACT
+        ];
+        if (history) {
+          sections.push(`## Recent Telegram Conversation
+
+${history}`);
+        }
+        if (isAdminDM) {
+          sections.push(`## Admin Capability Contract
+
+${ADMIN_CHAT_PROFILE_PROMPT}`);
+          const primarySessionContext = this.buildPrimaryTuiSessionContext(sessionId);
+          if (primarySessionContext) sections.push(`## Primary TUI Session State
+
+${primarySessionContext}`);
+          const workspaceContext = this.buildTelegramWorkspaceContext(modelTier, profile === "chat" ? 16e3 : 24e3);
+          if (workspaceContext) sections.push(`## Workspace Context
+
+${workspaceContext}`);
+        } else if (isAdminGroup) {
+          sections.push(`## Telegram Safety Contract
+
+${ADMIN_GROUP_PROMPT}`);
+        } else {
+          sections.push(`## Telegram Safety Contract
+
+${TELEGRAM_SAFETY_PROMPT}`);
+        }
+        return { sessionKey, sessionId, context: sections.join("\n\n") };
+      }
+      shouldFastChatReplyInGroup(msg) {
+        if (msg.chatType === "private" || msg.guestQueryId) return true;
+        const lower = msg.text.toLowerCase();
+        const botMention = this.state.botUsername ? lower.includes(`@${this.state.botUsername.toLowerCase()}`) : false;
+        if (botMention || msg.replyToMessageId) return true;
+        return /[?？]/.test(msg.text) || /\b(help|question|how|what|why|when|where|can you|could you|explain)\b/i.test(msg.text);
+      }
       async handleAdminAuthCommand(msg) {
         const normalized = msg.text.trim();
         const lower = normalized.toLowerCase();
@@ -591542,6 +591820,7 @@ with summary "no_reply" to silently skip without responding.
           active: true,
           botUsername: me.result?.username ?? "unknown",
           supportsGuestQueries: Boolean(me.result?.supports_guest_queries),
+          interactionMode: this.interactionMode,
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           messagesReceived: 0,
           messagesSent: 0,
@@ -591571,6 +591850,8 @@ with summary "no_reply" to silently skip without responding.
           if (agent.typingInterval) clearInterval(agent.typingInterval);
         }
         this.subAgents.clear();
+        this.activeChatViews.clear();
+        this.refreshActiveTelegramInteractionCount();
       }
       // ── Typing indicator ──────────────────────────────────────────────────
       /** Start sending "typing" indicator every 4 seconds */
@@ -591752,6 +592033,7 @@ Join: ${newUrl}`);
         }
         const existing = this.subAgents.get(sessionKey);
         if (existing && !existing.aborted) {
+          this.recordChatHistory(sessionKey, { role: "user", text: msg.text, mode: "steering" });
           if (existing.runner) {
             existing.runner.injectUserMessage(msg.text);
             this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, "mid-conversation steering injected"));
@@ -591761,6 +592043,14 @@ Join: ${newUrl}`);
           }
           return;
         }
+        const route = classifyTelegramInteraction(msg.text, this.interactionMode, {
+          hasMedia: !!msg.media || !!msg.poll || !!msg.livePhoto,
+          isSlashCommand: msg.text.trim().startsWith("/")
+        });
+        if (route === "chat") {
+          await this.handleTelegramChatCompletion(msg, toolContext);
+          return;
+        }
         const subAgent = {
           chatId: msg.chatId,
           username: msg.username,
@@ -591769,6 +592059,8 @@ Join: ${newUrl}`);
           typingInterval: null,
           liveMessageId: null,
           accumulated: "",
+          assistantText: "",
+          streamText: "",
           intermediateLines: [],
           lastEditMs: 0,
           aborted: false,
@@ -591776,7 +592068,7 @@ Join: ${newUrl}`);
           pendingMessages: []
         };
         this.subAgents.set(sessionKey, subAgent);
-        this.state.activeSubAgents = this.subAgents.size;
+        this.refreshActiveTelegramInteractionCount();
         this.subAgentViewCallbacks?.onRegister(
           subAgent.viewId,
           `✈ @${msg.username || "telegram"}`,
@@ -591816,6 +592108,8 @@ Join: ${newUrl}`);
             return;
           }
           const finalText = stripTelegramHiddenThinking(result || "").trim() || "I couldn't generate a response. Please try again.";
+          this.recordChatHistory(sessionKey, { role: "user", text: msg.text, mode: "action" });
+          this.recordChatHistory(sessionKey, { role: "assistant", text: finalText, mode: "action" });
           const finalHtml = convertMarkdownToTelegramHTML(finalText);
           if (subAgent.liveMessageId && !msg.guestQueryId) {
             await this.editLiveMessage(msg.chatId, subAgent.liveMessageId, finalHtml);
@@ -591846,12 +592140,270 @@ Join: ${newUrl}`);
           }
         } finally {
           this.subAgents.delete(sessionKey);
-          this.state.activeSubAgents = this.subAgents.size;
+          this.refreshActiveTelegramInteractionCount();
+          this.subAgentViewCallbacks?.onComplete(subAgent.viewId);
+        }
+      }
+      /** Admin quick-chat: conversational profile with full admin context/tools. */
+      async handleTelegramAdminChatAgent(msg, toolContext) {
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const subAgent = {
+          chatId: msg.chatId,
+          username: msg.username,
+          viewId: `${this.viewIdForMessage(msg)}-chat`,
+          runner: null,
+          typingInterval: null,
+          liveMessageId: null,
+          accumulated: "",
+          assistantText: "",
+          streamText: "",
+          intermediateLines: ["💬 Contextual admin chat"],
+          lastEditMs: 0,
+          aborted: false,
+          toolContext,
+          pendingMessages: []
+        };
+        this.subAgents.set(sessionKey, subAgent);
+        this.refreshActiveTelegramInteractionCount();
+        this.subAgentViewCallbacks?.onRegister(
+          subAgent.viewId,
+          `✈ @${msg.username || "telegram"}`,
+          `Telegram admin chat: ${msg.text.slice(0, 160)}`
+        );
+        this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `✈ Telegram admin chat from @${msg.username}: ${msg.text}`);
+        this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `route: chat (${this.interactionMode}) with admin tools`);
+        this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "running");
+        if (this.canUseChatActions(msg)) {
+          subAgent.typingInterval = this.startTypingIndicator(msg.chatId);
+        }
+        this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, `admin chat with full context/tools (${this.interactionMode})`));
+        try {
+          if (!msg.guestQueryId) {
+            subAgent.liveMessageId = await this.sendLiveMessage(
+              msg.chatId,
+              renderTelegramLiveProgressHTML(subAgent.intermediateLines, ""),
+              msg.chatType !== "private" ? msg.messageId : void 0
+            );
+          }
+          let mediaContext = "";
+          if (msg.media) {
+            mediaContext = await this.processMedia(msg);
+          }
+          const result = await this.runSubAgent(msg, subAgent, mediaContext, "chat");
+          if (subAgent.typingInterval) {
+            clearInterval(subAgent.typingInterval);
+            subAgent.typingInterval = null;
+          }
+          const finalText = stripTelegramHiddenThinking(result || "").trim() || "I heard you.";
+          this.recordChatHistory(sessionKey, { role: "user", text: msg.text, mode: "chat" });
+          this.recordChatHistory(sessionKey, { role: "assistant", text: finalText, mode: "chat" });
+          const finalHtml = convertMarkdownToTelegramHTML(finalText);
+          if (subAgent.liveMessageId && !msg.guestQueryId) {
+            await this.editLiveMessage(msg.chatId, subAgent.liveMessageId, finalHtml);
+          } else {
+            await this.replyToTelegramMessage(msg, finalHtml, {
+              html: true,
+              replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
+            });
+          }
+          this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `completed: ${finalText}`);
+          this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "completed");
+        } catch (err) {
+          if (subAgent.typingInterval) {
+            clearInterval(subAgent.typingInterval);
+            subAgent.typingInterval = null;
+          }
+          const errMsg = err instanceof Error ? err.message : String(err);
+          this.tuiWrite(() => renderTelegramSubAgentError(msg.username, errMsg));
+          this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `error: ${errMsg}`);
+          this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "failed");
+          if (subAgent.liveMessageId && !msg.guestQueryId) {
+            await this.editLiveMessage(msg.chatId, subAgent.liveMessageId, `❌ Error: ${escapeTelegramHTML(errMsg)}`).catch(() => {
+            });
+          } else {
+            await this.replyToTelegramMessage(msg, "Sorry, I couldn't process that Telegram chat message.").catch(() => {
+            });
+          }
+        } finally {
+          this.subAgents.delete(sessionKey);
+          this.refreshActiveTelegramInteractionCount();
           this.subAgentViewCallbacks?.onComplete(subAgent.viewId);
         }
       }
+      /** Fast Telegram chat path: direct streamed completion, no tool loop. */
+      async handleTelegramChatCompletion(msg, toolContext) {
+        if (toolContext === "telegram-admin-dm") {
+          await this.handleTelegramAdminChatAgent(msg, toolContext);
+          return;
+        }
+        if (!this.shouldFastChatReplyInGroup(msg)) {
+          this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, "chat-mode discretion: skipped group chatter"));
+          return;
+        }
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const viewId = `${this.viewIdForMessage(msg)}-chat`;
+        let typingInterval = null;
+        let liveMessageId = null;
+        let accumulated = "";
+        let lastEditMs = 0;
+        let lastViewWriteMs = 0;
+        const progressLines = [`💬 Quick chat mode (${this.interactionMode})`];
+        this.activeChatViews.add(viewId);
+        this.refreshActiveTelegramInteractionCount();
+        this.subAgentViewCallbacks?.onRegister(
+          viewId,
+          `✈ @${msg.username || "telegram"}`,
+          `Telegram quick chat: ${msg.text.slice(0, 160)}`
+        );
+        this.subAgentViewCallbacks?.onWrite(viewId, `✈ Telegram quick chat from @${msg.username}: ${msg.text}`);
+        this.subAgentViewCallbacks?.onWrite(viewId, `route: chat (${this.interactionMode})`);
+        this.subAgentViewCallbacks?.onStatus(viewId, "running");
+        if (this.canUseChatActions(msg)) {
+          typingInterval = this.startTypingIndicator(msg.chatId);
+        }
+        this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, `chat-mode fast reply (${this.interactionMode})`));
+        try {
+          if (!msg.guestQueryId) {
+            liveMessageId = await this.sendLiveMessage(
+              msg.chatId,
+              renderTelegramLiveProgressHTML(progressLines, ""),
+              msg.chatType !== "private" ? msg.messageId : void 0
+            );
+          }
+          const mediaContext = msg.media || msg.livePhoto ? "Attachment received. Quick-chat mode does not inspect media; use action mode for media analysis." : "";
+          const finalText = await this.runTelegramChatCompletion(
+            msg,
+            toolContext,
+            mediaContext,
+            (nextText) => {
+              accumulated = nextText;
+              const now = Date.now();
+              if (now - lastViewWriteMs > 900) {
+                lastViewWriteMs = now;
+                this.subAgentViewCallbacks?.onWrite(viewId, `stream: ${sanitizeTelegramProgressText(nextText, 180)}`);
+              }
+              if (liveMessageId && !msg.guestQueryId && now - lastEditMs > 900) {
+                lastEditMs = now;
+                this.editLiveMessage(
+                  msg.chatId,
+                  liveMessageId,
+                  renderTelegramLiveProgressHTML(progressLines, accumulated)
+                ).catch(() => {
+                });
+              }
+            }
+          );
+          if (typingInterval) {
+            clearInterval(typingInterval);
+            typingInterval = null;
+          }
+          const cleaned = stripTelegramHiddenThinking(finalText || accumulated).trim() || "I heard you.";
+          this.recordChatHistory(sessionKey, { role: "user", text: msg.text, mode: "chat" });
+          this.recordChatHistory(sessionKey, { role: "assistant", text: cleaned, mode: "chat" });
+          const finalHtml = convertMarkdownToTelegramHTML(cleaned);
+          if (liveMessageId && !msg.guestQueryId) {
+            await this.editLiveMessage(msg.chatId, liveMessageId, finalHtml);
+          } else {
+            await this.replyToTelegramMessage(msg, finalHtml, {
+              html: true,
+              replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
+            });
+          }
+          this.subAgentViewCallbacks?.onWrite(viewId, `completed: ${cleaned}`);
+          this.subAgentViewCallbacks?.onStatus(viewId, "completed");
+        } catch (err) {
+          if (typingInterval) {
+            clearInterval(typingInterval);
+            typingInterval = null;
+          }
+          const errMsg = err instanceof Error ? err.message : String(err);
+          this.tuiWrite(() => renderTelegramSubAgentError(msg.username, errMsg));
+          this.subAgentViewCallbacks?.onWrite(viewId, `error: ${errMsg}`);
+          this.subAgentViewCallbacks?.onStatus(viewId, "failed");
+          if (liveMessageId && !msg.guestQueryId) {
+            await this.editLiveMessage(msg.chatId, liveMessageId, `❌ Error: ${escapeTelegramHTML(errMsg)}`).catch(() => {
+            });
+          } else {
+            await this.replyToTelegramMessage(msg, "Sorry, I couldn't process that quick chat message.").catch(() => {
+            });
+          }
+        } finally {
+          this.activeChatViews.delete(viewId);
+          this.refreshActiveTelegramInteractionCount();
+          this.subAgentViewCallbacks?.onComplete(viewId);
+        }
+      }
+      buildTelegramChatMessages(msg, toolContext, mediaContext = "") {
+        const isAdminDM = toolContext === "telegram-admin-dm";
+        const isAdminGroup = toolContext === "telegram-admin-group";
+        const isGroup = msg.chatType !== "private";
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const history = this.chatHistory.get(sessionKey) ?? [];
+        const safety = isAdminDM ? "Admin private DM. The user is trusted, but quick-chat mode still has no tool access." : isAdminGroup ? ADMIN_GROUP_PROMPT : TELEGRAM_SAFETY_PROMPT;
+        const groupHint = isGroup ? `Telegram group: ${msg.chatTitle || "unknown"}. Keep the reply short and relevant.` : "Telegram private chat.";
+        const runtime = buildTelegramRuntimeContext(/* @__PURE__ */ new Date());
+        const messages2 = [
+          {
+            role: "system",
+            content: `${TELEGRAM_CHAT_MODE_PROMPT}
+
+## Runtime Context
+
+${runtime}
+
+${safety}
+
+${groupHint}`
+          },
+          ...history.slice(-8).map((entry) => ({
+            role: entry.role,
+            content: entry.text
+          }))
+        ];
+        const chatLabel = isGroup ? ` in group "${msg.chatTitle || "unknown"}"` : "";
+        messages2.push({
+          role: "user",
+          content: `Telegram message from @${msg.username}${chatLabel}:
+${msg.text}${mediaContext ? `
+
+${mediaContext}` : ""}`
+        });
+        return messages2;
+      }
+      async runTelegramChatCompletion(msg, toolContext, mediaContext, onToken) {
+        const config = this.agentConfig;
+        const backend = new OllamaAgenticBackend(
+          config.backendUrl,
+          config.model,
+          config.apiKey
+        );
+        const request = {
+          messages: this.buildTelegramChatMessages(msg, toolContext, mediaContext),
+          tools: [],
+          temperature: 0.4,
+          maxTokens: 700,
+          timeoutMs: Math.min(config.timeoutMs ?? 3e4, 3e4),
+          think: false
+        };
+        let accumulated = "";
+        const streamable = backend;
+        if (typeof streamable.chatCompletionStream === "function") {
+          for await (const chunk of streamable.chatCompletionStream(request)) {
+            if (chunk.type === "content" && !chunk.thinking && chunk.content) {
+              accumulated += chunk.content;
+              onToken(accumulated);
+            }
+          }
+        }
+        if (!accumulated.trim()) {
+          const result = await backend.chatCompletion(request);
+          accumulated = result.choices[0]?.message?.content ?? "";
+          if (accumulated) onToken(accumulated);
+        }
+        return stripTelegramHiddenThinking(accumulated).trim();
+      }
       /** Run a sub-agent for a Telegram message */
-      async runSubAgent(msg, subAgent, mediaContext = "") {
+      async runSubAgent(msg, subAgent, mediaContext = "", profile = "action") {
         const config = this.agentConfig;
         const repoRoot = this.repoRoot;
         const modelTier = getModelTier(config.model);
@@ -591859,21 +592411,25 @@ Join: ${newUrl}`);
         const isAdminDM = ctx3 === "telegram-admin-dm";
         const isAdminGroup = ctx3 === "telegram-admin-group";
         const isGroup = msg.chatType !== "private";
+        const sessionContext = this.buildTelegramSessionContext(msg, ctx3, profile, modelTier);
         const backend = new OllamaAgenticBackend(
           config.backendUrl,
           config.model,
           config.apiKey
         );
         const runner = new AgenticRunner(backend, {
-          maxTurns: isAdminDM ? 30 : isAdminGroup ? 12 : 8,
-          maxTokens: isAdminDM ? 8192 : 2048,
+          maxTurns: isAdminDM ? profile === "chat" ? 16 : 30 : isAdminGroup ? 12 : 8,
+          maxTokens: isAdminDM ? profile === "chat" ? 6144 : 8192 : 2048,
           temperature: 0.3,
           requestTimeoutMs: config.timeoutMs,
           taskTimeoutMs: isAdminDM ? config.timeoutMs * 3 : config.timeoutMs,
           compactionThreshold: modelTier === "small" ? 8e3 : 16e3,
           modelTier,
-          streamEnabled: true
+          streamEnabled: true,
+          dynamicContext: sessionContext.context,
+          sessionId: sessionContext.sessionId
         });
+        runner.setWorkingDirectory(repoRoot);
         subAgent.runner = runner;
         if (subAgent.pendingMessages.length > 0) {
           for (const queued of subAgent.pendingMessages) {
@@ -591882,7 +592438,7 @@ Join: ${newUrl}`);
           this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, `replayed ${subAgent.pendingMessages.length} queued message(s)`));
           subAgent.pendingMessages.length = 0;
         }
-        const tools = this.buildSubAgentTools(ctx3, repoRoot, msg.chatId);
+        const tools = this.buildSubAgentTools(ctx3, repoRoot, msg.chatId, sessionContext.sessionId);
         runner.registerTools(tools);
         runner.onEvent((event) => {
           if (subAgent.aborted) return;
@@ -591895,6 +592451,10 @@ Join: ${newUrl}`);
             this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `${event.success ? "ok" : "fail"}: ${event.toolName}: ${preview}`);
           } else if (event.type === "status" && event.content) {
             this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `status: ${event.content}`);
+          } else if (event.type === "assistant_text" && event.content) {
+            subAgent.assistantText = event.content;
+          } else if (event.type === "stream_end" && event.content) {
+            subAgent.streamText = event.content;
           }
           if (subAgent.liveMessageId && !msg.guestQueryId) {
             if (event.type === "stream_token" && event.streamKind === "content" && event.content) {
@@ -591921,7 +592481,7 @@ Join: ${newUrl}`);
         });
         let systemPrompt;
         if (isAdminDM) {
-          systemPrompt = ADMIN_DM_PROMPT;
+          systemPrompt = profile === "chat" ? ADMIN_CHAT_PROFILE_PROMPT : ADMIN_DM_PROMPT;
         } else if (isAdminGroup) {
           systemPrompt = ADMIN_GROUP_PROMPT;
         } else {
@@ -591933,7 +592493,14 @@ ${GROUP_REPLY_DISCRETION_PROMPT}` : "";
         const chatLabel = isGroup ? ` in group "${msg.chatTitle || "unknown"}"` : "";
         let userPrompt;
         if (isAdminDM) {
-          userPrompt = `Telegram message from admin @${msg.username}:
+          const profileLine = profile === "chat" ? "Handle this as contextual Telegram chat: answer directly if simple, use tools/delegation if needed." : "Handle this as Telegram action work: complete the requested task or clearly report the blocker.";
+          userPrompt = `${systemPrompt}
+
+${TELEGRAM_ACTION_RESPONSE_CONTRACT}
+
+${profileLine}
+
+Telegram message from admin @${msg.username}:
 ${msg.text}`;
         } else {
           const toolHint = "You have access to isolated per-chat memory (memory_write, memory_read, memory_search) scoped to this conversation. You can remember facts about this user and retrieve them later. You also have web_search and web_fetch to look up information.";
@@ -591955,22 +592522,29 @@ Respond concisely and safely.`;
 ${mediaContext}`;
         }
         const systemCtx = isAdminDM ? `Working directory: ${repoRoot}
-Telegram admin: @${msg.username}` : `Telegram ${isGroup ? "group" : "public"} chat. Respond concisely. Safety filter: ACTIVE.`;
+Telegram admin: @${msg.username}
+Telegram profile: ${profile}
+Todo/session id: ${sessionContext.sessionId}` : `Telegram ${isGroup ? "group" : "public"} chat. Respond concisely. Safety filter: ACTIVE.`;
         const result = await runner.run(userPrompt, systemCtx);
-        return result.summary || subAgent.accumulated || "";
+        return selectTelegramFinalResponse({
+          assistantText: subAgent.assistantText,
+          streamText: subAgent.streamText,
+          accumulated: subAgent.accumulated,
+          summary: result.summary
+        });
       }
       /**
        * Build tool set based on tool context, filtered through the policy system.
        * All possible tools are instantiated, then applyToolPolicy filters them.
        */
-      buildSubAgentTools(context2, repoRoot, chatId) {
+      buildSubAgentTools(context2, repoRoot, chatId, todoSessionId) {
         const taskComplete = {
           name: "task_complete",
-          description: "Signal that your response is ready to send to the Telegram user. Use summary 'no_reply' to silently skip responding.",
+          description: "Signal that your response is ready to send to the Telegram user. The summary must be the exact final Telegram message, not a meta-summary. Use summary 'no_reply' to silently skip responding.",
           parameters: {
             type: "object",
             properties: {
-              summary: { type: "string", description: "The response to send to the Telegram user, or 'no_reply' to skip" }
+              summary: { type: "string", description: "Exact response to send to the Telegram user, or 'no_reply' to skip" }
             },
             required: ["summary"]
           },
@@ -591978,7 +592552,21 @@ Telegram admin: @${msg.username}` : `Telegram ${isGroup ? "group" : "public"} ch
             return { success: true, output: args["summary"] || "Done." };
           }
         };
-        const allTools = [
+        const fullSubAgentTool = new FullSubAgentTool(
+          repoRoot,
+          this.agentConfig?.model,
+          this.agentConfig?.backendUrl,
+          {
+            onViewRegister: (id, label) => this.subAgentViewCallbacks?.onRegister(id, `✈ ${label}`, "Telegram delegated full sub-agent"),
+            onViewWrite: (id, text) => this.subAgentViewCallbacks?.onWrite(id, text),
+            onViewStatus: (id, status) => {
+              if (status === "completed" || status === "failed" || status === "running") {
+                this.subAgentViewCallbacks?.onStatus(id, status);
+              }
+            }
+          }
+        );
+        const sharedReadMemoryWebTools = [
           // File tools
           new FileReadTool(repoRoot),
           new GrepSearchTool(repoRoot),
@@ -591988,6 +592576,8 @@ Telegram admin: @${msg.username}` : `Telegram ${isGroup ? "group" : "public"} ch
           new MemoryReadTool(repoRoot),
           new MemoryWriteTool(repoRoot),
           new MemorySearchTool(repoRoot),
+          new TodoReadTool(),
+          new TodoWriteTool(),
           // Web tools
           new WebFetchTool(),
           new WebSearchTool(),
@@ -592002,7 +592592,62 @@ Telegram admin: @${msg.username}` : `Telegram ${isGroup ? "group" : "public"} ch
           new TranscribeFileTool(repoRoot),
           new TranscribeUrlTool(repoRoot)
         ];
-        let adaptedTools = allTools.map(adaptTool5);
+        const adminTools = [
+          new ShellTool(repoRoot),
+          new FileReadTool(repoRoot),
+          new FileWriteTool(repoRoot),
+          new FileEditTool(repoRoot),
+          new FilePatchTool(repoRoot),
+          new BatchEditTool(repoRoot),
+          new GrepSearchTool(repoRoot),
+          new GlobFindTool(repoRoot),
+          new ListDirectoryTool(repoRoot),
+          new SessionSearchTool(repoRoot),
+          new ExploreToolsTool(),
+          new CodebaseMapTool(repoRoot),
+          new DiagnosticTool(repoRoot),
+          new GitInfoTool(repoRoot),
+          new PhaseRecallTool(repoRoot),
+          new LogExploreTool(repoRoot),
+          new FileExploreTool(repoRoot),
+          new WorkingNotesTool(),
+          new ProjectScaffoldingTool(),
+          new TodoReadTool(),
+          new TodoWriteTool(),
+          new MemoryReadTool(repoRoot),
+          new MemoryWriteTool(repoRoot),
+          new MemorySearchTool(repoRoot),
+          new WebFetchTool(),
+          new WebSearchTool(),
+          new WebCrawlTool(repoRoot),
+          new StructuredReadTool(repoRoot),
+          new StructuredFileTool(repoRoot),
+          new CodeSandboxTool(repoRoot),
+          new ImageReadTool(repoRoot),
+          new ScreenshotTool(repoRoot),
+          new OCRTool(repoRoot),
+          new OcrImageAdvancedTool(repoRoot),
+          new VisionTool(repoRoot),
+          new OcrPdfTool(repoRoot),
+          new PdfToTextTool(repoRoot),
+          new TranscribeFileTool(repoRoot),
+          new TranscribeUrlTool(repoRoot),
+          new YouTubeDownloadTool(repoRoot),
+          new BrowserActionTool(),
+          new CarbonylBrowserTool(),
+          new PlaywrightBrowserTool(),
+          new ImageGenerateTool(repoRoot, this.agentConfig?.backendUrl),
+          new NotebookEditTool(),
+          new RepoMapTool(repoRoot),
+          new ImportGraphTool(repoRoot),
+          new SymbolSearchTool(repoRoot),
+          new ImpactAnalysisTool(repoRoot),
+          new CodeNeighborsTool(repoRoot),
+          new ProcessHealthTool(),
+          fullSubAgentTool
+        ];
+        const allTools = context2 === "telegram-admin-dm" ? adminTools : sharedReadMemoryWebTools;
+        let adaptedTools = allTools.map((tool) => adaptTool5(tool, todoSessionId));
         adaptedTools = applyToolPolicy(adaptedTools, context2, this.toolPolicyConfig);
         if (context2 !== "telegram-admin-dm") {
           const memWriteIdx = adaptedTools.findIndex((t2) => t2.name === "memory_write");
@@ -622073,6 +622718,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         currentConfig,
         repoRoot
       );
+      telegramBridge.setInteractionMode(savedSettings.telegramMode ?? "auto");
       if (adminId) {
         telegramBridge.setAdmin(adminId);
       }
@@ -622185,7 +622831,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         );
       });
       writeContent(
-        () => renderTelegramStart(telegramBridge.botUsername, adminId)
+        () => renderTelegramStart(telegramBridge.botUsername, adminId, savedSettings.telegramMode ?? "auto")
       );
       showPrompt();
     },
@@ -622204,7 +622850,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
     getTelegramSettings() {
       return {
         key: savedSettings.telegramKey,
-        admin: savedSettings.telegramAdmin
+        admin: savedSettings.telegramAdmin,
+        mode: savedSettings.telegramMode
       };
     },
     saveTelegramSettings(settings) {
@@ -622214,9 +622861,13 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       if (settings.admin !== void 0) {
         savedSettings.telegramAdmin = settings.admin;
       }
+      if (settings.mode !== void 0) {
+        savedSettings.telegramMode = settings.mode;
+      }
       const payload = {
         ...settings.key !== void 0 ? { telegramKey: settings.key } : {},
-        ...settings.admin !== void 0 ? { telegramAdmin: settings.admin } : {}
+        ...settings.admin !== void 0 ? { telegramAdmin: settings.admin } : {},
+        ...settings.mode !== void 0 ? { telegramMode: settings.mode } : {}
       };
       if (settings.local) {
         saveProjectSettings(repoRoot, payload);
@@ -622224,6 +622875,10 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         saveGlobalSettings(payload);
       }
     },
+    telegramSetInteractionMode(mode) {
+      savedSettings.telegramMode = mode;
+      telegramBridge?.setInteractionMode(mode);
+    },
     telegramStatus() {
       const active = telegramBridge?.isActive ?? false;
       const botUser = active ? telegramBridge?.botUsername : void 0;
@@ -622233,7 +622888,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           active,
           botUser,
           savedSettings.telegramAdmin,
-          subAgents
+          subAgents,
+          savedSettings.telegramMode ?? "auto"
         )
       );
     },

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.583",
+  "version": "0.187.585",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.583",
+      "version": "0.187.585",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.583",
+  "version": "0.187.585",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",