@cloudcli-ai/cloudcli 1.37.3 → 1.37.4

package/dist-server/server/modules/providers/list/claude/claude-sessions.provider.js

@@ -3,16 +3,31 @@ import fsp from 'node:fs/promises';
 import path from 'node:path';
 import readline from 'node:readline';
 import { parseFilesInputTag } from '../../../../shared/image-attachments.js';
-import { prepareTranscriptMessages } from '../../../../shared/message-unification.js';
-import { createNormalizedMessage, generateMessageId, readObjectRecord, sliceTailPage, truncateSubagentActivity, } from '../../../../shared/utils.js';
+import { prepareTranscriptMessages, truncateNestedOutput } from '../../../../shared/message-unification.js';
+import { createNormalizedMessage, generateMessageId, isPlaceholderProviderModel, readObjectRecord, sliceTailPage, stripAnsiSequences, truncateSubagentActivity, } from '../../../../shared/utils.js';
 import { sessionsDb } from '../../../../modules/database/index.js';
+import { getClaudeSDKSessionStartTime } from '../../../../modules/providers/list/claude/claude-runtime.provider.js';
 import { summarizeClaudeTokenUsage } from '../../../../modules/providers/services/provider-token-usage.service.js';
 const PROVIDER = 'claude';
+/** Tokens the way the CLI writes them: 725k rather than 724,871. */
+const formatTokenCount = (tokens) => {
+    if (tokens >= 1_000_000) {
+        return `${(tokens / 1_000_000).toFixed(1)}M`;
+    }
+    return tokens >= 1_000 ? `${Math.round(tokens / 1_000)}k` : `${tokens}`;
+};
+/** A duration the way the CLI writes one: `2m 22s`. */
+const formatDuration = (milliseconds) => {
+    const seconds = Math.round(milliseconds / 1_000);
+    return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+};
 /**
  * Upper bound on how much of a subagent's timeline is sent to the client. A
  * long-running agent can record hundreds of tool calls, and the transcript only
  * ever shows them behind a collapsed header, so shipping the whole history on
- * every load costs far more than it shows.
+ * every load costs far more than it shows. The newest steps are the ones
+ * kept: a running agent's timeline is polled for what it is doing now, and
+ * the card says how many earlier ones were left out.
  */
 const MAX_TRANSMITTED_SUBAGENT_ACTIVITIES = 200;
 /**
@@ -24,7 +39,7 @@ const MAX_TRANSMITTED_SUBAGENT_ACTIVITIES = 200;
  */
 async function readClaudeSubagentTranscript(filePath) {
     const activity = [];
-    const transcript = { activity, endedMidToolCall: false };
+    const transcript = { activity };
     const toolsById = new Map();
     try {
         const fileStream = fs.createReadStream(filePath);
@@ -39,6 +54,9 @@ async function readClaudeSubagentTranscript(filePath) {
             try {
                 const entry = JSON.parse(line);
                 const timestamp = typeof entry.timestamp === 'string' ? entry.timestamp : undefined;
+                if (timestamp && !transcript.startedAt) {
+                    transcript.startedAt = timestamp;
+                }
                 if (entry.message?.role === 'assistant' && Array.isArray(entry.message?.content)) {
                     if (typeof entry.message.model === 'string') {
                         transcript.model = entry.message.model;
@@ -98,8 +116,6 @@ async function readClaudeSubagentTranscript(filePath) {
         const message = error instanceof Error ? error.message : String(error);
         console.warn(`Error parsing agent file ${filePath}:`, message);
     }
-    const lastActivity = activity[activity.length - 1];
-    transcript.endedMidToolCall = lastActivity?.kind === 'tool' && !lastActivity.toolResult;
     return transcript;
 }
 /** Reads the sidecar `.meta.json` Claude writes next to a subagent transcript. */
@@ -140,13 +156,122 @@ async function findClaudeSubagentTranscript(projectDirectory, providerSessionId,
     }
     return null;
 }
+/**
+ * Reads which agents a workflow run spawned and how far each got.
+ *
+ * The run appends one record per event to `<transcriptDir>/journal.jsonl`:
+ * `started` names the agent (and the label and phase the script gave it, when
+ * it gave any), `result` and `failed` settle it. The journal is what the
+ * workflow itself resumes from, so it is the only record of an agent that is
+ * still running — its transcript file is written, but nothing in it says the
+ * agent is not done. A missing directory or journal means the run left no
+ * record here (a fork copies only the parent's transcript), which reads as no
+ * agents rather than an error.
+ */
+async function readWorkflowJournal(transcriptDir) {
+    const agentsById = new Map();
+    let journal;
+    try {
+        journal = await fsp.readFile(path.join(transcriptDir, 'journal.jsonl'), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    for (const line of journal.split('\n')) {
+        if (!line.trim()) {
+            continue;
+        }
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            // The workflow appends while this reads, so the last line can be partial.
+            continue;
+        }
+        const agentId = typeof entry.agentId === 'string' ? entry.agentId : '';
+        if (!agentId) {
+            continue;
+        }
+        if (entry.type === 'started') {
+            agentsById.set(agentId, {
+                id: agentId,
+                label: typeof entry.label === 'string' ? entry.label : undefined,
+                phase: typeof entry.phase === 'string' ? entry.phase : undefined,
+                status: 'running',
+            });
+            continue;
+        }
+        const agent = agentsById.get(agentId);
+        if (!agent) {
+            continue;
+        }
+        if (entry.type === 'result') {
+            agent.status = 'completed';
+        }
+        else if (entry.type === 'failed') {
+            agent.status = 'failed';
+        }
+    }
+    return [...agentsById.values()];
+}
+function readBackgroundLaunch(toolUseResult) {
+    const result = readObjectRecord(toolUseResult);
+    if (!result) {
+        return null;
+    }
+    if (result.agentId) {
+        return 'agent';
+    }
+    if (result.status === 'async_launched') {
+        return 'workflow';
+    }
+    if (typeof result.backgroundTaskId === 'string' && result.backgroundTaskId) {
+        return 'bash';
+    }
+    return null;
+}
 function readTaggedValue(content, tagName) {
     const match = new RegExp(`<${tagName}>([\\s\\S]*?)<\\/${tagName}>`).exec(content);
     return match ? match[1].trim() : '';
 }
 /**
- * Collects every `<task-notification>` turn keyed by the tool call that
- * spawned the agent it reports on.
+ * Reads every `<task-notification>` payload one transcript row carries.
+ *
+ * Claude writes the same completion report in two shapes, and which one you get
+ * depends only on when the agent happened to finish:
+ *
+ * - as an ordinary user-role turn, when the queued notification is delivered
+ *   between turns (the harness also logs a contentless `dequeue` for it);
+ * - as a top-level `queue-operation` record whose `content` holds the payload,
+ *   when the harness consumes it inline while the parent turn is still running
+ *   (`remove`), or when the session ends before it is ever delivered
+ *   (`enqueue`).
+ *
+ * The operation names the queue's bookkeeping, not whether the agent finished,
+ * so every queue-operation payload counts. Reading only the user-role shape
+ * loses the majority of them: across the 919 transcripts this was measured on,
+ * 31 of 56 background agent launches report *only* through a queue-operation
+ * record, and their result and status were invisible to every consumer.
+ */
+function readTaskNotificationTexts(message) {
+    if (message.type === 'queue-operation') {
+        return typeof message.content === 'string' ? [message.content] : [];
+    }
+    if (message.message?.role !== 'user') {
+        return [];
+    }
+    const content = message.message.content;
+    if (typeof content === 'string') {
+        return [content];
+    }
+    return Array.isArray(content)
+        ? content.filter((part) => part?.type === 'text').map((part) => String(part.text ?? ''))
+        : [];
+}
+/**
+ * Collects every `<task-notification>` keyed by the tool call that spawned the
+ * agent it reports on.
  *
  * Only notifications that name a tool-use id are collected: without one there
  * is no card to fold them into, and they must keep rendering on their own.
@@ -154,16 +279,7 @@ function readTaggedValue(content, tagName) {
 function collectTaskNotifications(messages) {
     const notifications = new Map();
     for (const message of messages) {
-        if (message.message?.role !== 'user') {
-            continue;
-        }
-        const content = message.message.content;
-        const texts = typeof content === 'string'
-            ? [content]
-            : Array.isArray(content)
-                ? content.filter((part) => part?.type === 'text').map((part) => String(part.text ?? ''))
-                : [];
-        for (const text of texts) {
+        for (const text of readTaskNotificationTexts(message)) {
             if (!text.trimStart().startsWith('<task-notification>')) {
                 continue;
             }
@@ -171,9 +287,14 @@ function collectTaskNotifications(messages) {
             if (!toolUseId) {
                 continue;
             }
-            // A resumed agent notifies more than once; the last word wins.
+            // A resumed agent notifies more than once; the last word wins, and the
+            // rows that carried the earlier words go with it.
+            const sourceUuids = notifications.get(toolUseId)?.sourceUuids ?? [];
+            if (typeof message.uuid === 'string' && message.uuid) {
+                sourceUuids.push(message.uuid);
+            }
             notifications.set(toolUseId, {
-                sourceUuid: String(message.uuid ?? ''),
+                sourceUuids,
                 toolUseId,
                 status: readTaggedValue(text, 'status') || 'completed',
                 summary: readTaggedValue(text, 'summary'),
@@ -183,8 +304,8 @@ function collectTaskNotifications(messages) {
     }
     return notifications;
 }
-/** Reads the `tool_use_id` off the tool-result row that launched an agent. */
-function readAgentToolUseId(message) {
+/** Reads the `tool_use_id` off the tool-result row that launched background work. */
+function readLaunchToolUseId(message) {
     const content = message.message?.content;
     if (!Array.isArray(content)) {
         return null;
@@ -196,8 +317,8 @@ function readAgentToolUseId(message) {
     }
     return null;
 }
-/** Swaps an agent launch acknowledgement for the agent's actual answer. */
-function replaceAgentToolResultContent(message, replacement) {
+/** Swaps a launch acknowledgement for the work's actual answer. */
+function replaceLaunchToolResultContent(message, replacement) {
     const content = message.message?.content;
     if (!Array.isArray(content)) {
         return;
@@ -247,12 +368,111 @@ function isUserPromptRow(row) {
     return typeof content === 'string' && content.length > 0;
 }
 /**
- * Drops the rows belonging to prompts that were replaced by an edit.
+ * Returns the uuids on the chain the next `claude --resume` replays, from the
+ * leaf it continues from back to the root.
+ *
+ * Mirrors the transcript loader of the Claude CLI, which the Agent SDK's
+ * `resume` spawns as well. Every CLI process stamps a `last-prompt` row naming
+ * the leaf it was on when it exits, so with two writers on one session it is
+ * that stamp — not the newest row — that decides which branch is replayed. The
+ * newest conversation row only takes over when it descends from the stamped
+ * leaf (the stamping process kept going), or when the file carries no stamp.
+ * A compact boundary clears the stamp, and `progress` rows are skipped over
+ * when linking a row to its parent, as the CLI does.
+ */
+function resolveResumePath(rows) {
+    const conversation = new Map();
+    const progressParents = new Map();
+    const parentOf = (row) => {
+        const parentUuid = typeof row.parentUuid === 'string' ? row.parentUuid : undefined;
+        if (parentUuid && progressParents.has(parentUuid)) {
+            return progressParents.get(parentUuid) ?? undefined;
+        }
+        return parentUuid;
+    };
+    let newestRow;
+    let stampedLeaf;
+    let stampIsExplicit = false;
+    for (const row of rows) {
+        if (row.type === 'progress' && typeof row.uuid === 'string') {
+            progressParents.set(row.uuid, parentOf(row) ?? null);
+            continue;
+        }
+        if (typeof row.uuid === 'string'
+            && (row.type === 'user' || row.type === 'assistant' || row.type === 'attachment' || row.type === 'system')) {
+            conversation.set(row.uuid, row);
+            if (row.isSidechain !== true) {
+                newestRow = row.uuid;
+                stampIsExplicit = false;
+            }
+            if (row.type === 'system' && row.subtype === 'compact_boundary') {
+                stampedLeaf = undefined;
+                stampIsExplicit = false;
+            }
+        }
+        else if (row.type === 'last-prompt' && typeof row.leafUuid === 'string' && row.leafUuid) {
+            stampIsExplicit = row.explicit === true || (stampIsExplicit && row.leafUuid === stampedLeaf);
+            stampedLeaf = row.leafUuid;
+        }
+    }
+    const chainFrom = (leaf) => {
+        const chain = [];
+        const seen = new Set();
+        let cursor = leaf;
+        while (cursor && conversation.has(cursor) && !seen.has(cursor)) {
+            seen.add(cursor);
+            chain.push(cursor);
+            cursor = parentOf(conversation.get(cursor));
+        }
+        return chain;
+    };
+    let leaf = stampedLeaf && conversation.has(stampedLeaf) ? stampedLeaf : undefined;
+    if (leaf && !stampIsExplicit && newestRow && newestRow !== leaf && chainFrom(newestRow).includes(leaf)) {
+        leaf = newestRow;
+    }
+    return new Set(chainFrom(leaf ?? newestRow));
+}
+/**
+ * Maps each row's uuid to the file position of the newest row in its subtree.
+ *
+ * The transcript is append-only and a child is always written after its
+ * parent, so one backward pass hands every row's position to its parent and
+ * each uuid ends up holding the position of the last line its branch grew.
+ * Rows after a compact boundary do not link back across it, so this only
+ * orders branches within one compaction segment.
+ */
+function indexNewestRowPerBranch(rows) {
+    const newestByUuid = new Map();
+    for (let index = rows.length - 1; index >= 0; index -= 1) {
+        const row = rows[index];
+        if (typeof row.uuid !== 'string') {
+            continue;
+        }
+        const newest = newestByUuid.get(row.uuid) ?? index;
+        newestByUuid.set(row.uuid, newest);
+        if (typeof row.parentUuid === 'string' && (newestByUuid.get(row.parentUuid) ?? -1) < newest) {
+            newestByUuid.set(row.parentUuid, newest);
+        }
+    }
+    return newestByUuid;
+}
+/**
+ * Drops the rows belonging to prompts the next resume will not replay.
  *
  * When a message is edited, Claude resumes the conversation partway and appends
  * the replacement, so two prompts end up sharing one parent and the file holds
  * both the abandoned attempt and the live one. A flat read would show them
- * stacked, which reads as the app having sent the message twice.
+ * stacked, which reads as the app having sent the message twice. The same shape
+ * appears without an edit when a session is driven from Chat and from the
+ * native `claude` CLI at once: both writers branch off the row each of them saw
+ * last.
+ *
+ * Which sibling survives is decided by the branch the runtime will actually
+ * resume: the sibling on the chain `resolveResumePath` returns. Going by the
+ * newest prompt, or by the newest row, would show a branch the model was never
+ * sent whenever the two writers exit in a different order than they wrote. A
+ * fork that is not on that chain at all (one made before a compaction) keeps
+ * the branch that was appended to last.
  *
  * Only sibling *prompts* are treated as a fork. Branch points made by parallel
  * tool calls are extremely common — one assistant turn writes several chained
@@ -273,15 +493,29 @@ function dropSupersededPromptBranches(rows) {
             promptSiblings.set(row.parentUuid, [row]);
         }
     }
+    const forks = [...promptSiblings.values()].filter((siblings) => siblings.length > 1);
+    if (forks.length === 0) {
+        return rows;
+    }
+    const resumePath = resolveResumePath(rows);
+    let newestByUuid;
+    const newestRowOf = (row) => {
+        newestByUuid ??= indexNewestRowPerBranch(rows);
+        return typeof row.uuid === 'string' ? newestByUuid.get(row.uuid) ?? -1 : -1;
+    };
     const supersededRoots = new Set();
-    for (const siblings of promptSiblings.values()) {
-        if (siblings.length < 2) {
-            continue;
+    for (const siblings of forks) {
+        let live = siblings.find((row) => typeof row.uuid === 'string' && resumePath.has(row.uuid));
+        if (!live) {
+            live = siblings[0];
+            for (const row of siblings) {
+                if (newestRowOf(row) > newestRowOf(live)) {
+                    live = row;
+                }
+            }
         }
-        // The transcript is append-only, so the last prompt written under a parent
-        // is the one that replaced the others.
-        for (const row of siblings.slice(0, -1)) {
-            if (typeof row.uuid === 'string') {
+        for (const row of siblings) {
+            if (row !== live && typeof row.uuid === 'string') {
                 supersededRoots.add(row.uuid);
             }
         }
@@ -299,7 +533,7 @@ function dropSupersededPromptBranches(rows) {
     }
     return rows.filter((row) => typeof row.uuid !== 'string' || !abandoned.has(row.uuid));
 }
-async function getSessionMessages(sessionId, providerSessionId, limit, offset) {
+async function getSessionMessages(sessionId, providerSessionId, limit, offset, getLiveRunStartTime) {
     try {
         // The DB row is keyed by the app-facing session id, while the JSONL rows
         // on disk carry the provider-native id — both ids are needed here.
@@ -317,7 +551,8 @@ async function getSessionMessages(sessionId, providerSessionId, limit, offset) {
             }
         }
         // Read each spawned agent's own transcript once, then hang it off every
-        // row that references it.
+        // row that references it. Status is not part of this: the transcript
+        // cannot say whether the agent finished (see the loop below).
         const subagentsById = new Map();
         for (const agentId of agentIds) {
             const located = await findClaudeSubagentTranscript(projectDir, providerSessionId, agentId);
@@ -329,9 +564,8 @@ async function getSessionMessages(sessionId, providerSessionId, limit, offset) {
                 readClaudeSubagentMeta(located.metaPath),
             ]);
             subagentsById.set(agentId, {
-                endedMidToolCall: transcript.endedMidToolCall,
                 activity: transcript.activity
-                    .slice(0, MAX_TRANSMITTED_SUBAGENT_ACTIVITIES)
+                    .slice(-MAX_TRANSMITTED_SUBAGENT_ACTIVITIES)
                     .map(truncateSubagentActivity),
                 info: {
                     id: agentId,
@@ -339,58 +573,146 @@ async function getSessionMessages(sessionId, providerSessionId, limit, offset) {
                     type: meta.agentType,
                     description: meta.description,
                     model: transcript.model,
-                    status: 'completed',
                     activityCount: transcript.activity.length,
                 },
             });
         }
-        // An async agent's launch result is internal bookkeeping ("Async agent
-        // launched successfully…"); its real answer arrives later as a separate
-        // `<task-notification>` turn. Folding the notification back onto the tool
-        // call that started the agent keeps one card per agent instead of a card,
-        // an unrelated status line, and a stray markdown reply.
+        // Read each workflow run's journal once, keyed by the directory the launch
+        // row names. The journal is the only thing that says which of a run's
+        // agents are still going — see `readWorkflowJournal`.
+        const workflowAgentsByDir = new Map();
+        for (const message of messages) {
+            const transcriptDir = message.toolUseResult?.transcriptDir;
+            if (readBackgroundLaunch(message.toolUseResult) === 'workflow'
+                && typeof transcriptDir === 'string'
+                && transcriptDir
+                && !workflowAgentsByDir.has(transcriptDir)) {
+                workflowAgentsByDir.set(transcriptDir, await readWorkflowJournal(transcriptDir));
+            }
+        }
+        // A background launch's tool result is internal bookkeeping ("Async agent
+        // launched successfully…", "Workflow launched in background. Task ID: …",
+        // "Command running in background with ID: …"); its real answer arrives
+        // later as a separate `<task-notification>` turn. Folding the notification
+        // back onto the tool call that started the work keeps one card per launch
+        // instead of a card, an unrelated status line, and a stray markdown reply.
+        // Reading only rows with an `agentId` left a workflow's card on its launch
+        // acknowledgement forever, with its report rendering as a raw user bubble
+        // further down or, for a queue-operation record, nowhere at all.
         const notificationsByToolUseId = collectTaskNotifications(messages);
         const foldedNotificationUuids = new Set();
+        // A background agent runs inside the CLI process that launched it, so once
+        // that process is gone an agent that has not reported back never will. A
+        // later run of the same session is a new process, so a launch row older
+        // than the live run belongs to a process that has already exited. The
+        // runtime keys its process map by the app session id when the chat gateway
+        // starts a run and by the provider-native id when the agent API does, so
+        // both are asked.
+        const liveRunStartedAt = getLiveRunStartTime(sessionId) ?? getLiveRunStartTime(providerSessionId);
+        const launchedByLiveRun = (message) => liveRunStartedAt !== null && Date.parse(String(message.timestamp ?? '')) >= liveRunStartedAt;
         for (const message of messages) {
-            const agentId = message.toolUseResult?.agentId;
-            if (!agentId) {
+            const launch = readBackgroundLaunch(message.toolUseResult);
+            if (!launch) {
                 continue;
             }
-            const subagent = subagentsById.get(String(agentId));
-            const toolUseId = readAgentToolUseId(message);
+            const toolUseId = readLaunchToolUseId(message);
             const notification = toolUseId ? notificationsByToolUseId.get(toolUseId) : undefined;
-            // An async agent's launch row never tells you it finished — only the
-            // later notification does. When that notification is missing (a live run,
-            // or one compacted out of the transcript), the agent's own transcript is
-            // the evidence: a timeline that does not stop mid-tool-call is done.
-            const isAwaitingAsyncAgent = message.toolUseResult?.isAsync === true
-                && !notification
-                && (!subagent || subagent.endedMidToolCall);
-            if (subagent) {
-                if (subagent.activity.length > 0) {
+            // A workflow and a backgrounded shell command have no foreground form;
+            // only an agent can hand its answer back inline.
+            const isAsyncLaunch = launch !== 'agent' || message.toolUseResult?.isAsync === true;
+            // An async launch row never tells you it finished — only the later
+            // notification does, so a missing notification means the outcome is
+            // still unknown.
+            //
+            // The agent's own transcript cannot stand in for that. A background agent
+            // routinely ends its turn cleanly while its work is still outstanding: it
+            // replies "I've started that, waiting for it to finish" and stops, or it
+            // has live background children of its own, which is precisely when the
+            // harness holds the notification back. Treating a cleanly-ended timeline
+            // as proof of completion therefore marked every background agent
+            // `completed` the moment it launched, collapsing its card and dropping
+            // its spinner while it was still working.
+            //
+            // "Unknown" only means "still outstanding" while the process the agent
+            // runs in is alive. Once it is gone — the run was stopped or crashed, or
+            // this transcript is a fork, which copies the parent's conversation rows
+            // but not its agent files or queue-operation records — nothing can still
+            // report, and reading that as `running` pinned a spinner on the card
+            // forever.
+            //
+            // A synchronous agent hands its answer back inline on its own tool
+            // result, so its status never depends on a notification or the process.
+            const unreportedStatus = isAsyncLaunch
+                ? launchedByLiveRun(message) ? 'running' : 'stopped'
+                : 'completed';
+            if (launch === 'agent') {
+                const agentId = String(message.toolUseResult.agentId);
+                const subagent = subagentsById.get(agentId);
+                const status = notification
+                    ? notification.status === 'completed' ? 'completed' : 'failed'
+                    : unreportedStatus;
+                if (subagent && subagent.activity.length > 0) {
                     message.subagentTools = subagent.activity;
                 }
+                // The agent's own transcript names its type, model and timeline, but
+                // it is not what says whether the agent finished, and it can be
+                // missing — a fork copies only the parent's `.jsonl`. The card reads
+                // its status off `subagent`, so the launch row publishes one with or
+                // without it; otherwise a notification saying "completed" left the
+                // card `running`.
                 message.subagent = {
-                    ...subagent.info,
-                    description: subagent.info.description
+                    id: agentId,
+                    ...subagent?.info,
+                    description: subagent?.info.description
                         ?? (typeof message.toolUseResult?.description === 'string' ? message.toolUseResult.description : undefined),
-                    model: subagent.info.model
+                    model: subagent?.info.model
                         ?? (typeof message.toolUseResult?.resolvedModel === 'string' ? message.toolUseResult.resolvedModel : undefined),
-                    status: isAwaitingAsyncAgent
-                        ? 'running'
-                        : notification && notification.status !== 'completed'
-                            ? 'failed'
-                            : 'completed',
+                    status,
+                };
+            }
+            else if (launch === 'workflow') {
+                // The notification's own word is kept here, `stopped` included: a
+                // workflow the user stopped is not one that failed.
+                const status = notification
+                    ? notification.status === 'completed' || notification.status === 'stopped' ? notification.status : 'failed'
+                    : unreportedStatus;
+                // The journal marks an agent `started` and later `result`/`failed`.
+                // Once the run itself has settled, a `started` with no second record
+                // is not still going: the run was stopped under it, or a resume re-ran
+                // the step under a new id. Drawing those as running put a pulsing dot
+                // on a finished card.
+                const agents = (workflowAgentsByDir.get(String(message.toolUseResult.transcriptDir ?? '')) ?? [])
+                    .map((agent) => (status !== 'running' && agent.status === 'running' ? { ...agent, status: 'stopped' } : agent));
+                const countWith = (agentStatus) => agents.filter((agent) => agent.status === agentStatus).length;
+                message.workflow = {
+                    runId: String(message.toolUseResult.runId ?? ''),
+                    name: String(message.toolUseResult.workflowName ?? ''),
+                    description: typeof message.toolUseResult.summary === 'string' ? message.toolUseResult.summary : undefined,
+                    status,
+                    agents,
+                    agentCounts: {
+                        total: agents.length,
+                        completed: countWith('completed'),
+                        failed: countWith('failed'),
+                        running: countWith('running'),
+                        stopped: countWith('stopped'),
+                    },
+                    scriptPath: typeof message.toolUseResult.scriptPath === 'string' ? message.toolUseResult.scriptPath : undefined,
                 };
             }
             if (notification) {
-                replaceAgentToolResultContent(message, notification.result || notification.summary);
-                foldedNotificationUuids.add(notification.sourceUuid);
+                replaceLaunchToolResultContent(message, notification.result || notification.summary);
+                for (const sourceUuid of notification.sourceUuids) {
+                    foldedNotificationUuids.add(sourceUuid);
+                }
             }
-            else if (message.toolUseResult?.isAsync === true) {
-                // Without a notification there is no answer to show, and the launch
-                // acknowledgement is internal bookkeeping the user must never read.
-                replaceAgentToolResultContent(message, '');
+            else if (isAsyncLaunch && launch !== 'bash') {
+                // Without a notification there is no answer to show, and an agent's
+                // or workflow's launch acknowledgement is internal bookkeeping the
+                // user must never read. A backgrounded command's acknowledgement is
+                // different: it names the output file, which is the only handle on
+                // the command's output until it reports, so it stays.
+                replaceLaunchToolResultContent(message, '');
             }
         }
         const sortedMessages = messages
@@ -489,14 +811,156 @@ function buildLocalCommandDisplayText(payload) {
     }
     return commandArgs ? `${baseCommand} ${commandArgs}` : baseCommand;
 }
+const readOptionalString = (value) => typeof value === 'string' && value ? value : undefined;
+/**
+ * The model an assistant row reports, or undefined when there is nothing
+ * honest to report.
+ *
+ * Rows Claude Code fabricated locally — a usage-limit notice, an API-error
+ * placeholder — are stamped `<synthetic>`; labelling one with a model would
+ * claim a request that never ran, so those are dropped here rather than
+ * guessed at further down.
+ */
+const readAssistantModel = (value) => {
+    const model = readOptionalString(value)?.trim();
+    return model && !isPlaceholderProviderModel(model) ? model : undefined;
+};
+/** The CLI's `{total_tokens, tool_uses, duration_ms}` in the app's spelling. */
+function readTaskUsage(value) {
+    const usage = readObjectRecord(value);
+    if (!usage) {
+        return undefined;
+    }
+    return {
+        totalTokens: Number(usage.total_tokens) || 0,
+        toolUses: Number(usage.tool_uses) || 0,
+        durationMs: Number(usage.duration_ms) || 0,
+    };
+}
+const readOptionalNumber = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+/**
+ * The SDK's word on one workflow agent, in the app's spelling.
+ *
+ * The SDK reports `start` for an agent the script has queued as well as one
+ * that is running; only an `agentId` — the transcript the agent writes — tells
+ * the two apart. `progress` is a running agent that has reported, `done` one
+ * that finished, and anything else (`error`, `failed`) one that did not.
+ */
+function readWorkflowAgentState(state, agentId) {
+    switch (state) {
+        case 'start':
+            return agentId ? 'running' : 'queued';
+        case 'progress':
+            return 'running';
+        case 'done':
+            return 'done';
+        default:
+            return 'failed';
+    }
+}
 /**
- * Claude local-command stdout may contain ANSI styling codes because it was
- * captured from the terminal. The web chat should receive readable plain text.
+ * The per-agent progress a workflow's `task_progress` carries in its
+ * undocumented `workflow_progress`, or undefined when the event has none (an
+ * agent's or shell command's progress, or a workflow that has not spawned).
  */
-function stripAnsiFormatting(text) {
-    return text.replace(/\u001B\[[0-9;?]*[ -/]*[@-~]/g, '');
+function readWorkflowAgentsProgress(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const agents = [];
+    for (const raw of value) {
+        const entry = readObjectRecord(raw);
+        const index = readOptionalNumber(entry?.index);
+        if (!entry || entry.type !== 'workflow_agent' || index === undefined) {
+            continue;
+        }
+        const agentId = readOptionalString(entry.agentId);
+        agents.push({
+            index,
+            label: readOptionalString(entry.label),
+            phase: readOptionalString(entry.phaseTitle),
+            agentId,
+            model: readOptionalString(entry.model),
+            state: readWorkflowAgentState(entry.state, agentId),
+            startedAt: readOptionalNumber(entry.startedAt),
+            lastToolName: readOptionalString(entry.lastToolName),
+            lastToolSummary: readOptionalString(entry.lastToolSummary),
+            promptPreview: readOptionalString(entry.promptPreview),
+            tokens: readOptionalNumber(entry.tokens),
+            toolCalls: readOptionalNumber(entry.toolCalls),
+            durationMs: readOptionalNumber(entry.durationMs),
+            resultPreview: readOptionalString(entry.resultPreview),
+        });
+    }
+    return agents;
+}
+/**
+ * Maps one of the SDK's four background-task `system` events onto the
+ * `task_status` fields, or returns null for any other `system` subtype.
+ *
+ * `task_started` and `task_progress` name the tool call that launched the
+ * task; `task_updated` carries only the task id and a patch of what changed,
+ * so the client has to remember the id from the start event. The patch's
+ * `killed` is spelled `stopped` here, the word the task notification and the
+ * history reader already use for a task that ended without an outcome.
+ */
+function readTaskStatusEvent(raw) {
+    const taskId = readOptionalString(raw.task_id);
+    if (!taskId) {
+        return null;
+    }
+    const shared = {
+        taskId,
+        toolUseId: readOptionalString(raw.tool_use_id),
+    };
+    switch (raw.subtype) {
+        case 'task_started':
+            return {
+                ...shared,
+                event: 'started',
+                taskType: readOptionalString(raw.task_type),
+                workflowName: readOptionalString(raw.workflow_name),
+                description: readOptionalString(raw.description),
+            };
+        case 'task_progress':
+            // A workflow's progress reports on each agent it spawned. Its
+            // task-level `last_tool_name` is the current agent's label rather than
+            // a tool — and nothing draws a task's, so it is not forwarded; the
+            // client reads the current agent from `agents`.
+            return {
+                ...shared,
+                event: 'progress',
+                description: readOptionalString(raw.description),
+                summary: readOptionalString(raw.summary),
+                usage: readTaskUsage(raw.usage),
+                agents: readWorkflowAgentsProgress(raw.workflow_progress),
+            };
+        case 'task_updated': {
+            const patched = readOptionalString(readObjectRecord(raw.patch)?.status);
+            return {
+                ...shared,
+                event: 'updated',
+                status: patched === 'killed' ? 'stopped' : patched,
+            };
+        }
+        case 'task_notification':
+            return {
+                ...shared,
+                event: 'notification',
+                status: readOptionalString(raw.status),
+                summary: readOptionalString(raw.summary),
+                usage: readTaskUsage(raw.usage),
+                outputFile: readOptionalString(raw.output_file),
+            };
+        default:
+            return null;
+    }
 }
 export class ClaudeSessionsProvider {
+    getLiveRunStartTime;
+    constructor({ getLiveRunStartTime = getClaudeSDKSessionStartTime } = {}) {
+        this.getLiveRunStartTime = getLiveRunStartTime;
+    }
     /**
      * Normalizes one Claude JSONL entry or live SDK stream event into the shared
      * message shape consumed by REST and WebSocket clients.
@@ -536,6 +1000,80 @@ export class ClaudeSessionsProvider {
         const messages = [];
         const ts = raw.timestamp || new Date().toISOString();
         const baseId = raw.uuid || generateMessageId('claude');
+        // The live stream reports on background work — a launched workflow, agent
+        // or shell command — through four `system` subtypes that the transcript
+        // never records. They normalize to one `task_status` kind so the client
+        // can keep a workflow's card current while it runs; before this they fell
+        // through every branch below and were dropped.
+        if (raw.type === 'system') {
+            const taskStatus = readTaskStatusEvent(raw);
+            if (taskStatus) {
+                return [createNormalizedMessage({
+                        id: baseId,
+                        sessionId,
+                        timestamp: ts,
+                        provider: PROVIDER,
+                        kind: 'task_status',
+                        ...taskStatus,
+                    })];
+            }
+        }
+        // A compaction is the most expensive thing a long session does without
+        // being asked, and neither record that describes it survives the branches
+        // below: `system` events normalize to nothing. Both become one ordinary
+        // assistant row, so a client that knows nothing of `compact` still reads
+        // the sentence, while one that does can draw it as a row of its own.
+        if (raw.type === 'system' && (raw.subtype === 'compact_boundary' || raw.subtype === 'status')) {
+            const compactionRow = (content, compact) => [
+                createNormalizedMessage({
+                    id: `${baseId}_compact`,
+                    sessionId,
+                    timestamp: ts,
+                    provider: PROVIDER,
+                    kind: 'text',
+                    role: 'assistant',
+                    content,
+                    compact,
+                }),
+            ];
+            if (raw.subtype === 'compact_boundary') {
+                // `compact_metadata` live, `compactMetadata` on disk.
+                const metadata = readObjectRecord(raw.compact_metadata ?? raw.compactMetadata) ?? {};
+                const trigger = metadata.trigger === 'manual' ? 'manual' : 'auto';
+                const preTokens = Number(metadata.pre_tokens ?? metadata.preTokens) || 0;
+                const postTokens = Number(metadata.post_tokens ?? metadata.postTokens) || 0;
+                const durationMs = Number(metadata.duration_ms ?? metadata.durationMs) || 0;
+                const said = ['Compacted', trigger];
+                if (preTokens) {
+                    said.push(postTokens
+                        ? `${formatTokenCount(preTokens)} → ${formatTokenCount(postTokens)} tokens`
+                        : `${formatTokenCount(preTokens)} tokens`);
+                }
+                if (durationMs) {
+                    said.push(formatDuration(durationMs));
+                }
+                return compactionRow(said.join(' · '), {
+                    phase: 'done',
+                    trigger,
+                    preTokens,
+                    postTokens,
+                    durationMs,
+                });
+            }
+            // A status message reports several things, and compaction is the only one
+            // with anything to say: every other turn sends `requesting` or nothing.
+            if (raw.status === 'compacting') {
+                return compactionRow('Compacting conversation…', { phase: 'running' });
+            }
+            if (raw.compact_result === 'failed') {
+                const error = typeof raw.compact_error === 'string' ? raw.compact_error : null;
+                return compactionRow(`Compaction failed${error ? `: ${error}` : ''}`, {
+                    phase: 'failed',
+                    error,
+                });
+            }
+            return [];
+        }
         if (raw.message?.role === 'user' && raw.message?.content && raw.isMeta !== true) {
             if (Array.isArray(raw.message.content)) {
                 // Image attachments sent through the SDK are persisted as base64
@@ -562,7 +1100,14 @@ export class ClaudeSessionsProvider {
                             toolId: part.tool_use_id,
                             content: typeof part.content === 'string' ? part.content : JSON.stringify(part.content),
                             isError: Boolean(part.is_error),
-                            toolUseResult: raw.toolUseResult,
+                            // `toolUseResult` on disk, `tool_use_result` on the live SDK
+                            // stream. Reading only the transcript key meant a live agent
+                            // launch reached the client with no `isAsync`, so the card could
+                            // not tell the launch acknowledgement from an answer. The stream
+                            // value is the tool's whole structured output — an Edit carries
+                            // the file it edited — so it gets the same per-string cap the
+                            // transcript path applies before anything is sent or buffered.
+                            toolUseResult: truncateNestedOutput(raw.toolUseResult ?? raw.tool_use_result),
                         }));
                     }
                     else if (part.type === 'text') {
@@ -679,7 +1224,7 @@ export class ClaudeSessionsProvider {
                  */
                 const localCommandStdout = extractTaggedContent(text, 'local-command-stdout');
                 if (localCommandStdout !== null) {
-                    const stdoutText = stripAnsiFormatting(localCommandStdout).trim();
+                    const stdoutText = stripAnsiSequences(localCommandStdout).trim();
                     if (stdoutText) {
                         messages.push(createNormalizedMessage({
                             id: baseId,
@@ -749,6 +1294,12 @@ export class ClaudeSessionsProvider {
             return messages;
         }
         if (raw.message?.role === 'assistant' && raw.message?.content) {
+            // Which model actually answered. It rides on the assistant row itself in
+            // both the transcript and the live SDK stream, so history renders it
+            // retroactively with no migration. Only prose carries it: a tool call has
+            // no footer to show it in, and a locally-fabricated row (`<synthetic>`,
+            // e.g. the usage-limit notice) gets no label rather than a guessed one.
+            const answeredByModel = readAssistantModel(raw.message.model);
             if (Array.isArray(raw.message.content)) {
                 let partIndex = 0;
                 for (const part of raw.message.content) {
@@ -761,6 +1312,7 @@ export class ClaudeSessionsProvider {
                             kind: 'text',
                             role: 'assistant',
                             content: part.text,
+                            model: answeredByModel,
                         }));
                     }
                     else if (part.type === 'tool_use') {
@@ -797,6 +1349,7 @@ export class ClaudeSessionsProvider {
                     kind: 'text',
                     role: 'assistant',
                     content: raw.message.content,
+                    model: answeredByModel,
                 }));
             }
             return messages;
@@ -845,6 +1398,60 @@ export class ClaudeSessionsProvider {
         }
         return { found: true, resumeThroughId: null };
     }
+    /**
+     * Reads one workflow agent's timeline from the transcript the run wrote for
+     * it, under `<projectDir>/<providerSessionId>/subagents/workflows/<runId>/`
+     * — the only place it exists, since the SDK never streams a workflow agent's
+     * rows to the parent session.
+     *
+     * The journal beside it settles the agent when it has; short of that the
+     * agent is running only while the process that spawned it is — the same
+     * rule history applies to a launch row, keyed here on the agent's first row
+     * rather than the launch's.
+     */
+    async readWorkflowAgentActivity(sessionId, runId, agentId) {
+        const session = sessionsDb.getSessionById(sessionId);
+        const jsonlPath = session?.jsonl_path;
+        const providerSessionId = session?.provider_session_id;
+        if (!jsonlPath || !providerSessionId) {
+            return null;
+        }
+        const transcriptDir = path.join(path.dirname(jsonlPath), providerSessionId, 'subagents', 'workflows', runId);
+        const transcriptPath = path.join(transcriptDir, `agent-${agentId}.jsonl`);
+        try {
+            await fsp.access(transcriptPath);
+        }
+        catch {
+            return null;
+        }
+        const [transcript, journalAgents] = await Promise.all([
+            readClaudeSubagentTranscript(transcriptPath),
+            readWorkflowJournal(transcriptDir),
+        ]);
+        const journalAgent = journalAgents.find((agent) => agent.id === agentId);
+        let status;
+        if (journalAgent && journalAgent.status !== 'running') {
+            status = journalAgent.status;
+        }
+        else {
+            const liveRunStartedAt = this.getLiveRunStartTime(sessionId) ?? this.getLiveRunStartTime(providerSessionId);
+            status = liveRunStartedAt !== null && Date.parse(transcript.startedAt ?? '') >= liveRunStartedAt
+                ? 'running'
+                : 'stopped';
+        }
+        return {
+            agent: {
+                id: agentId,
+                label: journalAgent?.label,
+                model: transcript.model,
+                status,
+            },
+            activity: transcript.activity
+                .slice(-MAX_TRANSMITTED_SUBAGENT_ACTIVITIES)
+                .map(truncateSubagentActivity),
+            activityCount: transcript.activity.length,
+        };
+    }
     /**
      * Loads Claude JSONL history for a project/session and returns normalized
      * messages, preserving the existing pagination behavior from projects.js.
@@ -856,7 +1463,7 @@ export class ClaudeSessionsProvider {
         try {
             // Load full history first so `total` reflects frontend-normalized messages,
             // not raw JSONL records.
-            result = await getSessionMessages(sessionId, providerSessionId, null, 0);
+            result = await getSessionMessages(sessionId, providerSessionId, null, 0, this.getLiveRunStartTime);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -874,6 +1481,7 @@ export class ClaudeSessionsProvider {
                             isError: Boolean(part.is_error),
                             subagentTools: raw.subagentTools,
                             subagent: raw.subagent,
+                            workflow: raw.workflow,
                             toolUseResult: raw.toolUseResult,
                         });
                     }
@@ -899,6 +1507,7 @@ export class ClaudeSessionsProvider {
                 };
                 msg.subagentTools = toolResult.subagentTools;
                 msg.subagent = toolResult.subagent;
+                msg.workflow = toolResult.workflow;
             }
         }
         // Everything the transcript draws, and nothing else — so a page of N rows