open-agents-ai 0.187.584 → 0.187.586

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 "";
@@ -590819,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":
@@ -590866,6 +590867,8 @@ var init_tool_policy = __esm({
       "memory_read",
       "memory_write",
       "memory_search",
+      "todo_read",
+      "todo_write",
       "web_search",
       "web_fetch",
       "task_complete"
@@ -590874,6 +590877,8 @@ var init_tool_policy = __esm({
       "memory_read",
       "memory_write",
       "memory_search",
+      "todo_read",
+      "todo_write",
       "web_search",
       "web_fetch",
       "web_crawl",
@@ -590945,35 +590950,85 @@ 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;
   if (event.type === "tool_call") {
-    return `🔧 Using <code>${escapeTelegramHTML(event.toolName || "tool")}</code>`;
+    return `Using ${escapeTelegramHTML(event.toolName || "tool")}`;
   }
   if (event.type === "tool_result") {
-    const icon = event.success ? "✔" : "✘";
     const preview = sanitizeTelegramProgressText(event.content || "", 80);
-    const suffix = preview ? `: ${escapeTelegramHTML(preview)}` : "";
-    return `${icon} <code>${escapeTelegramHTML(event.toolName || "tool")}</code>${suffix}`;
+    const toolName = escapeTelegramHTML(event.toolName || "tool");
+    if (preview) return `${toolName}: ${escapeTelegramHTML(preview)}`;
+    return event.success ? `${toolName} completed` : `${toolName} failed`;
   }
   if (event.type === "status") {
     const content = sanitizeTelegramProgressText(event.content || "", 120);
-    return content ? `⏳ ${escapeTelegramHTML(content)}` : null;
+    return content ? escapeTelegramHTML(content) : null;
   }
   return null;
 }
 function renderTelegramLiveProgressHTML(progressLines, accumulated) {
-  const recentProgress = progressLines.slice(-6);
-  const progressBlock = recentProgress.length > 0 ? recentProgress.join("\n") : "⏳ Starting...";
-  const draft = sanitizeTelegramProgressText(accumulated, 700);
-  const draftBlock = draft ? `
-
-<i>Drafting answer...</i>
-${convertMarkdownToTelegramHTML(draft)}
-<i>▌</i>` : "\n\n<i>Working...</i>";
-  return `<b>✈ Working on this...</b>
-${progressBlock}${draftBlock}`;
+  const draft = stripTelegramHiddenThinking(accumulated).trim();
+  if (draft) {
+    const clipped = draft.length > 2e3 ? `${draft.slice(0, 1997).trimEnd()}...` : draft;
+    return convertMarkdownToTelegramHTML(clipped);
+  }
+  return progressLines.slice(-6).map((line) => line.trim()).filter(Boolean).join("\n");
 }
 function normalizeTelegramChatId(value2) {
   if (typeof value2 === "number" || typeof value2 === "string") return value2;
@@ -591185,14 +591240,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);
+        }
+      }
     }
   };
 }
@@ -591309,7 +591374,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, TELEGRAM_CHAT_MODE_PROMPT, TELEGRAM_ACTION_INTENT_RE, TELEGRAM_CODEBASE_CONTEXT_RE, TELEGRAM_COMMANDISH_RE, TELEGRAM_CHAT_INTENT_RE, 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";
@@ -591374,10 +591439,27 @@ You are Open Agents replying in Telegram quick-chat mode.
 
 Rules:
 1. Reply directly to the Telegram user, conversationally and concisely.
-2. Do not inspect, summarize, or expose local files, paths, secrets, tool output, or runtime internals.
-3. Do not claim that you changed code, ran commands, or checked the workspace in quick-chat mode.
-4. If the user asks for codebase action while quick-chat mode is forced, tell them to switch Telegram to action mode or send a concrete action request in auto mode.
-5. For ordinary chat, status questions, greetings, quick explanations, and playful messages, answer immediately without tool-use narration.
+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;
@@ -591578,10 +591660,92 @@ Rules:
       }
       recordChatHistory(sessionKey, entry) {
         const existing = this.chatHistory.get(sessionKey) ?? [];
-        existing.push(entry);
+        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();
@@ -591865,6 +592029,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"));
@@ -591889,7 +592054,10 @@ Join: ${newUrl}`);
           runner: null,
           typingInterval: null,
           liveMessageId: null,
+          liveMessagePromise: null,
           accumulated: "",
+          assistantText: "",
+          streamText: "",
           intermediateLines: [],
           lastEditMs: 0,
           aborted: false,
@@ -591909,14 +592077,6 @@ Join: ${newUrl}`);
         }
         this.tuiWrite(() => renderTelegramSubAgentStart(msg.username, msg.text, isAdminDM));
         try {
-          if (!msg.guestQueryId) {
-            const msgId = await this.sendLiveMessage(
-              msg.chatId,
-              renderTelegramLiveProgressHTML([], ""),
-              msg.chatType !== "private" ? msg.messageId : void 0
-            );
-            subAgent.liveMessageId = msgId;
-          }
           let mediaContext = "";
           if (msg.media) {
             mediaContext = await this.processMedia(msg);
@@ -591937,6 +592097,12 @@ Join: ${newUrl}`);
             return;
           }
           const finalText = stripTelegramHiddenThinking(result || "").trim() || "I couldn't generate a response. Please try again.";
+          if (subAgent.liveMessagePromise) {
+            await subAgent.liveMessagePromise.catch(() => {
+            });
+          }
+          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);
@@ -591959,7 +592125,7 @@ Join: ${newUrl}`);
           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: ${errMsg}`).catch(() => {
+            await this.editLiveMessage(msg.chatId, subAgent.liveMessageId, `Error: ${errMsg}`).catch(() => {
             });
           } else {
             await this.replyToTelegramMessage(msg, "Sorry, I encountered an error processing your message. Please try again.").catch(() => {
@@ -591971,8 +592137,96 @@ Join: ${newUrl}`);
           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,
+          liveMessagePromise: null,
+          accumulated: "",
+          assistantText: "",
+          streamText: "",
+          intermediateLines: [],
+          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 {
+          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.";
+          if (subAgent.liveMessagePromise) {
+            await subAgent.liveMessagePromise.catch(() => {
+            });
+          }
+          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;
@@ -591984,7 +592238,8 @@ Join: ${newUrl}`);
         let accumulated = "";
         let lastEditMs = 0;
         let lastViewWriteMs = 0;
-        const progressLines = [`💬 Quick chat mode (${this.interactionMode})`];
+        let liveMessagePromise = null;
+        const progressLines = [];
         this.activeChatViews.add(viewId);
         this.refreshActiveTelegramInteractionCount();
         this.subAgentViewCallbacks?.onRegister(
@@ -592000,19 +592255,12 @@ Join: ${newUrl}`);
         }
         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) => {
+            async (nextText) => {
               accumulated = nextText;
               const now = Date.now();
               if (now - lastViewWriteMs > 900) {
@@ -592021,12 +592269,28 @@ Join: ${newUrl}`);
               }
               if (liveMessageId && !msg.guestQueryId && now - lastEditMs > 900) {
                 lastEditMs = now;
-                this.editLiveMessage(
+                await this.editLiveMessage(
                   msg.chatId,
                   liveMessageId,
                   renderTelegramLiveProgressHTML(progressLines, accumulated)
                 ).catch(() => {
                 });
+              } else if (!liveMessageId && !liveMessagePromise && !msg.guestQueryId) {
+                const html = renderTelegramLiveProgressHTML(progressLines, accumulated);
+                if (html.trim()) {
+                  liveMessagePromise = this.sendLiveMessage(
+                    msg.chatId,
+                    html,
+                    msg.chatType !== "private" ? msg.messageId : void 0
+                  ).then((id) => {
+                    liveMessageId = id;
+                    lastEditMs = Date.now();
+                  }).catch(() => {
+                  }).finally(() => {
+                    liveMessagePromise = null;
+                  });
+                  await liveMessagePromise;
+                }
               }
             }
           );
@@ -592035,8 +592299,13 @@ Join: ${newUrl}`);
             typingInterval = null;
           }
           const cleaned = stripTelegramHiddenThinking(finalText || accumulated).trim() || "I heard you.";
-          this.recordChatHistory(sessionKey, { role: "user", text: msg.text });
-          this.recordChatHistory(sessionKey, { role: "assistant", text: cleaned });
+          const pendingLiveMessage = liveMessagePromise;
+          if (pendingLiveMessage) {
+            await pendingLiveMessage.catch(() => {
+            });
+          }
+          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);
@@ -592058,7 +592327,7 @@ Join: ${newUrl}`);
           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(() => {
+            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(() => {
@@ -592078,11 +592347,16 @@ Join: ${newUrl}`);
         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}`
@@ -592123,19 +592397,19 @@ ${mediaContext}` : ""}`
           for await (const chunk of streamable.chatCompletionStream(request)) {
             if (chunk.type === "content" && !chunk.thinking && chunk.content) {
               accumulated += chunk.content;
-              onToken(accumulated);
+              await onToken(accumulated);
             }
           }
         }
         if (!accumulated.trim()) {
           const result = await backend.chatCompletion(request);
           accumulated = result.choices[0]?.message?.content ?? "";
-          if (accumulated) onToken(accumulated);
+          if (accumulated) await 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);
@@ -592143,21 +592417,25 @@ ${mediaContext}` : ""}`
         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) {
@@ -592166,7 +592444,7 @@ ${mediaContext}` : ""}`
           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;
@@ -592179,33 +592457,46 @@ ${mediaContext}` : ""}`
             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) {
-              subAgent.accumulated += event.content;
-            }
-            const intermediateLine = formatTelegramProgressEvent(event);
-            if (intermediateLine) {
-              subAgent.intermediateLines.push(intermediateLine);
-            }
+          if (event.type === "stream_token" && event.streamKind === "content" && event.content) {
+            subAgent.accumulated += event.content;
+          }
+          const intermediateLine = formatTelegramProgressEvent(event);
+          if (intermediateLine) {
+            subAgent.intermediateLines.push(intermediateLine);
+          }
+          if (!msg.guestQueryId) {
+            const html = renderTelegramLiveProgressHTML(subAgent.intermediateLines, subAgent.accumulated);
+            if (!html.trim()) return;
             const now = Date.now();
-            if (now - subAgent.lastEditMs > 1e3) {
-              const hasContent = subAgent.accumulated.length > 10 || subAgent.intermediateLines.length > 0;
-              if (hasContent) {
+            if (subAgent.liveMessageId) {
+              if (now - subAgent.lastEditMs > 1e3) {
                 subAgent.lastEditMs = now;
-                this.editLiveMessage(
-                  msg.chatId,
-                  subAgent.liveMessageId,
-                  renderTelegramLiveProgressHTML(subAgent.intermediateLines, subAgent.accumulated)
-                ).catch(() => {
+                this.editLiveMessage(msg.chatId, subAgent.liveMessageId, html).catch(() => {
                 });
               }
+            } else if (!subAgent.liveMessagePromise) {
+              subAgent.liveMessagePromise = this.sendLiveMessage(
+                msg.chatId,
+                html,
+                msg.chatType !== "private" ? msg.messageId : void 0
+              ).then((id) => {
+                subAgent.liveMessageId = id;
+                subAgent.lastEditMs = Date.now();
+              }).catch(() => {
+              }).finally(() => {
+                subAgent.liveMessagePromise = null;
+              });
             }
           }
         });
         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 {
@@ -592217,7 +592508,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.";
@@ -592239,22 +592537,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"]
           },
@@ -592262,7 +592567,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),
@@ -592272,6 +592591,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(),
@@ -592286,7 +592607,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");

package/npm-shrinkwrap.json

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

package/package.json

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