alvin-bot 4.5.0 → 4.6.0

package/dist/services/session.js

@@ -27,15 +27,20 @@ export function getSession(key) {
             totalCost: 0,
             costByProvider: {},
             queriesByProvider: {},
-            effort: "high",
+            effort: "medium",
             voiceReply: false,
             messageCount: 0,
             toolUseCount: 0,
             totalInputTokens: 0,
             totalOutputTokens: 0,
+            lastTurnInputTokens: 0,
+            compactionCount: 0,
+            checkpointHintsInjected: 0,
+            sdkSubTaskCount: 0,
             history: [],
             language: "en",
             messageQueue: [],
+            lastSdkHistoryIndex: -1,
         };
         sessions.set(k, session);
     }
@@ -56,7 +61,12 @@ export function resetSession(key) {
     session.toolUseCount = 0;
     session.totalInputTokens = 0;
     session.totalOutputTokens = 0;
+    session.lastTurnInputTokens = 0;
+    session.compactionCount = 0;
+    session.checkpointHintsInjected = 0;
+    session.sdkSubTaskCount = 0;
     session.history = [];
+    session.lastSdkHistoryIndex = -1;
     session.startedAt = Date.now();
     // Reset budget warning flags so the user gets fresh warnings in the new session.
     session._budgetWarned80 = false;
@@ -138,13 +148,21 @@ export function stopSessionCleanup() {
         cleanupTimer = null;
     }
 }
-/** Add a message to conversation history (for non-SDK providers). */
+/** Add a message to conversation history. Unified across all provider types
+ * — SDK providers resume from their filesystem session but we still track the
+ * transcript here so failovers (and the B2 bridge-message) have context. */
 export function addToHistory(key, message) {
     const session = getSession(key);
     session.history.push(message);
-    // Trim oldest messages if history gets too long
+    // Trim oldest messages if history gets too long. Adjust lastSdkHistoryIndex
+    // by the number of dropped entries so it keeps pointing at the correct
+    // (now shifted) assistant turn — or collapses to -1 if it falls off the front.
     if (session.history.length > MAX_HISTORY) {
+        const dropped = session.history.length - MAX_HISTORY;
         session.history = session.history.slice(-MAX_HISTORY);
+        if (session.lastSdkHistoryIndex >= 0) {
+            session.lastSdkHistoryIndex = Math.max(-1, session.lastSdkHistoryIndex - dropped);
+        }
     }
 }
 /** Get all active sessions (for web UI session browser). */

package/dist/services/subagent-delivery.js

@@ -0,0 +1,111 @@
+/**
+ * Sub-Agent Delivery Router (I3) — context-aware rendering of sub-agent
+ * results into Telegram. Source decides the delivery path:
+ *   - implicit → no-op (main stream already shows the Task-tool result)
+ *   - user     → banner+final as a new message in parentChatId
+ *   - cron     → banner+final in chatId from the CronJob target
+ *
+ * The caller is responsible for passing a correct `parentChatId` on the
+ * SubAgentInfo. Lookup of the bot API is lazy so we can unit-test the
+ * module with a fake bot via __setBotApiForTest.
+ */
+import { getVisibility } from "./subagents.js";
+const MAX_TG_CHUNK = 3800; // below Telegram's 4096 limit with headroom
+const FILE_UPLOAD_THRESHOLD = 20_000; // switch to .md file upload above this
+let injectedApi = null;
+let runtimeApi = null;
+/** Test-only hook for injecting a fake bot API. Production code must NEVER call this. */
+export function __setBotApiForTest(api) {
+    injectedApi = api;
+}
+/** Wire the grammy bot API once at startup (called from src/index.ts). */
+export function attachBotApi(api) {
+    runtimeApi = api;
+}
+function getBotApi() {
+    return injectedApi ?? runtimeApi;
+}
+function formatTokens(n) {
+    if (n < 1000)
+        return `${n}`;
+    return `${(n / 1000).toFixed(1)}k`;
+}
+function formatDuration(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    const rem = s - m * 60;
+    return `${m}m ${rem}s`;
+}
+function statusIcon(status) {
+    switch (status) {
+        case "completed": return "✅";
+        case "timeout": return "⏱️";
+        case "cancelled": return "⚠️";
+        case "error": return "❌";
+    }
+}
+function buildBanner(info, result) {
+    const icon = statusIcon(result.status);
+    const dur = formatDuration(result.duration);
+    const ti = formatTokens(result.tokensUsed.input);
+    const to = formatTokens(result.tokensUsed.output);
+    return `${icon} *${info.name}* ${result.status} · ${dur} · ${ti} in / ${to} out`;
+}
+/**
+ * Main delivery entry point. Resolves the effective visibility (override →
+ * config default), then dispatches to the source-specific renderer.
+ *
+ * Errors are logged but never thrown — delivery must not break the sub-agent
+ * lifecycle. A failed Telegram send falls through silently.
+ */
+export async function deliverSubAgentResult(info, result, opts = {}) {
+    // Implicit spawns: the Task-tool bridge in the main stream has already
+    // surfaced the output; extra delivery would be duplication.
+    if (info.source === "implicit")
+        return;
+    const effective = opts.visibility ?? getVisibility();
+    if (effective === "silent")
+        return;
+    const api = getBotApi();
+    if (!api) {
+        console.warn(`[subagent-delivery] no bot api available for ${info.name}`);
+        return;
+    }
+    if (!info.parentChatId) {
+        console.warn(`[subagent-delivery] missing parentChatId for ${info.name} (source=${info.source})`);
+        return;
+    }
+    const banner = buildBanner(info, result);
+    const body = result.output?.trim() || `(empty output)`;
+    try {
+        // Case 1: very long output → file upload with a short banner
+        if (body.length > FILE_UPLOAD_THRESHOLD) {
+            await api.sendMessage(info.parentChatId, banner, { parse_mode: "Markdown" });
+            try {
+                const { InputFile } = await import("grammy");
+                const buf = Buffer.from(body, "utf-8");
+                await api.sendDocument(info.parentChatId, new InputFile(buf, `${info.name}.md`));
+            }
+            catch (err) {
+                console.error(`[subagent-delivery] file upload failed:`, err);
+                await api.sendMessage(info.parentChatId, body.slice(0, MAX_TG_CHUNK));
+            }
+            return;
+        }
+        // Case 2: fits in a single message → banner + body joined
+        if (body.length + banner.length + 2 <= MAX_TG_CHUNK) {
+            await api.sendMessage(info.parentChatId, `${banner}\n\n${body}`, { parse_mode: "Markdown" });
+            return;
+        }
+        // Case 3: medium output → banner as its own message, body chunked
+        await api.sendMessage(info.parentChatId, banner, { parse_mode: "Markdown" });
+        for (let i = 0; i < body.length; i += MAX_TG_CHUNK) {
+            await api.sendMessage(info.parentChatId, body.slice(i, i + MAX_TG_CHUNK));
+        }
+    }
+    catch (err) {
+        console.error(`[subagent-delivery] send failed for ${info.name}:`, err);
+    }
+}

package/dist/services/subagents.js

@@ -6,25 +6,186 @@
  * Results are stored and can be retrieved by the caller.
  */
 import os from "os";
+import fs from "fs";
+import { resolve, dirname } from "path";
 import crypto from "crypto";
 import { config } from "../config.js";
+// ── File-based config (persistent, runtime-editable) ───────────────────
+const DATA_DIR = process.env.ALVIN_DATA_DIR || resolve(os.homedir(), ".alvin-bot");
+const CONFIG_FILE = resolve(DATA_DIR, "sub-agents.json");
+const ABSOLUTE_MAX_AGENTS = 16; // Hard cap no matter what
+const MAX_SUBAGENT_DEPTH = 2; // F2: hard cap on nested spawning
+let configCache = null;
+function isValidVisibility(v) {
+    return v === "auto" || v === "banner" || v === "silent";
+}
+function loadSubAgentsConfig() {
+    if (configCache)
+        return configCache;
+    try {
+        const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        configCache = {
+            maxParallel: typeof parsed.maxParallel === "number" ? parsed.maxParallel : 0,
+            visibility: isValidVisibility(parsed.visibility) ? parsed.visibility : "auto",
+        };
+    }
+    catch {
+        // File missing or invalid — seed from env var then default to auto
+        configCache = {
+            maxParallel: Number(process.env.MAX_SUBAGENTS) || 0,
+            visibility: "auto",
+        };
+    }
+    return configCache;
+}
+function saveSubAgentsConfig(cfg) {
+    try {
+        fs.mkdirSync(dirname(CONFIG_FILE), { recursive: true });
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), "utf-8");
+        configCache = cfg;
+    }
+    catch (err) {
+        console.error("[subagents] failed to write config:", err);
+    }
+}
+/** Resolves max parallel agents, interpreting 0 as "auto = cpu cores capped". */
+export function getMaxParallelAgents() {
+    const cfg = loadSubAgentsConfig();
+    if (cfg.maxParallel === 0) {
+        return Math.min(os.cpus().length, ABSOLUTE_MAX_AGENTS);
+    }
+    return Math.min(Math.max(1, cfg.maxParallel), ABSOLUTE_MAX_AGENTS);
+}
+/** Returns the raw configured value (for display). 0 means "auto". */
+export function getConfiguredMaxParallel() {
+    return loadSubAgentsConfig().maxParallel;
+}
+/** Sets max parallel agents. Value is clamped to [0, ABSOLUTE_MAX_AGENTS].
+ *  Returns the resolved effective value (with auto-expansion if set to 0). */
+export function setMaxParallelAgents(n) {
+    const clamped = Math.max(0, Math.min(Math.floor(n), ABSOLUTE_MAX_AGENTS));
+    const cfg = loadSubAgentsConfig();
+    saveSubAgentsConfig({ ...cfg, maxParallel: clamped });
+    return getMaxParallelAgents();
+}
+/** A4: Current default visibility mode for new spawns. */
+export function getVisibility() {
+    return loadSubAgentsConfig().visibility;
+}
+/**
+ * A4: Set the default visibility mode. Throws if the value is invalid.
+ * Writes through to the on-disk config so restart-resilient.
+ */
+export function setVisibility(mode) {
+    if (!isValidVisibility(mode)) {
+        throw new Error(`Invalid visibility mode "${mode}". Expected: auto | banner | silent.`);
+    }
+    const cfg = loadSubAgentsConfig();
+    saveSubAgentsConfig({ ...cfg, visibility: mode });
+}
 // ── State ───────────────────────────────────────────────
 const activeAgents = new Map();
+// ── Name resolver (B2) ──────────────────────────────────
+/**
+ * Return all currently-tracked agents whose *base* name matches `base`.
+ * Base name = the part before any "#N" suffix.
+ */
+function agentsByBaseName(base) {
+    const out = [];
+    for (const entry of activeAgents.values()) {
+        const info = entry.info;
+        const entryBase = info.name.replace(/#\d+$/, "");
+        if (entryBase === base)
+            out.push(info);
+    }
+    return out;
+}
+/**
+ * Given a requested name, return a unique variant. If no collision exists,
+ * returns `requested` unchanged (with the base form). Otherwise returns
+ * `base#N` with the smallest free N ≥ 2.
+ */
+function resolveAgentName(requested) {
+    const base = requested.replace(/#\d+$/, "");
+    const siblings = agentsByBaseName(base);
+    if (siblings.length === 0)
+        return { name: base };
+    // Find the smallest free index ≥ 2. The bare base name counts as "#1".
+    const takenIndices = new Set();
+    for (const s of siblings) {
+        const m = s.name.match(/#(\d+)$/);
+        if (m)
+            takenIndices.add(parseInt(m[1], 10));
+        else
+            takenIndices.add(1);
+    }
+    let n = 2;
+    while (takenIndices.has(n))
+        n++;
+    return { name: `${base}#${n}`, index: n };
+}
+/**
+ * Public name-resolution API used by /sub-agents cancel / result.
+ * - Exact name match wins (e.g. "review#2" finds exactly that entry).
+ * - If only one agent matches the base name, returns that one.
+ * - If the caller opted into `ambiguousAsList`, returns a disambiguation
+ *   marker with all candidates instead of a single result.
+ */
+export function findSubAgentByName(name, opts = {}) {
+    // An explicit "base#N" query must always resolve to that exact entry,
+    // even when the caller opted into ambiguity. Otherwise users who type
+    // out the disambiguated form get an unhelpful 'which one?' reply.
+    const hasExplicitSuffix = /#\d+$/.test(name);
+    if (hasExplicitSuffix) {
+        for (const entry of activeAgents.values()) {
+            if (entry.info.name === name)
+                return { ...entry.info };
+        }
+        return null;
+    }
+    // No explicit suffix → base-name query. Ambiguity detection runs here
+    // when the caller opted in and there are multiple siblings.
+    const siblings = agentsByBaseName(name);
+    if (siblings.length === 0)
+        return null;
+    if (opts.ambiguousAsList && siblings.length > 1) {
+        return {
+            ambiguous: true,
+            candidates: siblings.map((s) => ({ ...s })),
+        };
+    }
+    // Without ambiguity opt-in, prefer an exact name match over just the
+    // first sibling — the bare base name is itself a unique key.
+    for (const entry of activeAgents.values()) {
+        if (entry.info.name === name)
+            return { ...entry.info };
+    }
+    return { ...siblings[0] };
+}
 // ── Core execution ──────────────────────────────────────
-async function runSubAgent(id, agentConfig, abort) {
+async function runSubAgent(id, agentConfig, abort, resolvedName) {
     const startTime = Date.now();
     const entry = activeAgents.get(id);
     try {
         const { getRegistry } = await import("../engine.js");
         const registry = getRegistry();
-        const systemPrompt = `You are a sub-agent named "${agentConfig.name}". Complete the following task autonomously and report your results clearly when done. Working directory: ${agentConfig.workingDir || os.homedir()}`;
+        // C3: inheritCwd (default true) decides whether the parent's working
+        // dir flows through. When false, we fall back to the home directory —
+        // useful for cron jobs that must run in a well-known root regardless
+        // of what the caller was doing.
+        const inheritCwd = agentConfig.inheritCwd ?? true;
+        const effectiveCwd = inheritCwd
+            ? agentConfig.workingDir || os.homedir()
+            : os.homedir();
+        const systemPrompt = `You are a sub-agent named "${resolvedName}". Complete the following task autonomously and report your results clearly when done. Working directory: ${effectiveCwd}`;
         let finalText = "";
         let inputTokens = 0;
         let outputTokens = 0;
         for await (const chunk of registry.queryWithFallback({
             prompt: agentConfig.prompt,
             systemPrompt,
-            workingDir: agentConfig.workingDir || os.homedir(),
+            workingDir: effectiveCwd,
             effort: "high",
             abortSignal: abort.signal,
         })) {
@@ -35,15 +196,37 @@ async function runSubAgent(id, agentConfig, abort) {
                 outputTokens = chunk.outputTokens || 0;
             }
         }
-        entry.result = {
-            id,
-            name: agentConfig.name,
-            status: "completed",
-            output: finalText,
-            tokensUsed: { input: inputTokens, output: outputTokens },
-            duration: Date.now() - startTime,
-        };
-        entry.info.status = "completed";
+        // If cancelAllSubAgents has already taken over (shutdown path), don't
+        // overwrite the cancelled result it synthesised. Also: if the generator
+        // exited gracefully but the abort signal fired mid-stream (e.g. the
+        // provider's queryWithFallback returned `type:error` and we fell out
+        // of the loop without throwing), mark the run as cancelled rather
+        // than completed — the result output is whatever we buffered.
+        if (entry.result && entry.result.status === "cancelled") {
+            // cancelAllSubAgents already set this; nothing to do.
+        }
+        else if (abort.signal.aborted) {
+            entry.result = {
+                id,
+                name: resolvedName,
+                status: "cancelled",
+                output: finalText,
+                tokensUsed: { input: inputTokens, output: outputTokens },
+                duration: Date.now() - startTime,
+            };
+            entry.info.status = "cancelled";
+        }
+        else {
+            entry.result = {
+                id,
+                name: resolvedName,
+                status: "completed",
+                output: finalText,
+                tokensUsed: { input: inputTokens, output: outputTokens },
+                duration: Date.now() - startTime,
+            };
+            entry.info.status = "completed";
+        }
     }
     catch (err) {
         const isAbort = err instanceof Error && err.message.includes("abort");
@@ -55,7 +238,7 @@ async function runSubAgent(id, agentConfig, abort) {
                 : "error";
         entry.result = {
             id,
-            name: agentConfig.name,
+            name: resolvedName,
             status,
             output: "",
             tokensUsed: { input: 0, output: 0 },
@@ -71,11 +254,47 @@ async function runSubAgent(id, agentConfig, abort) {
  * Returns the agent ID immediately (does NOT await completion).
  */
 export function spawnSubAgent(agentConfig) {
-    // Check concurrency limit
-    const runningCount = [...activeAgents.values()].filter((a) => a.info.status === "running").length;
-    if (runningCount >= config.maxSubAgents) {
-        return Promise.reject(new Error(`Sub-agent limit reached (${config.maxSubAgents}). Wait for a running agent to finish or cancel one.`));
+    // F2: enforce depth cap before touching any state.
+    const depth = agentConfig.depth ?? 0;
+    if (depth > MAX_SUBAGENT_DEPTH) {
+        return Promise.reject(new Error(`Sub-agent depth limit reached (${MAX_SUBAGENT_DEPTH}). Agents can only spawn ${MAX_SUBAGENT_DEPTH} level(s) of nested agents.`));
+    }
+    // G1: toolset preset. Only "full" is supported in Stufe 1. The literal
+    // type blocks wrong values at compile time; the runtime check catches
+    // callers that bypass TypeScript (e.g. plugin code loaded at runtime).
+    const toolset = agentConfig.toolset ?? "full";
+    if (toolset !== "full") {
+        return Promise.reject(new Error(`Invalid toolset "${toolset}". Only "full" is supported in this version.`));
+    }
+    // Check concurrency limit — now reads from the file-backed config so
+    // /sub-agents max <n> edits take effect immediately without a restart.
+    const running = [...activeAgents.values()].filter((a) => a.info.status === "running");
+    const maxParallel = getMaxParallelAgents();
+    if (running.length >= maxParallel) {
+        // D4: priority-aware reject messages — give callers context about
+        // WHO is holding the slots so they know whether to wait, cancel,
+        // or give up.
+        const source = agentConfig.source ?? "implicit";
+        const userSlots = running.filter((a) => a.info.source === "user").length;
+        const bgSlots = running.length - userSlots;
+        let message;
+        if (source === "user") {
+            if (bgSlots > 0) {
+                message = `Alle Slots belegt (${running.length}/${maxParallel}), davon ${bgSlots} cron/implicit im Hintergrund. /sub-agents list für Details oder /sub-agents cancel <name>.`;
+            }
+            else {
+                message = `Alle Slots belegt (${running.length}/${maxParallel}) mit eigenen user-Spawns. /sub-agents cancel <name> oder warten: /sub-agents list`;
+            }
+        }
+        else {
+            message = `Sub-agent limit reached (${maxParallel}). Wait for a running agent to finish or cancel one.`;
+        }
+        return Promise.reject(new Error(message));
     }
+    // B2: resolve the requested name to a unique variant. On collision,
+    // append #N where N is the smallest free index ≥ 2.
+    const resolved = resolveAgentName(agentConfig.name);
+    const resolvedName = resolved.name;
     const id = crypto.randomUUID();
     const timeout = agentConfig.timeout ?? config.subAgentTimeout;
     const abort = new AbortController();
@@ -83,20 +302,51 @@ export function spawnSubAgent(agentConfig) {
     const timeoutId = setTimeout(() => abort.abort(), timeout);
     const info = {
         id,
-        name: agentConfig.name,
+        name: resolvedName,
         status: "running",
         startedAt: Date.now(),
         model: agentConfig.model,
+        source: agentConfig.source,
+        depth,
+        parentChatId: agentConfig.parentChatId,
+        nameIndex: resolved.index,
     };
-    activeAgents.set(id, { info, abort });
+    activeAgents.set(id, { info, abort, delivered: false });
     // Run in background — don't await
-    runSubAgent(id, agentConfig, abort)
+    runSubAgent(id, agentConfig, abort, resolvedName)
         .finally(() => {
         clearTimeout(timeoutId);
+        // Call the onComplete callback if the caller provided one. This is
+        // how cron.ts turns the fire-and-forget spawnSubAgent() into a
+        // Promise that resolves when the work finishes. The callback runs
+        // inside a try/catch so a throwing callback can't break cleanup.
+        const entry = activeAgents.get(id);
+        if (agentConfig.onComplete && entry?.result) {
+            try {
+                agentConfig.onComplete(entry.result);
+            }
+            catch (err) {
+                console.error(`[subagent ${id}] onComplete callback threw:`, err);
+            }
+        }
+        // I3: fire delivery router (non-blocking, errors logged). Dynamic
+        // import keeps the module graph free of circular edges. Guarded by
+        // the `delivered` flag so cancelAllSubAgents (shutdown path) and
+        // this finally() can't both post the result.
+        if (entry?.result && !entry.delivered) {
+            entry.delivered = true;
+            const resultSnapshot = entry.result;
+            const infoSnapshot = entry.info;
+            import("./subagent-delivery.js")
+                .then(({ deliverSubAgentResult }) => deliverSubAgentResult(infoSnapshot, resultSnapshot, {
+                visibility: agentConfig.visibility,
+            }))
+                .catch((err) => console.error(`[subagent ${id}] delivery failed:`, err));
+        }
         // Auto-cleanup: remove completed agents after 30 minutes
         setTimeout(() => {
-            const entry = activeAgents.get(id);
-            if (entry && entry.info.status !== "running") {
+            const e = activeAgents.get(id);
+            if (e && e.info.status !== "running") {
                 activeAgents.delete(id);
             }
         }, 30 * 60 * 1000);
@@ -129,14 +379,78 @@ export function getSubAgentResult(id) {
     const entry = activeAgents.get(id);
     return entry?.result ?? null;
 }
+/**
+ * Cancel a sub-agent by name (or name#N). Returns true if a running agent
+ * was found and aborted. Uses findSubAgentByName for resolution; in an
+ * ambiguous case (multiple siblings under the same base name, caller did
+ * not disambiguate), cancels the first candidate.
+ */
+export function cancelSubAgentByName(name) {
+    const match = findSubAgentByName(name);
+    if (!match || "ambiguous" in match)
+        return false;
+    return cancelSubAgent(match.id);
+}
+/**
+ * Get a sub-agent's result by name. Returns null if no such agent, no
+ * result yet (still running), or the name is ambiguous without explicit
+ * disambiguation.
+ */
+export function getSubAgentResultByName(name) {
+    const match = findSubAgentByName(name);
+    if (!match || "ambiguous" in match)
+        return null;
+    return getSubAgentResult(match.id);
+}
 /**
  * Cancel all active sub-agents. Used during shutdown.
+ *
+ * When notify=true (default), each running agent gets a Telegram
+ * delivery explaining that it was interrupted by a restart. Errors
+ * during delivery are logged but never block shutdown. The whole
+ * notify phase is capped at 5s so a hung Telegram send can't hold
+ * the process hostage.
  */
-export function cancelAllSubAgents() {
+export async function cancelAllSubAgents(notify = true) {
+    const deliveryPromises = [];
+    // Iterate once: for each running agent (1) abort the SDK stream,
+    // (2) synthesise and store a cancelled SubAgentResult, (3) mark
+    // delivered=true so runSubAgent.finally() can't fire a second
+    // delivery on the next microtask, (4) queue the I3 delivery.
+    const runningEntries = [];
     for (const [id, entry] of activeAgents) {
-        if (entry.info.status === "running") {
-            entry.abort.abort();
-            entry.info.status = "cancelled";
-        }
+        if (entry.info.status !== "running")
+            continue;
+        entry.abort.abort();
+        entry.info.status = "cancelled";
+        const cancelResult = {
+            id,
+            name: entry.info.name,
+            status: "cancelled",
+            output: "⚠️ Agent wurde durch Bot-Restart unterbrochen. Bitte neu triggern.",
+            tokensUsed: { input: 0, output: 0 },
+            duration: Date.now() - entry.info.startedAt,
+        };
+        entry.result = cancelResult;
+        entry.delivered = true;
+        runningEntries.push({ id, info: entry.info, cancelResult });
+    }
+    if (!notify || runningEntries.length === 0)
+        return;
+    // Import once, then reuse. Doing one dynamic import per running agent
+    // races with Vitest's mock-resolution in tests and can occasionally
+    // resolve to the real module instead of the mock for later calls.
+    const { deliverSubAgentResult } = await import("./subagent-delivery.js");
+    for (const { id, info, cancelResult } of runningEntries) {
+        const p = Promise.resolve(deliverSubAgentResult(info, cancelResult)).catch((err) => {
+            console.error(`[subagents] shutdown-notify failed for ${id}:`, err);
+        });
+        deliveryPromises.push(p);
     }
+    // Wait up to 5s total — long enough for real Telegram sends, short
+    // enough that shutdown isn't held hostage by a hang.
+    await Promise.race([
+        Promise.all(deliveryPromises),
+        new Promise((r) => setTimeout(r, 5000)),
+    ]);
 }

package/dist/services/telegram.js

@@ -9,13 +9,38 @@ export class TelegramStreamer {
     pendingText = null;
     editTimer = null;
     lastSentText = "";
+    currentStatus = null;
+    lastFullText = "";
     constructor(chatId, api, replyToMessageId) {
         this.chatId = chatId;
         this.api = api;
         this.replyTo = replyToMessageId;
     }
+    /**
+     * Set a transient status line (e.g. "📖 Read file.html…") that gets
+     * appended to the current accumulated text. Passing null clears it.
+     * Used to surface tool-use activity so users see real progress instead
+     * of an endless typing indicator.
+     */
+    setStatus(status) {
+        if (this.currentStatus === status)
+            return;
+        this.currentStatus = status;
+        // Re-render with the previously accumulated text so the new status
+        // becomes visible immediately (throttled by the existing flush timer).
+        void this.update(this.lastFullText);
+    }
+    renderWithStatus(fullText) {
+        const truncated = this.truncate(fullText);
+        const hasBody = truncated.length > 0;
+        const body = hasBody ? truncated : "…";
+        if (!this.currentStatus)
+            return body;
+        return hasBody ? `${body}\n\n_${this.currentStatus}_` : `_${this.currentStatus}_`;
+    }
     async update(fullText) {
-        const displayText = sanitizeTelegramMarkdown(this.truncate(fullText) || "...");
+        this.lastFullText = fullText;
+        const displayText = sanitizeTelegramMarkdown(this.renderWithStatus(fullText));
         if (!this.messageId) {
             const opts = { parse_mode: "Markdown" };
             if (this.replyTo)
@@ -52,6 +77,8 @@ export class TelegramStreamer {
         }
     }
     async finalize(fullText) {
+        // Drop any transient status line — final message should be clean text.
+        this.currentStatus = null;
         if (this.editTimer) {
             clearTimeout(this.editTimer);
             this.editTimer = null;