@grinev/opencode-telegram-bot 0.13.2 → 0.14.0

package/dist/pinned/manager.js

@@ -3,7 +3,9 @@ import { opencodeClient } from "../opencode/client.js";
 import { getCurrentSession } from "../session/manager.js";
 import { getCurrentProject, getPinnedMessageId, setPinnedMessageId, clearPinnedMessageId, } from "../settings/manager.js";
 import { getStoredModel } from "../model/manager.js";
+import { getModelContextLimit } from "../model/context-limit.js";
 import { t } from "../i18n/index.js";
+import { DEFAULT_CONTEXT_LIMIT, formatContextLine, formatCostLine, formatModelDisplayName, } from "./format.js";
 class PinnedMessageManager {
     api = null;
     chatId = null;
@@ -147,6 +149,22 @@ class PinnedMessageManager {
         await this.refreshSessionTitle();
         await this.updatePinnedMessage();
     }
+    /**
+     * Update tokens in memory without triggering an API call.
+     * Used for intermediate (non-completed) message.updated events
+     * to keep pinned state in sync with keyboardManager.
+     */
+    updateTokensSilent(tokens) {
+        this.state.tokensUsed = tokens.input + tokens.cacheRead;
+        logger.debug(`[PinnedManager] Tokens updated (silent): ${this.state.tokensUsed}/${this.state.tokensLimit}`);
+    }
+    /**
+     * Refresh the pinned message with current in-memory state.
+     * Used at thinking time to push accumulated silent updates to Telegram.
+     */
+    async refresh() {
+        await this.updatePinnedMessage();
+    }
     /**
      * Called when cost info is received from SSE events
      */
@@ -162,6 +180,12 @@ class PinnedMessageManager {
     setOnKeyboardUpdate(callback) {
         this.onKeyboardUpdateCallback = callback;
         logger.debug("[PinnedManager] Keyboard update callback registered");
+        // Fire immediately with current state to fix race condition:
+        // onSessionChange may have already run before this callback was registered.
+        const limit = this.state.tokensLimit > 0 ? this.state.tokensLimit : this.contextLimit || 0;
+        if (limit > 0) {
+            callback(this.state.tokensUsed, limit);
+        }
     }
     /**
      * Get current context information
@@ -412,38 +436,13 @@ class PinnedMessageManager {
     async fetchContextLimit() {
         try {
             const model = getStoredModel();
-            if (!model.providerID || !model.modelID) {
-                logger.warn("[PinnedManager] No model configured, using default limit");
-                this.contextLimit = 200000;
-                this.state.tokensLimit = this.contextLimit;
-                return;
-            }
-            const { data: providersData, error } = await opencodeClient.config.providers();
-            if (error || !providersData) {
-                logger.warn("[PinnedManager] Failed to fetch providers, using default limit");
-                this.contextLimit = 200000;
-                this.state.tokensLimit = this.contextLimit;
-                return;
-            }
-            // Find the model in providers
-            for (const provider of providersData.providers) {
-                if (provider.id === model.providerID) {
-                    const modelInfo = provider.models[model.modelID];
-                    if (modelInfo?.limit?.context) {
-                        this.contextLimit = modelInfo.limit.context;
-                        this.state.tokensLimit = this.contextLimit;
-                        logger.debug(`[PinnedManager] Context limit: ${this.contextLimit}`);
-                        return;
-                    }
-                }
-            }
-            logger.warn("[PinnedManager] Model not found in providers, using default limit");
-            this.contextLimit = 200000;
+            this.contextLimit = await getModelContextLimit(model.providerID, model.modelID);
             this.state.tokensLimit = this.contextLimit;
+            logger.debug(`[PinnedManager] Context limit: ${this.contextLimit}`);
         }
         catch (err) {
             logger.error("[PinnedManager] Error fetching context limit:", err);
-            this.contextLimit = 200000;
+            this.contextLimit = DEFAULT_CONTEXT_LIMIT;
             this.state.tokensLimit = this.contextLimit;
         }
     }
@@ -451,28 +450,16 @@ class PinnedMessageManager {
      * Format the pinned message text
      */
     formatMessage() {
-        const percentage = this.state.tokensLimit > 0
-            ? Math.round((this.state.tokensUsed / this.state.tokensLimit) * 100)
-            : 0;
-        const tokensFormatted = this.formatTokenCount(this.state.tokensUsed);
-        const limitFormatted = this.formatTokenCount(this.state.tokensLimit);
-        // Get current model info
         const currentModel = getStoredModel();
-        const modelName = currentModel.providerID && currentModel.modelID
-            ? `${currentModel.providerID}/${currentModel.modelID}`
-            : t("pinned.unknown");
+        const modelName = formatModelDisplayName(currentModel.providerID, currentModel.modelID);
         const lines = [
             `${this.state.sessionTitle}`,
             t("pinned.line.project", { project: this.state.projectName }),
             t("pinned.line.model", { model: modelName }),
-            t("pinned.line.context", {
-                used: tokensFormatted,
-                limit: limitFormatted,
-                percent: percentage,
-            }),
+            formatContextLine(this.state.tokensUsed, this.state.tokensLimit),
         ];
         if (this.state.cost !== undefined && this.state.cost !== null) {
-            lines.push(t("pinned.line.cost", { cost: `$${this.state.cost.toFixed(2)}` }));
+            lines.push(formatCostLine(this.state.cost));
         }
         if (this.state.changedFiles.length > 0) {
             const maxFiles = 10;
@@ -496,18 +483,6 @@ class PinnedMessageManager {
         }
         return lines.join("\n");
     }
-    /**
-     * Format token count (e.g., 150000 -> "150K")
-     */
-    formatTokenCount(count) {
-        if (count >= 1000000) {
-            return `${(count / 1000000).toFixed(1)}M`;
-        }
-        else if (count >= 1000) {
-            return `${Math.round(count / 1000)}K`;
-        }
-        return count.toString();
-    }
     /**
      * Create and pin a new status message
      */

package/dist/summary/aggregator.js

@@ -39,6 +39,7 @@ class SummaryAggregator {
     onThinkingCallback = null;
     onTokensCallback = null;
     onCostCallback = null;
+    onSubagentCallback = null;
     onSessionCompactedCallback = null;
     onSessionErrorCallback = null;
     onSessionRetryCallback = null;
@@ -54,6 +55,13 @@ class SummaryAggregator {
     typingTimer = null;
     typingIndicatorEnabled = true;
     partHashes = new Map();
+    trackedSessionParents = new Map();
+    subagentStates = new Map();
+    subagentOrder = [];
+    subagentCardIdBySessionId = new Map();
+    pendingSubagentCardIdsByParent = new Map();
+    pendingChildSessionIdsByParent = new Map();
+    fallbackSubagentCardIdsByParent = new Map();
     setBotAndChatId(bot, chatId) {
         this.bot = bot;
         this.chatId = chatId;
@@ -85,6 +93,9 @@ class SummaryAggregator {
     setOnCost(callback) {
         this.onCostCallback = callback;
     }
+    setOnSubagent(callback) {
+        this.onSubagentCallback = callback;
+    }
     setOnSessionCompacted(callback) {
         this.onSessionCompactedCallback = callback;
     }
@@ -150,6 +161,10 @@ class SummaryAggregator {
             logger.debug(`[Aggregator] Session event: ${event.type}`, JSON.stringify(event.properties, null, 2));
         }
         switch (event.type) {
+            case "session.created":
+            case "session.updated":
+                this.handleSessionCreatedOrUpdated(event);
+                break;
             case "message.updated":
                 this.handleMessageUpdated(event);
                 break;
@@ -195,6 +210,7 @@ class SummaryAggregator {
         if (this.currentSessionId !== sessionId) {
             this.clear();
             this.currentSessionId = sessionId;
+            this.trackedSessionParents.set(sessionId, null);
         }
     }
     clear() {
@@ -206,6 +222,13 @@ class SummaryAggregator {
         this.knownTextPartIds.clear();
         this.processedToolStates.clear();
         this.thinkingFiredForMessages.clear();
+        this.trackedSessionParents.clear();
+        this.subagentStates.clear();
+        this.subagentOrder = [];
+        this.subagentCardIdBySessionId.clear();
+        this.pendingSubagentCardIdsByParent.clear();
+        this.pendingChildSessionIdsByParent.clear();
+        this.fallbackSubagentCardIdsByParent.clear();
         this.messageCount = 0;
         this.lastUpdated = 0;
         if (this.onClearedCallback) {
@@ -217,8 +240,362 @@ class SummaryAggregator {
             }
         }
     }
+    isTrackedChildSession(sessionId) {
+        return this.trackedSessionParents.has(sessionId) && sessionId !== this.currentSessionId;
+    }
+    getQueue(map, parentSessionId) {
+        const existing = map.get(parentSessionId);
+        if (existing) {
+            return existing;
+        }
+        const queue = [];
+        map.set(parentSessionId, queue);
+        return queue;
+    }
+    dequeue(map, parentSessionId) {
+        const queue = map.get(parentSessionId);
+        if (!queue || queue.length === 0) {
+            return undefined;
+        }
+        const value = queue.shift();
+        if (queue.length === 0) {
+            map.delete(parentSessionId);
+        }
+        return value;
+    }
+    removeFromQueue(map, parentSessionId, value) {
+        const queue = map.get(parentSessionId);
+        if (!queue) {
+            return;
+        }
+        const index = queue.indexOf(value);
+        if (index >= 0) {
+            queue.splice(index, 1);
+        }
+        if (queue.length === 0) {
+            map.delete(parentSessionId);
+        }
+    }
+    emitSubagentState() {
+        if (!this.currentSessionId || !this.onSubagentCallback || this.subagentOrder.length === 0) {
+            return;
+        }
+        const subagents = this.subagentOrder
+            .map((cardId) => this.subagentStates.get(cardId))
+            .filter((state) => Boolean(state))
+            .map((state) => ({
+            cardId: state.cardId,
+            sessionId: state.sessionId,
+            parentSessionId: state.parentSessionId,
+            agent: state.agent,
+            description: state.description,
+            prompt: state.prompt,
+            command: state.command,
+            status: state.status,
+            providerID: state.providerID,
+            modelID: state.modelID,
+            tokens: { ...state.tokens },
+            cost: state.cost,
+            currentTool: state.currentTool,
+            currentToolInput: state.currentToolInput ? { ...state.currentToolInput } : undefined,
+            currentToolTitle: state.currentToolTitle,
+            terminalMessage: state.terminalMessage,
+            updatedAt: state.updatedAt,
+        }));
+        this.onSubagentCallback(this.currentSessionId, subagents);
+    }
+    createSubagentState(parentSessionId, sessionId, cardId = `subagent-${parentSessionId}-${Date.now()}-${this.subagentOrder.length}`) {
+        const state = {
+            cardId,
+            sessionId,
+            parentSessionId,
+            agent: "",
+            description: "",
+            prompt: "",
+            status: "pending",
+            tokens: {
+                input: 0,
+                output: 0,
+                reasoning: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+            },
+            cost: 0,
+            terminalMessage: undefined,
+            updatedAt: Date.now(),
+            hasSubtaskMetadata: false,
+            hasTaskToolMetadata: false,
+            hasSessionTitleMetadata: false,
+            createdAt: Date.now(),
+        };
+        this.subagentStates.set(cardId, state);
+        this.subagentOrder.push(cardId);
+        if (sessionId) {
+            this.subagentCardIdBySessionId.set(sessionId, cardId);
+        }
+        return state;
+    }
+    enrichSubagentFromSubtask(state, details) {
+        state.agent = details.agent || state.agent;
+        state.description = details.description || details.prompt || state.description;
+        state.prompt = details.prompt;
+        state.command = details.command;
+        state.hasSubtaskMetadata = true;
+        state.updatedAt = Date.now();
+    }
+    enrichSubagentFromTaskTool(state, details) {
+        const nextDescription = details.description?.trim() || details.prompt?.trim();
+        if (details.agent?.trim()) {
+            state.agent = details.agent.trim();
+        }
+        if (nextDescription) {
+            state.description = nextDescription;
+        }
+        if (details.prompt?.trim()) {
+            state.prompt = details.prompt.trim();
+        }
+        if (details.command?.trim()) {
+            state.command = details.command.trim();
+        }
+        state.hasTaskToolMetadata = true;
+        state.updatedAt = Date.now();
+    }
+    enrichSubagentFromSessionTitle(state, title) {
+        const trimmedTitle = title?.trim();
+        if (!trimmedTitle) {
+            return;
+        }
+        const match = trimmedTitle.match(/^(.*?)(?:\s+\(@([^\s)]+)\s+subagent\))?$/i);
+        const rawDescription = match?.[1]?.trim() || trimmedTitle;
+        const rawAgent = match?.[2]?.trim();
+        if (rawDescription) {
+            state.description = rawDescription;
+        }
+        if (rawAgent) {
+            state.agent = rawAgent.replace(/^@/, "");
+        }
+        state.hasSessionTitleMetadata = true;
+        state.updatedAt = Date.now();
+    }
+    attachSessionToSubagent(cardId, sessionId) {
+        const state = this.subagentStates.get(cardId);
+        if (!state) {
+            return;
+        }
+        state.sessionId = sessionId;
+        state.updatedAt = Date.now();
+        this.subagentCardIdBySessionId.set(sessionId, cardId);
+        this.removeFromQueue(this.pendingSubagentCardIdsByParent, state.parentSessionId, cardId);
+    }
+    findPendingSubagentWithoutSession() {
+        for (const cardId of this.subagentOrder) {
+            const state = this.subagentStates.get(cardId);
+            if (state && !state.sessionId) {
+                return state;
+            }
+        }
+        return null;
+    }
+    attachUnknownSessionToPendingSubagent(sessionId) {
+        const pendingState = this.findPendingSubagentWithoutSession();
+        if (!pendingState) {
+            return false;
+        }
+        this.trackedSessionParents.set(sessionId, pendingState.parentSessionId);
+        this.attachSessionToSubagent(pendingState.cardId, sessionId);
+        this.removeFromQueue(this.pendingChildSessionIdsByParent, pendingState.parentSessionId, sessionId);
+        this.emitSubagentState();
+        return true;
+    }
+    findNextSubagentForTaskTool(parentSessionId) {
+        for (const cardId of this.subagentOrder) {
+            const state = this.subagentStates.get(cardId);
+            if (state && state.parentSessionId === parentSessionId && !state.hasTaskToolMetadata) {
+                return state;
+            }
+        }
+        return null;
+    }
+    updateSubagentFromTaskTool(parentSessionId, input) {
+        const subagent = this.findNextSubagentForTaskTool(parentSessionId);
+        if (!subagent || !input) {
+            return;
+        }
+        const description = typeof input.description === "string" ? input.description : undefined;
+        const prompt = typeof input.prompt === "string" ? input.prompt : undefined;
+        const agent = typeof input.subagent_type === "string" ? input.subagent_type : undefined;
+        const command = typeof input.command === "string" ? input.command : undefined;
+        if (!description && !prompt && !agent && !command) {
+            return;
+        }
+        this.enrichSubagentFromTaskTool(subagent, { agent, description, prompt, command });
+        this.emitSubagentState();
+    }
+    getOrCreateSubagentForSession(sessionId) {
+        const existingCardId = this.subagentCardIdBySessionId.get(sessionId);
+        if (existingCardId) {
+            return this.subagentStates.get(existingCardId);
+        }
+        const parentSessionId = this.trackedSessionParents.get(sessionId) ?? this.currentSessionId ?? sessionId;
+        this.removeFromQueue(this.pendingChildSessionIdsByParent, parentSessionId, sessionId);
+        const state = this.createSubagentState(parentSessionId, sessionId);
+        this.getQueue(this.fallbackSubagentCardIdsByParent, parentSessionId).push(state.cardId);
+        return state;
+    }
+    registerSubtaskPart(parentSessionId, partId, agent, description, prompt, command) {
+        const fallbackCardId = this.dequeue(this.fallbackSubagentCardIdsByParent, parentSessionId);
+        if (fallbackCardId) {
+            const fallbackState = this.subagentStates.get(fallbackCardId);
+            if (fallbackState) {
+                this.enrichSubagentFromSubtask(fallbackState, { agent, description, prompt, command });
+                this.emitSubagentState();
+                return;
+            }
+        }
+        const state = this.createSubagentState(parentSessionId, null, `subtask-${parentSessionId}-${partId}`);
+        this.enrichSubagentFromSubtask(state, { agent, description, prompt, command });
+        const pendingChildSessionId = this.dequeue(this.pendingChildSessionIdsByParent, parentSessionId);
+        if (pendingChildSessionId) {
+            this.attachSessionToSubagent(state.cardId, pendingChildSessionId);
+        }
+        else {
+            this.getQueue(this.pendingSubagentCardIdsByParent, parentSessionId).push(state.cardId);
+        }
+        this.emitSubagentState();
+    }
+    trackChildSession(sessionId, parentSessionId) {
+        this.trackedSessionParents.set(sessionId, parentSessionId);
+        const pendingCardId = this.dequeue(this.pendingSubagentCardIdsByParent, parentSessionId);
+        if (pendingCardId) {
+            this.attachSessionToSubagent(pendingCardId, sessionId);
+            this.emitSubagentState();
+            return;
+        }
+        this.getQueue(this.pendingChildSessionIdsByParent, parentSessionId).push(sessionId);
+    }
+    handleSessionCreatedOrUpdated(event) {
+        if (!this.currentSessionId) {
+            return;
+        }
+        const { info } = event.properties;
+        if (!info.parentID) {
+            return;
+        }
+        if (!this.trackedSessionParents.has(info.parentID)) {
+            return;
+        }
+        if (info.id === this.currentSessionId) {
+            return;
+        }
+        if (!this.trackedSessionParents.has(info.id)) {
+            this.trackChildSession(info.id, info.parentID);
+        }
+        const subagent = this.getOrCreateSubagentForSession(info.id);
+        this.enrichSubagentFromSessionTitle(subagent, info.title);
+        this.emitSubagentState();
+    }
+    updateSubagentFromAssistantMessage(info) {
+        const subagent = this.getOrCreateSubagentForSession(info.sessionID);
+        if (info.agent) {
+            subagent.agent = info.agent;
+        }
+        if (info.providerID) {
+            subagent.providerID = info.providerID;
+        }
+        if (info.modelID) {
+            subagent.modelID = info.modelID;
+        }
+        if (info.tokens) {
+            subagent.tokens = {
+                input: info.tokens.input,
+                output: info.tokens.output,
+                reasoning: info.tokens.reasoning,
+                cacheRead: info.tokens.cache?.read || 0,
+                cacheWrite: info.tokens.cache?.write || 0,
+            };
+        }
+        if (typeof info.cost === "number") {
+            subagent.cost = info.cost;
+        }
+        subagent.updatedAt = Date.now();
+        this.emitSubagentState();
+    }
+    updateSubagentToolState(sessionId, state, tool, input, title) {
+        const subagent = this.getOrCreateSubagentForSession(sessionId);
+        const status = "status" in state ? state.status : undefined;
+        if (status === "running") {
+            subagent.status = "running";
+            subagent.terminalMessage = undefined;
+        }
+        if (status === "pending" && subagent.status === "pending") {
+            subagent.status = "pending";
+            subagent.terminalMessage = undefined;
+        }
+        subagent.currentTool = tool;
+        subagent.currentToolInput = input ? { ...input } : undefined;
+        subagent.currentToolTitle = title;
+        subagent.updatedAt = Date.now();
+        this.emitSubagentState();
+    }
+    updateSubagentStepStart(sessionId, snapshot) {
+        const subagent = this.getOrCreateSubagentForSession(sessionId);
+        subagent.status = "running";
+        subagent.terminalMessage = undefined;
+        subagent.currentTool = undefined;
+        subagent.currentToolInput = undefined;
+        subagent.currentToolTitle = snapshot?.trim() || subagent.currentToolTitle;
+        subagent.updatedAt = Date.now();
+        this.emitSubagentState();
+    }
+    updateSubagentStepFinish(sessionId, tokens, cost, snapshot) {
+        const subagent = this.getOrCreateSubagentForSession(sessionId);
+        subagent.status = "running";
+        subagent.terminalMessage = undefined;
+        subagent.tokens = {
+            input: tokens.input,
+            output: tokens.output,
+            reasoning: tokens.reasoning,
+            cacheRead: tokens.cache.read,
+            cacheWrite: tokens.cache.write,
+        };
+        subagent.cost += cost;
+        if (snapshot?.trim()) {
+            subagent.currentToolTitle = snapshot.trim();
+        }
+        subagent.updatedAt = Date.now();
+        this.emitSubagentState();
+    }
+    setSubagentTerminalStatus(sessionId, status, terminalMessage) {
+        const cardId = this.subagentCardIdBySessionId.get(sessionId);
+        if (!cardId) {
+            return;
+        }
+        const subagent = this.subagentStates.get(cardId);
+        if (!subagent) {
+            return;
+        }
+        subagent.status = status;
+        subagent.currentTool = undefined;
+        subagent.currentToolInput = undefined;
+        subagent.currentToolTitle = undefined;
+        subagent.terminalMessage = terminalMessage?.trim() || undefined;
+        subagent.updatedAt = Date.now();
+        this.emitSubagentState();
+    }
     handleMessageUpdated(event) {
         const { info } = event.properties;
+        if (info.sessionID !== this.currentSessionId &&
+            !this.trackedSessionParents.has(info.sessionID) &&
+            info.role === "assistant") {
+            this.attachUnknownSessionToPendingSubagent(info.sessionID);
+        }
+        if (this.isTrackedChildSession(info.sessionID)) {
+            if (info.role === "assistant") {
+                const assistantInfo = info;
+                this.updateSubagentFromAssistantMessage(assistantInfo);
+            }
+            return;
+        }
         if (info.sessionID !== this.currentSessionId) {
             return;
         }
@@ -242,23 +619,24 @@ class SummaryAggregator {
             if (!isCompleted && textState.optimisticUpdateCount === 1) {
                 this.emitPartialText(info.sessionID, messageID, messageText);
             }
+            // Extract and report tokens for EVERY message.updated with token data
+            // (both intermediate and completed). This keeps keyboard context in sync.
+            const assistantInfo = info;
+            if (this.onTokensCallback && assistantInfo.tokens) {
+                const tokens = {
+                    input: assistantInfo.tokens.input,
+                    output: assistantInfo.tokens.output,
+                    reasoning: assistantInfo.tokens.reasoning,
+                    cacheRead: assistantInfo.tokens.cache?.read || 0,
+                    cacheWrite: assistantInfo.tokens.cache?.write || 0,
+                };
+                logger.debug(`[Aggregator] Tokens: input=${tokens.input}, output=${tokens.output}, reasoning=${tokens.reasoning}, cacheRead=${tokens.cacheRead}, cacheWrite=${tokens.cacheWrite}, completed=${isCompleted}`);
+                // Call synchronously so keyboardManager is updated before onComplete sends the reply
+                this.onTokensCallback(tokens, isCompleted);
+            }
             if (isCompleted) {
                 const finalText = messageText;
                 logger.debug(`[Aggregator] Message part completed: messageId=${messageID}, textLength=${finalText.length}, totalParts=${textState.orderedPartIds.length}, session=${this.currentSessionId}`);
-                // Extract and report tokens BEFORE onComplete so keyboard context is updated
-                const assistantInfo = info;
-                if (this.onTokensCallback && assistantInfo.tokens) {
-                    const tokens = {
-                        input: assistantInfo.tokens.input,
-                        output: assistantInfo.tokens.output,
-                        reasoning: assistantInfo.tokens.reasoning,
-                        cacheRead: assistantInfo.tokens.cache?.read || 0,
-                        cacheWrite: assistantInfo.tokens.cache?.write || 0,
-                    };
-                    logger.debug(`[Aggregator] Tokens: input=${tokens.input}, output=${tokens.output}, reasoning=${tokens.reasoning}`);
-                    // Call synchronously so keyboardManager is updated before onComplete sends the reply
-                    this.onTokensCallback(tokens);
-                }
                 // Extract and report cost
                 if (this.onCostCallback && assistantInfo.cost !== undefined) {
                     logger.debug(`[Aggregator] Cost: $${assistantInfo.cost.toFixed(2)}`);
@@ -282,7 +660,35 @@ class SummaryAggregator {
     }
     handleMessagePartUpdated(event) {
         const { part } = event.properties;
-        if (part.sessionID !== this.currentSessionId) {
+        if (part.sessionID !== this.currentSessionId &&
+            !this.trackedSessionParents.has(part.sessionID) &&
+            part.type !== "subtask") {
+            this.attachUnknownSessionToPendingSubagent(part.sessionID);
+        }
+        const isCurrentRootSession = part.sessionID === this.currentSessionId;
+        const isTrackedChildSession = this.isTrackedChildSession(part.sessionID);
+        if (!isCurrentRootSession && !isTrackedChildSession) {
+            return;
+        }
+        if (part.type === "subtask") {
+            this.registerSubtaskPart(part.sessionID, part.id, part.agent, part.description, part.prompt, part.command);
+            this.lastUpdated = Date.now();
+            return;
+        }
+        if (isTrackedChildSession) {
+            if (part.type === "tool") {
+                const state = part.state;
+                const input = "input" in state ? state.input : undefined;
+                const title = "title" in state ? state.title : undefined;
+                this.updateSubagentToolState(part.sessionID, state, part.tool, input, title);
+            }
+            if (part.type === "step-start") {
+                this.updateSubagentStepStart(part.sessionID, part.snapshot);
+            }
+            if (part.type === "step-finish") {
+                this.updateSubagentStepFinish(part.sessionID, part.tokens, part.cost, part.snapshot);
+            }
+            this.lastUpdated = Date.now();
             return;
         }
         const messageID = part.messageID;
@@ -337,6 +743,9 @@ class SummaryAggregator {
             const state = part.state;
             const input = "input" in state ? state.input : undefined;
             const title = "title" in state ? state.title : undefined;
+            if (part.tool === "task") {
+                this.updateSubagentFromTaskTool(part.sessionID, input);
+            }
             logger.debug(`[Aggregator] Tool event: callID=${part.callID}, tool=${part.tool}, status=${"status" in state ? state.status : "unknown"}`);
             if (part.tool === "question") {
                 logger.debug(`[Aggregator] Question tool part update:`, JSON.stringify(part, null, 2));
@@ -618,6 +1027,11 @@ class SummaryAggregator {
     }
     handleSessionIdle(event) {
         const { sessionID } = event.properties;
+        if (this.isTrackedChildSession(sessionID)) {
+            logger.info(`[Aggregator] Subagent session became idle: ${sessionID}`);
+            this.setSubagentTerminalStatus(sessionID, "completed");
+            return;
+        }
         if (sessionID !== this.currentSessionId) {
             return;
         }
@@ -644,10 +1058,15 @@ class SummaryAggregator {
     }
     handleSessionError(event) {
         const { sessionID, error } = event.properties;
+        const message = error?.data?.message || error?.message || error?.name || "Unknown session error";
+        if (sessionID && this.isTrackedChildSession(sessionID)) {
+            logger.warn(`[Aggregator] Subagent session error: ${sessionID}: ${message}`);
+            this.setSubagentTerminalStatus(sessionID, "error", message);
+            return;
+        }
         if (sessionID !== this.currentSessionId) {
             return;
         }
-        const message = error?.data?.message || error?.message || error?.name || "Unknown session error";
         logger.warn(`[Aggregator] Session error: ${sessionID}: ${message}`);
         this.stopTypingIndicator();
         if (this.onSessionErrorCallback) {