@cloudcli-ai/cloudcli 1.37.3 → 1.37.4

package/server/modules/providers/list/claude/claude-sessions.provider.ts

@@ -6,31 +6,56 @@ import readline from 'node:readline';
 import type { IProviderSessions } from '@/shared/interfaces.js';
 import type {
   AnyRecord,
+  CompactionInfo,
   FetchHistoryOptions,
   FetchHistoryResult,
   NormalizedMessage,
   SubagentActivity,
   SubagentInfo,
+  TaskUsage,
+  WorkflowAgentActivity,
+  WorkflowAgentInfo,
+  WorkflowAgentProgress,
+  WorkflowInfo,
 } from '@/shared/types.js';
 import { parseFilesInputTag } from '@/shared/image-attachments.js';
-import { prepareTranscriptMessages } from '@/shared/message-unification.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: number): string => {
+  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: number): string => {
+  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;
 
@@ -39,6 +64,7 @@ type ClaudeToolResult = {
   isError: boolean;
   subagentTools?: SubagentActivity[];
   subagent?: SubagentInfo;
+  workflow?: WorkflowInfo;
   toolUseResult?: unknown;
 };
 
@@ -63,11 +89,8 @@ type ClaudeHistoryMessagesResult =
 type ClaudeSubagentTranscript = {
   activity: SubagentActivity[];
   model?: string;
-  /**
-   * True when the transcript's last tool call never received a result, which
-   * is the only evidence in the file that the agent stopped mid-flight.
-   */
-  endedMidToolCall: boolean;
+  /** When the agent's first row was written: the moment it was spawned. */
+  startedAt?: string;
 };
 
 /**
@@ -79,7 +102,7 @@ type ClaudeSubagentTranscript = {
  */
 async function readClaudeSubagentTranscript(filePath: string): Promise<ClaudeSubagentTranscript> {
   const activity: SubagentActivity[] = [];
-  const transcript: ClaudeSubagentTranscript = { activity, endedMidToolCall: false };
+  const transcript: ClaudeSubagentTranscript = { activity };
   const toolsById = new Map<string, SubagentActivity>();
 
   try {
@@ -97,6 +120,9 @@ async function readClaudeSubagentTranscript(filePath: string): Promise<ClaudeSub
       try {
         const entry = JSON.parse(line) as AnyRecord;
         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') {
@@ -160,9 +186,6 @@ async function readClaudeSubagentTranscript(filePath: string): Promise<ClaudeSub
     console.warn(`Error parsing agent file ${filePath}:`, message);
   }
 
-  const lastActivity = activity[activity.length - 1];
-  transcript.endedMidToolCall = lastActivity?.kind === 'tool' && !lastActivity.toolResult;
-
   return transcript;
 }
 
@@ -215,9 +238,111 @@ async function findClaudeSubagentTranscript(
   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: string): Promise<WorkflowAgentInfo[]> {
+  const agentsById = new Map<string, WorkflowAgentInfo>();
+
+  let journal: string;
+  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: AnyRecord;
+    try {
+      entry = JSON.parse(line) as AnyRecord;
+    } 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()];
+}
+
+/**
+ * Which kind of background work a tool-result row launched, read off the
+ * structured `toolUseResult` the CLI stores beside it.
+ *
+ * All three answer the same way — a launch acknowledgement now, a
+ * `<task-notification>` later — but each is recognised by its own key: an
+ * `Agent` by the `agentId` of the transcript it writes, a `Workflow` by the
+ * `async_launched` status it shares with an agent launch (it has no agent of
+ * its own), and a backgrounded `Bash` by the `backgroundTaskId` the shell
+ * reports. A synchronous `Agent` also carries `agentId` and is included here
+ * because its card is built the same way; only `isAsync` says it launched.
+ */
+type ClaudeBackgroundLaunch = 'agent' | 'workflow' | 'bash';
+
+function readBackgroundLaunch(toolUseResult: unknown): ClaudeBackgroundLaunch | null {
+  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;
+}
+
 type ClaudeTaskNotification = {
-  /** `uuid` of the transcript row the notification came from, so it can be dropped. */
-  sourceUuid: string;
+  /**
+   * `uuid`s of every transcript row that notified for this call, so all of
+   * them can be dropped once the latest one is folded. A task that resumes or
+   * is first reported as stopped and later as completed notifies more than
+   * once, and every earlier row is superseded bookkeeping. Queue-operation
+   * records carry no `uuid` and never render on their own, so they add
+   * nothing here.
+   */
+  sourceUuids: string[];
   toolUseId: string;
   status: string;
   summary: string;
@@ -230,8 +355,46 @@ function readTaggedValue(content: string, tagName: string): string {
 }
 
 /**
- * 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: AnyRecord): string[] {
+  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: AnyRecord) => part?.type === 'text').map((part: AnyRecord) => 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.
@@ -240,18 +403,7 @@ function collectTaskNotifications(messages: AnyRecord[]): Map<string, ClaudeTask
   const notifications = new Map<string, ClaudeTaskNotification>();
 
   for (const message of messages) {
-    if (message.message?.role !== 'user') {
-      continue;
-    }
-
-    const content = message.message.content;
-    const texts: string[] = typeof content === 'string'
-      ? [content]
-      : Array.isArray(content)
-        ? content.filter((part: AnyRecord) => part?.type === 'text').map((part: AnyRecord) => String(part.text ?? ''))
-        : [];
-
-    for (const text of texts) {
+    for (const text of readTaskNotificationTexts(message)) {
       if (!text.trimStart().startsWith('<task-notification>')) {
         continue;
       }
@@ -261,9 +413,14 @@ function collectTaskNotifications(messages: AnyRecord[]): Map<string, ClaudeTask
         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'),
@@ -275,8 +432,8 @@ function collectTaskNotifications(messages: AnyRecord[]): Map<string, ClaudeTask
   return notifications;
 }
 
-/** Reads the `tool_use_id` off the tool-result row that launched an agent. */
-function readAgentToolUseId(message: AnyRecord): string | null {
+/** Reads the `tool_use_id` off the tool-result row that launched background work. */
+function readLaunchToolUseId(message: AnyRecord): string | null {
   const content = message.message?.content;
   if (!Array.isArray(content)) {
     return null;
@@ -291,8 +448,8 @@ function readAgentToolUseId(message: AnyRecord): string | null {
   return null;
 }
 
-/** Swaps an agent launch acknowledgement for the agent's actual answer. */
-function replaceAgentToolResultContent(message: AnyRecord, replacement: string): void {
+/** Swaps a launch acknowledgement for the work's actual answer. */
+function replaceLaunchToolResultContent(message: AnyRecord, replacement: string): void {
   const content = message.message?.content;
   if (!Array.isArray(content)) {
     return;
@@ -349,12 +506,119 @@ function isUserPromptRow(row: AnyRecord): boolean {
 }
 
 /**
- * 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: AnyRecord[]): Set<string> {
+  const conversation = new Map<string, AnyRecord>();
+  const progressParents = new Map<string, string | null>();
+  const parentOf = (row: AnyRecord): string | undefined => {
+    const parentUuid = typeof row.parentUuid === 'string' ? row.parentUuid : undefined;
+    if (parentUuid && progressParents.has(parentUuid)) {
+      return progressParents.get(parentUuid) ?? undefined;
+    }
+    return parentUuid;
+  };
+
+  let newestRow: string | undefined;
+  let stampedLeaf: string | undefined;
+  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: string | undefined): string[] => {
+    const chain: string[] = [];
+    const seen = new Set<string>();
+    let cursor = leaf;
+    while (cursor && conversation.has(cursor) && !seen.has(cursor)) {
+      seen.add(cursor);
+      chain.push(cursor);
+      cursor = parentOf(conversation.get(cursor) as AnyRecord);
+    }
+    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: AnyRecord[]): Map<string, number> {
+  const newestByUuid = new Map<string, number>();
+
+  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
@@ -375,15 +639,31 @@ function dropSupersededPromptBranches(rows: AnyRecord[]): AnyRecord[] {
     }
   }
 
+  const forks = [...promptSiblings.values()].filter((siblings) => siblings.length > 1);
+  if (forks.length === 0) {
+    return rows;
+  }
+
+  const resumePath = resolveResumePath(rows);
+  let newestByUuid: Map<string, number> | undefined;
+  const newestRowOf = (row: AnyRecord): number => {
+    newestByUuid ??= indexNewestRowPerBranch(rows);
+    return typeof row.uuid === 'string' ? newestByUuid.get(row.uuid) ?? -1 : -1;
+  };
+
   const supersededRoots = new Set<string>();
-  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);
       }
     }
@@ -405,11 +685,15 @@ function dropSupersededPromptBranches(rows: AnyRecord[]): AnyRecord[] {
   return rows.filter((row) => typeof row.uuid !== 'string' || !abandoned.has(row.uuid));
 }
 
+/** When the CLI run behind a session started (epoch ms), or null when none is up. */
+type LiveRunStartTimeProbe = (sessionId: string) => number | null;
+
 async function getSessionMessages(
   sessionId: string,
   providerSessionId: string,
   limit: number | null,
   offset: number,
+  getLiveRunStartTime: LiveRunStartTimeProbe,
 ): Promise<ClaudeHistoryMessagesResult> {
   try {
     // The DB row is keyed by the app-facing session id, while the JSONL rows
@@ -435,11 +719,11 @@ async function getSessionMessages(
     }
 
     // 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<string, {
       activity: SubagentActivity[];
-      info: SubagentInfo;
-      endedMidToolCall: boolean;
+      info: Omit<SubagentInfo, 'status'>;
     }>();
     for (const agentId of agentIds) {
       const located = await findClaudeSubagentTranscript(projectDir, providerSessionId, agentId);
@@ -453,9 +737,8 @@ async function getSessionMessages(
       ]);
 
       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,
@@ -463,62 +746,158 @@ async function getSessionMessages(
           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<string, WorkflowAgentInfo[]>();
+    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<string>();
 
+    // 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: AnyRecord): boolean =>
+      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: SubagentInfo['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: WorkflowInfo['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' as const } : agent));
+        const countWith = (agentStatus: WorkflowAgentInfo['status']) =>
+          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);
-      } 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, '');
+        replaceLaunchToolResultContent(message, notification.result || notification.summary);
+        for (const sourceUuid of notification.sourceUuids) {
+          foldedNotificationUuids.add(sourceUuid);
+        }
+      } 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, '');
       }
     }
 
@@ -638,15 +1017,185 @@ function buildLocalCommandDisplayText(payload: ClaudeLocalCommandPayload): strin
   return commandArgs ? `${baseCommand} ${commandArgs}` : baseCommand;
 }
 
+/** The `task_status` fields of a normalized message, minus the envelope. */
+type ClaudeTaskStatusEvent = Pick<
+  NormalizedMessage,
+  'event' | 'taskId' | 'toolUseId' | 'taskType' | 'workflowName' | 'description' | 'status' | 'summary' | 'usage' | 'outputFile' | 'agents'
+>;
+
+const readOptionalString = (value: unknown): string | undefined =>
+  typeof value === 'string' && value ? value : undefined;
+
 /**
- * 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 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.
  */
-function stripAnsiFormatting(text: string): string {
-  return text.replace(/\u001B\[[0-9;?]*[ -/]*[@-~]/g, '');
+const readAssistantModel = (value: unknown): string | undefined => {
+  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: unknown): TaskUsage | undefined {
+  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: unknown): number | undefined =>
+  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: unknown, agentId: string | undefined): WorkflowAgentProgress['state'] {
+  switch (state) {
+    case 'start':
+      return agentId ? 'running' : 'queued';
+    case 'progress':
+      return 'running';
+    case 'done':
+      return 'done';
+    default:
+      return 'failed';
+  }
+}
+
+/**
+ * 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 readWorkflowAgentsProgress(value: unknown): WorkflowAgentProgress[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+
+  const agents: WorkflowAgentProgress[] = [];
+  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: AnyRecord): ClaudeTaskStatusEvent | null {
+  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;
+  }
+}
+
+type ClaudeSessionsProviderOptions = {
+  /**
+   * When the CLI run behind a session started, or null when none is up.
+   * Injected so history tests can pin what a stopped run reads as without
+   * driving a real SDK run.
+   */
+  getLiveRunStartTime?: LiveRunStartTimeProbe;
+};
+
 export class ClaudeSessionsProvider implements IProviderSessions {
+  private readonly getLiveRunStartTime: LiveRunStartTimeProbe;
+
+  constructor({ getLiveRunStartTime = getClaudeSDKSessionStartTime }: ClaudeSessionsProviderOptions = {}) {
+    this.getLiveRunStartTime = getLiveRunStartTime;
+  }
+
   /**
    * Normalizes one Claude JSONL entry or live SDK stream event into the shared
    * message shape consumed by REST and WebSocket clients.
@@ -691,6 +1240,86 @@ export class ClaudeSessionsProvider implements IProviderSessions {
     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: string, compact: CompactionInfo): NormalizedMessage[] => [
+        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
@@ -718,7 +1347,14 @@ export class ClaudeSessionsProvider implements IProviderSessions {
               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') {
             const text = part.text || '';
@@ -840,7 +1476,7 @@ export class ClaudeSessionsProvider implements IProviderSessions {
          */
         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,
@@ -917,6 +1553,13 @@ export class ClaudeSessionsProvider implements IProviderSessions {
     }
 
     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) {
@@ -929,6 +1572,7 @@ export class ClaudeSessionsProvider implements IProviderSessions {
               kind: 'text',
               role: 'assistant',
               content: part.text,
+              model: answeredByModel,
             }));
           } else if (part.type === 'tool_use') {
             messages.push(createNormalizedMessage({
@@ -962,6 +1606,7 @@ export class ClaudeSessionsProvider implements IProviderSessions {
           kind: 'text',
           role: 'assistant',
           content: raw.message.content,
+          model: answeredByModel,
         }));
       }
       return messages;
@@ -1020,6 +1665,67 @@ export class ClaudeSessionsProvider implements IProviderSessions {
     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: string,
+    runId: string,
+    agentId: string,
+  ): Promise<WorkflowAgentActivity | null> {
+    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: WorkflowAgentActivity['agent']['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.
@@ -1035,7 +1741,7 @@ export class ClaudeSessionsProvider implements IProviderSessions {
     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);
       console.warn(`[ClaudeProvider] Failed to load session ${sessionId}:`, message);
@@ -1054,6 +1760,7 @@ export class ClaudeSessionsProvider implements IProviderSessions {
               isError: Boolean(part.is_error),
               subagentTools: raw.subagentTools,
               subagent: raw.subagent,
+              workflow: raw.workflow,
               toolUseResult: raw.toolUseResult,
             });
           }
@@ -1082,6 +1789,7 @@ export class ClaudeSessionsProvider implements IProviderSessions {
         };
         msg.subagentTools = toolResult.subagentTools;
         msg.subagent = toolResult.subagent;
+        msg.workflow = toolResult.workflow;
       }
     }