@sumicom/quicksave 0.8.9 → 0.8.11

package/dist/ai/cardBuilder.js

@@ -46,6 +46,47 @@ const TOOL_RESULT_TRUNCATE_LENGTH = 500;
 function cardHistoryPath(sessionId) {
     return join(getCardHistoryDir(), `${sessionId}.json`);
 }
+function cleanPersistedCard(card) {
+    const { pendingInput, ...rest } = card;
+    void pendingInput;
+    if (rest.type === 'assistant_text') {
+        return { ...rest, streaming: false };
+    }
+    return rest;
+}
+function mergeCardsById(existing, incoming) {
+    const byId = new Map();
+    for (const card of existing)
+        byId.set(card.id, card);
+    for (const card of incoming)
+        byId.set(card.id, card);
+    return sortCardsChronologically(Array.from(byId.values()));
+}
+function sortCardsChronologically(cards) {
+    return cards
+        .map((card, index) => ({ card, index }))
+        .sort((a, b) => {
+        const at = Number.isFinite(a.card.timestamp) ? a.card.timestamp : 0;
+        const bt = Number.isFinite(b.card.timestamp) ? b.card.timestamp : 0;
+        return at - bt || a.index - b.index;
+    })
+        .map(({ card }) => card);
+}
+function maxCardSequenceForSession(cards, sessionId) {
+    const prefix = `${sessionId}:`;
+    let max = 0;
+    for (const card of cards) {
+        if (!card.id.startsWith(prefix))
+            continue;
+        const raw = card.id.slice(prefix.length);
+        if (!/^\d+$/.test(raw))
+            continue;
+        const seq = Number(raw);
+        if (Number.isSafeInteger(seq) && seq > max)
+            max = seq;
+    }
+    return max;
+}
 /**
  * Load persisted card history for a memory-mode session.
  * Returns cards in insertion order, or empty array if none exist.
@@ -57,20 +98,20 @@ export async function loadPersistedCards(sessionId) {
     try {
         const raw = await readFile(p, 'utf-8');
         const data = JSON.parse(raw);
-        return Array.isArray(data) ? data : [];
+        return Array.isArray(data) ? sortCardsChronologically(data) : [];
     }
     catch {
         return [];
     }
 }
 // ── Direct JSONL file reading (replaces SDK getSessionMessages/listSubagents) ──
-function encodeCwdPath(cwd) {
+export function encodeCwdPath(cwd) {
     return cwd.replace(/\//g, '-');
 }
-function claudeProjectDir(cwd) {
+export function claudeProjectDir(cwd) {
     return join(homedir(), '.claude', 'projects', encodeCwdPath(cwd));
 }
-function jsonlPath(sessionId, cwd) {
+export function jsonlPath(sessionId, cwd) {
     return join(claudeProjectDir(cwd), sessionId + '.jsonl');
 }
 function parseJSONLContent(content) {
@@ -220,6 +261,58 @@ function extractToolResultText(content) {
     }
     return JSON.stringify(content);
 }
+/** Compact "1m 25s" / "45s" duration for the `text` fallback. The PWA renders
+ *  its own badge from `meta.durationMs`; this keeps debug logs and non-PWA
+ *  consumers readable. */
+export function formatDurationMs(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        return '0s';
+    const totalSec = Math.round(ms / 1000);
+    const m = Math.floor(totalSec / 60);
+    const s = totalSec % 60;
+    return m > 0 ? `${m}m ${s}s` : `${s}s`;
+}
+/** Build a structured `turn_duration` system card from a Claude JSONL entry. */
+export function turnDurationCard(msg, id) {
+    const durationMs = typeof msg.durationMs === 'number' ? msg.durationMs : 0;
+    const messageCount = typeof msg.messageCount === 'number' ? msg.messageCount : 0;
+    return {
+        type: 'system',
+        id,
+        timestamp: Date.now(),
+        text: `Turn: ${formatDurationMs(durationMs)} · ${messageCount} messages`,
+        subtype: 'info',
+        meta: { kind: 'turn_duration', durationMs, messageCount },
+    };
+}
+/** Build a structured `stop_hook_summary` system card from a Claude JSONL entry.
+ *  Flags as `warning` when any hook errored or blocked continuation — that's the
+ *  channel that surfaces hook misconfigs (e.g. a bad interpreter path). */
+export function stopHookSummaryCard(msg, id) {
+    const hooks = Array.isArray(msg.hookInfos)
+        ? msg.hookInfos.map((h) => ({
+            command: typeof h?.command === 'string' ? h.command : '',
+            durationMs: typeof h?.durationMs === 'number' ? h.durationMs : 0,
+        }))
+        : [];
+    const errors = Array.isArray(msg.hookErrors)
+        ? msg.hookErrors.filter((e) => typeof e === 'string')
+        : [];
+    const preventedContinuation = msg.preventedContinuation === true;
+    const level = typeof msg.level === 'string' ? msg.level : undefined;
+    const stopReason = typeof msg.stopReason === 'string' && msg.stopReason ? msg.stopReason : undefined;
+    const text = errors.length > 0
+        ? `Stop hook: ${hooks.length} ran, ${errors.length} error${errors.length > 1 ? 's' : ''}`
+        : `Stop hook: ${hooks.length} ran`;
+    return {
+        type: 'system',
+        id,
+        timestamp: Date.now(),
+        text,
+        subtype: errors.length > 0 || preventedContinuation ? 'warning' : 'info',
+        meta: { kind: 'stop_hook_summary', hooks, errors, level, preventedContinuation, stopReason },
+    };
+}
 // ============================================================================
 // StreamCardBuilder — streaming session, emits CardEvents
 // ============================================================================
@@ -234,6 +327,14 @@ export class StreamCardBuilder {
     agentIdToCardId = new Map();
     /** Cards created for subagent permissions — removed after resolution. */
     ephemeralCards = new Set();
+    /** Agent tool_use input stashed from assistant message, keyed by tool_use block.id.
+     *  Consumed when task_started arrives with the matching tool_use_id. */
+    agentToolUseStash = new Map();
+    /** Card ID of the currently running subagent; tool calls are nested here instead of
+     *  being emitted as top-level ToolCallCards. Cleared on task_notification. */
+    activeSubagentCardId = null;
+    /** Nested tool_use_id → subagentCardId — lets toolResult() route to the right card. */
+    nestedToolUseToSubagentCard = new Map();
     /** Current streaming assistant_text card (for append_text events) */
     currentTextCardId = null;
     /** JSONL file byte offset at the start of the current turn — history reads stop here. */
@@ -248,6 +349,13 @@ export class StreamCardBuilder {
     updateSessionId(sessionId) {
         this.sessionId = sessionId;
     }
+    /** Continue the local card id counter after persisted memory-mode history.
+     * Used on cold resume after daemon restart so new Codex/OpenCode cards
+     * append after existing cards instead of reusing `sessionId:1`, `:2`, ...
+     * and overwriting or reordering older history. */
+    seedSequenceFromCards(cards) {
+        this.seq = Math.max(this.seq, maxCardSequenceForSession(cards, this.sessionId));
+    }
     /** Start a new turn: reset per-turn state, keep accumulated cards. */
     startNewTurn() {
         this.currentTextCardId = null;
@@ -258,6 +366,9 @@ export class StreamCardBuilder {
         this.toolUseIdToCardId.clear();
         this.agentIdToCardId.clear();
         this.ephemeralCards.clear();
+        this.agentToolUseStash.clear();
+        this.activeSubagentCardId = null;
+        this.nestedToolUseToSubagentCard.clear();
         this.currentTextCardId = null;
     }
     /**
@@ -269,17 +380,20 @@ export class StreamCardBuilder {
         const cards = this.getCards();
         if (cards.length === 0)
             return;
-        // Strip transient fields before persisting
-        const cleaned = cards.map(c => {
-            const { pendingInput, ...rest } = c;
-            if (rest.type === 'assistant_text') {
-                return { ...rest, streaming: false };
-            }
-            return rest;
-        });
+        await this.persistCardBatch(cards);
+    }
+    /** Persist a single card immediately. Used when a memory-mode provider
+     * injects a user prompt into an already-running turn; the card must survive
+     * refresh before the turn's normal end-of-turn persist runs. */
+    async persistCard(card) {
+        await this.persistCardBatch([card]);
+    }
+    async persistCardBatch(cards) {
+        if (cards.length === 0)
+            return;
+        const cleaned = cards.map(cleanPersistedCard);
         const dir = getCardHistoryDir();
         const p = cardHistoryPath(this.sessionId);
-        // Append to existing history
         let existing = [];
         try {
             if (existsSync(p)) {
@@ -290,7 +404,7 @@ export class StreamCardBuilder {
             }
         }
         catch { /* start fresh */ }
-        const merged = [...existing, ...cleaned];
+        const merged = mergeCardsById(existing, cleaned);
         await mkdir(dir, { recursive: true });
         await writeFile(p, JSON.stringify(merged) + '\n');
     }
@@ -364,6 +478,9 @@ export class StreamCardBuilder {
         this.toolUseIdToCardId.clear();
         this.agentIdToCardId.clear();
         this.ephemeralCards.clear();
+        this.agentToolUseStash.clear();
+        this.activeSubagentCardId = null;
+        this.nestedToolUseToSubagentCard.clear();
         this.currentTextCardId = null;
     }
     /** Cancel any pending deferred clear. Called on hot resume so the queued clear
@@ -468,6 +585,15 @@ export class StreamCardBuilder {
      */
     toolUse(toolName, toolInput, toolUseId) {
         this.currentTextCardId = null;
+        // Route to active subagent: nest this tool call inside the SubagentCard
+        if (this.activeSubagentCardId) {
+            const subagentCard = this.cards.get(this.activeSubagentCardId);
+            if (subagentCard) {
+                const toolCalls = [...(subagentCard.toolCalls ?? []), { id: toolUseId, toolName, toolInput }];
+                this.nestedToolUseToSubagentCard.set(toolUseId, this.activeSubagentCardId);
+                return this.updateEvent(this.activeSubagentCardId, { toolCalls });
+            }
+        }
         // Check if card was pre-created from canUseTool
         const existingCardId = this.toolUseIdToCardId.get(toolUseId);
         if (existingCardId) {
@@ -551,6 +677,17 @@ export class StreamCardBuilder {
         return Array.from(this.cards.values());
     }
     toolResult(toolUseId, content, isError) {
+        // Route to active subagent's nested tool call
+        const subagentCardId = this.nestedToolUseToSubagentCard.get(toolUseId);
+        if (subagentCardId) {
+            const subagentCard = this.cards.get(subagentCardId);
+            if (!subagentCard?.toolCalls)
+                return null;
+            const truncated = content.length > TOOL_RESULT_TRUNCATE_LENGTH;
+            const resultContent = truncated ? content.slice(0, TOOL_RESULT_TRUNCATE_LENGTH) + ' [truncated]' : content;
+            const toolCalls = subagentCard.toolCalls.map(tc => tc.id === toolUseId ? { ...tc, result: { content: resultContent, isError } } : tc);
+            return this.updateEvent(subagentCardId, { toolCalls });
+        }
         const cardId = this.toolUseIdToCardId.get(toolUseId);
         if (!cardId)
             return null;
@@ -569,9 +706,19 @@ export class StreamCardBuilder {
             return null;
         return this.updateEvent(cardId, { answers });
     }
-    subagentStart(description, agentId, toolUseId) {
+    /** Stash Agent tool_use input fields for later use when task_started arrives. */
+    stashAgentToolUseInput(toolUseId, input) {
+        this.agentToolUseStash.set(toolUseId, input);
+    }
+    subagentStart(description, agentId, toolUseId, extras) {
         this.currentTextCardId = null;
         const id = this.nextId();
+        const stashed = toolUseId ? this.agentToolUseStash.get(toolUseId) : undefined;
+        if (toolUseId)
+            this.agentToolUseStash.delete(toolUseId);
+        const subagentType = stashed?.subagentType ?? extras?.subagentType;
+        const requestedModel = stashed?.requestedModel ?? extras?.requestedModel;
+        const prompt = extras?.prompt ?? stashed?.prompt;
         const card = {
             type: 'subagent', id, timestamp: Date.now(),
             description,
@@ -579,9 +726,12 @@ export class StreamCardBuilder {
             agentId,
             status: 'running',
             toolUseCount: 0,
+            ...(subagentType ? { subagentType } : {}),
+            ...(requestedModel ? { requestedModel } : {}),
+            ...(prompt ? { prompt } : {}),
         };
         this.agentIdToCardId.set(agentId, id);
-        // Position after the parent ToolCallCard if we have the toolUseId
+        this.activeSubagentCardId = id;
         const afterCardId = toolUseId ? this.toolUseIdToCardId.get(toolUseId) : undefined;
         return this.addEvent(card, afterCardId);
     }
@@ -602,12 +752,34 @@ export class StreamCardBuilder {
             ?? (toolUseId ? this.agentIdToCardId.get(toolUseId) : undefined);
         if (!cardId)
             return null;
+        if (cardId === this.activeSubagentCardId)
+            this.activeSubagentCardId = null;
         return this.updateEvent(cardId, { status, summary });
     }
     systemMessage(text, subtype) {
         const card = { type: 'system', id: this.nextId(), timestamp: Date.now(), text, subtype };
         return this.addEvent(card);
     }
+    /** Live structured `turn_duration` card — mirrors the history builder so a
+     *  reload renders identically. */
+    turnDuration(raw) {
+        return this.addEvent(turnDurationCard(raw, this.nextId()));
+    }
+    /** Live structured `stop_hook_summary` card — see history builder counterpart. */
+    stopHookSummary(raw) {
+        return this.addEvent(stopHookSummaryCard(raw, this.nextId()));
+    }
+    generatedImage(prompt, status, savedPath) {
+        const card = {
+            type: 'generated_image',
+            id: this.nextId(),
+            timestamp: Date.now(),
+            prompt,
+            status,
+            ...(savedPath ? { savedPath } : {}),
+        };
+        return this.addEvent(card);
+    }
     recoverySuggested(reason, action, label) {
         const card = {
             type: 'recovery_suggested',
@@ -623,6 +795,54 @@ export class StreamCardBuilder {
         return this.systemMessage(`Error: ${text}`, 'error');
     }
 }
+/** Read tool calls from a subagent's JSONL — used by buildCardsFromHistory to nest them. */
+async function readSubagentToolCalls(jsonlPath) {
+    try {
+        const content = await readFile(jsonlPath, 'utf-8');
+        const messages = parseJSONLContent(content);
+        const resultMap = new Map();
+        const toolCalls = [];
+        for (const msg of messages) {
+            const rawMsg = msg.message;
+            if (!Array.isArray(rawMsg?.content))
+                continue;
+            if (msg.type === 'user') {
+                for (const block of rawMsg.content) {
+                    if (block.type === 'tool_result' && block.tool_use_id) {
+                        const text = extractToolResultText(block.content);
+                        resultMap.set(block.tool_use_id, { content: text, isError: !!block.is_error });
+                    }
+                }
+            }
+            else if (msg.type === 'assistant') {
+                for (const block of rawMsg.content) {
+                    if (block.type === 'tool_use' && block.id && block.name !== 'Agent') {
+                        toolCalls.push({
+                            id: block.id,
+                            toolName: block.name,
+                            toolInput: typeof block.input === 'object' && block.input ? block.input : {},
+                        });
+                    }
+                }
+            }
+        }
+        // Attach results and apply truncation
+        for (const tc of toolCalls) {
+            const r = resultMap.get(tc.id);
+            if (r) {
+                const truncated = r.content.length > TOOL_RESULT_TRUNCATE_LENGTH;
+                tc.result = {
+                    content: truncated ? r.content.slice(0, TOOL_RESULT_TRUNCATE_LENGTH) + ' [truncated]' : r.content,
+                    isError: r.isError,
+                };
+            }
+        }
+        return toolCalls;
+    }
+    catch {
+        return [];
+    }
+}
 // ============================================================================
 // buildCardsFromHistory — convert JSONL history into Card[]
 // ============================================================================
@@ -682,7 +902,52 @@ export async function buildCardsFromHistory(sessionId, cwd, offset = 0, limit =
     // The Claude CLI stores this as `toolUseResult` at the message envelope
     // level, separate from the human-readable tool_result.content string.
     const askUserResults = new Map();
+    const taskStarts = new Map();
+    const taskProgress = new Map();
+    const taskEnds = new Map();
+    const taskKey = (agentId, toolUseId) => {
+        if (typeof toolUseId === 'string' && toolUseId.length > 0)
+            return toolUseId;
+        if (typeof agentId === 'string' && agentId.length > 0)
+            return agentId;
+        return null;
+    };
     for (const msg of allMessages) {
+        if (msg.type === 'system') {
+            const subtype = msg.subtype;
+            const key = taskKey(msg.task_id, msg.tool_use_id);
+            if (key && subtype === 'task_started') {
+                taskStarts.set(key, {
+                    description: typeof msg.description === 'string' ? msg.description : '',
+                    agentId: typeof msg.task_id === 'string' ? msg.task_id : key,
+                    toolUseId: typeof msg.tool_use_id === 'string' ? msg.tool_use_id : key,
+                    prompt: typeof msg.prompt === 'string' ? msg.prompt : undefined,
+                    subagentType: typeof msg.subagent_type === 'string'
+                        ? msg.subagent_type
+                        : typeof msg.subagentType === 'string'
+                            ? msg.subagentType
+                            : undefined,
+                    requestedModel: typeof msg.model === 'string'
+                        ? msg.model
+                        : typeof msg.requested_model === 'string'
+                            ? msg.requested_model
+                            : undefined,
+                });
+            }
+            else if (key && subtype === 'task_progress') {
+                taskProgress.set(key, {
+                    toolUseCount: typeof msg.usage?.tool_uses === 'number' ? msg.usage.tool_uses : undefined,
+                    lastToolName: typeof msg.last_tool_name === 'string' ? msg.last_tool_name : undefined,
+                });
+            }
+            else if (key && subtype === 'task_notification') {
+                const status = msg.status;
+                taskEnds.set(key, {
+                    status: status === 'failed' || status === 'stopped' ? status : 'completed',
+                    summary: typeof msg.summary === 'string' ? msg.summary : undefined,
+                });
+            }
+        }
         const rawMsg = msg.message;
         const toolUseResult = msg.toolUseResult;
         if (!Array.isArray(rawMsg?.content))
@@ -707,24 +972,32 @@ export async function buildCardsFromHistory(sessionId, cwd, offset = 0, limit =
     // System messages (task_started) are NOT reliably present in the JSONL.
     // Instead, read subagent meta.json files and match by description to the
     // Agent tool_use input.description.
-    // Build description → toolUseId map from Agent tool_use blocks
+    // Build description → toolUseId map and capture Agent tool_use input data
     const descToToolUseId = new Map();
+    const agentInputByToolUseId = new Map();
     for (const msg of allMessages) {
         const rawMsg = msg.message;
         if (!Array.isArray(rawMsg?.content))
             continue;
         for (const block of rawMsg.content) {
             if (block.type === 'tool_use' && block.name === 'Agent' && block.id) {
-                const desc = block.input?.description ?? '';
+                const input = block.input;
+                const desc = input?.description ?? '';
                 if (desc)
                     descToToolUseId.set(desc, block.id);
+                agentInputByToolUseId.set(block.id, {
+                    prompt: typeof input?.prompt === 'string' ? input.prompt : undefined,
+                    subagentType: typeof input?.subagent_type === 'string' ? input.subagent_type : undefined,
+                    requestedModel: typeof input?.model === 'string' ? input.model : undefined,
+                });
             }
         }
     }
+    const subagentsDir = join(claudeProjectDir(cwd), sessionId, 'subagents');
     const toolUseIdToAgentId = new Map();
+    const subagentToolCallsByToolUseId = new Map();
     try {
         const agentIds = await listSubagentIdsFromDisk(sessionId, cwd);
-        const subagentsDir = join(claudeProjectDir(cwd), sessionId, 'subagents');
         for (const agentId of agentIds) {
             try {
                 const meta = JSON.parse(await readFile(join(subagentsDir, `${agentId}.meta.json`), 'utf-8'));
@@ -740,6 +1013,12 @@ export async function buildCardsFromHistory(sessionId, cwd, offset = 0, limit =
                 toolUseIdToAgentId.set(toolUseId, toolUseId);
             }
         }
+        // Read each subagent's JSONL to extract nested tool calls
+        for (const [toolUseId, agentId] of toolUseIdToAgentId) {
+            const toolCalls = await readSubagentToolCalls(join(subagentsDir, `${agentId}.jsonl`));
+            if (toolCalls.length > 0)
+                subagentToolCallsByToolUseId.set(toolUseId, toolCalls);
+        }
     }
     catch {
         // No subagents or SDK error — fallback: agentId = toolUseId
@@ -765,12 +1044,54 @@ export async function buildCardsFromHistory(sessionId, cwd, offset = 0, limit =
     let seq = Math.max(0, total - offset - limit);
     const nextId = () => `${sessionId}:h:${++seq}`;
     const cards = [];
+    const emittedSubagentKeys = new Set();
+    const slicedAgentToolUseIds = new Set();
+    for (const msg of sliced) {
+        const rawMsg = msg.message;
+        if (!Array.isArray(rawMsg?.content))
+            continue;
+        for (const block of rawMsg.content) {
+            if (block.type === 'tool_use' && block.name === 'Agent' && block.id) {
+                slicedAgentToolUseIds.add(block.id);
+            }
+        }
+    }
+    const subagentCardFromTask = (task) => {
+        const key = task.toolUseId || task.agentId;
+        const end = taskEnds.get(key);
+        const progress = taskProgress.get(key);
+        return {
+            type: 'subagent',
+            id: nextId(),
+            timestamp: Date.now(),
+            description: task.description,
+            toolUseId: task.toolUseId,
+            agentId: task.agentId,
+            status: end?.status ?? 'running',
+            ...(end?.summary ? { summary: end.summary } : {}),
+            toolUseCount: progress?.toolUseCount ?? 0,
+            ...(progress?.lastToolName ? { lastToolName: progress.lastToolName } : {}),
+            ...(task.prompt ? { prompt: task.prompt } : {}),
+            ...(task.subagentType ? { subagentType: task.subagentType } : {}),
+            ...(task.requestedModel ? { requestedModel: task.requestedModel } : {}),
+        };
+    };
     for (const msg of sliced) {
         // ── System messages ──
         if (msg.type === 'system') {
             const subtype = msg.subtype;
-            // Skip subagent lifecycle events (handled via subagentCards below)
-            if (subtype === 'task_started' || subtype === 'task_progress' || subtype === 'task_notification')
+            const key = taskKey(msg.task_id, msg.tool_use_id);
+            if (subtype === 'task_started' && key) {
+                const task = taskStarts.get(key);
+                if (task && !slicedAgentToolUseIds.has(task.toolUseId) && !emittedSubagentKeys.has(key)) {
+                    cards.push(subagentCardFromTask(task));
+                    emittedSubagentKeys.add(key);
+                }
+                continue;
+            }
+            // Progress/end task events update the task_started card; they do not
+            // render as standalone history cards.
+            if (subtype === 'task_progress' || subtype === 'task_notification')
                 continue;
             // Skip init and status messages (not useful in history)
             if (subtype === 'init' || subtype === 'status' || subtype === 'session_state_changed')
@@ -778,6 +1099,12 @@ export async function buildCardsFromHistory(sessionId, cwd, offset = 0, limit =
             if (subtype === 'compact_boundary') {
                 cards.push({ type: 'system', id: nextId(), timestamp: Date.now(), text: 'Context compacted', subtype: 'compacted' });
             }
+            else if (subtype === 'turn_duration') {
+                cards.push(turnDurationCard(msg, nextId()));
+            }
+            else if (subtype === 'stop_hook_summary') {
+                cards.push(stopHookSummaryCard(msg, nextId()));
+            }
             else {
                 // Unknown system subtype — show as info
                 cards.push({ type: 'system', id: nextId(), timestamp: Date.now(), text: subtype ?? 'System event', subtype: 'info' });
@@ -901,12 +1228,17 @@ export async function buildCardsFromHistory(sessionId, cwd, offset = 0, limit =
                         break;
                     case 'tool_use': {
                         if (agentToolUseIds.has(block.id)) {
-                            // Agent tool_use → create a ToolCallCard as anchor, then SubagentCard
+                            // Agent tool_use → SubagentCard
                             const agentId = toolUseIdToAgentId.get(block.id) ?? block.id;
                             const result = toolResults.get(block.id);
                             const description = block.input?.description ?? '';
                             const summary = result ? result.content.slice(0, 200) : undefined;
-                            // Insert SubagentCard
+                            const agentInput = agentInputByToolUseId.get(block.id);
+                            const taskStart = taskStarts.get(block.id);
+                            const progress = taskProgress.get(block.id);
+                            const end = taskEnds.get(block.id);
+                            const prompt = agentInput?.prompt ?? taskStart?.prompt;
+                            const nestedToolCalls = subagentToolCallsByToolUseId.get(block.id);
                             const subagentCard = {
                                 type: 'subagent',
                                 id: nextId(),
@@ -914,11 +1246,17 @@ export async function buildCardsFromHistory(sessionId, cwd, offset = 0, limit =
                                 description,
                                 toolUseId: block.id,
                                 agentId,
-                                status: result ? 'completed' : 'running',
-                                summary,
-                                toolUseCount: 0,
+                                status: end?.status ?? (result ? 'completed' : 'running'),
+                                summary: end?.summary ?? summary,
+                                toolUseCount: progress?.toolUseCount ?? nestedToolCalls?.length ?? 0,
+                                ...(progress?.lastToolName ? { lastToolName: progress.lastToolName } : {}),
+                                ...(agentInput?.subagentType ? { subagentType: agentInput.subagentType } : {}),
+                                ...(agentInput?.requestedModel ? { requestedModel: agentInput.requestedModel } : {}),
+                                ...(prompt ? { prompt } : {}),
+                                ...(nestedToolCalls?.length ? { toolCalls: nestedToolCalls } : {}),
                             };
                             cards.push(subagentCard);
+                            emittedSubagentKeys.add(block.id);
                         }
                         else {
                             // Normal tool call