@adecore/agents-react 0.31.12 → 0.33.0

package/dist/chat/logic/timeline.js

@@ -13,61 +13,80 @@ import { hasFileChanges, isFileChange, shellCommand } from './tools.js';
  */
 const BLOCK_KINDS = new Set(['assistant', 'report', 'thinking', 'changed-files', 'compaction', 'app-card', 'visual']);
 export function isBlock(row) {
-    return BLOCK_KINDS.has(row.kind) || isImageRow(row);
+  return BLOCK_KINDS.has(row.kind) || isImageRow(row);
 }
 /*
  * The sentence of a run of shell calls that are all runs of one look: its group's when they share a key,
  * else the look's own; null for any other run, which reads as shell calls.
  */
 function lookSummary(tools, looks) {
-    let look = null;
-    let group;
-    let sameKey = true;
-    for (const tool of tools) {
-        const command = shellCommand(tool.name, tool.input);
-        const run = command === null ? null : matchCommandLook(command, looks);
-        if (run === null || (look !== null && run.look !== look)) {
-            return null;
-        }
-        if (look === null) {
-            look = run.look;
-            group = run.match.group;
-        }
-        else if (run.match.group?.key !== group?.key) {
-            sameKey = false;
-        }
+  let look = null;
+  let group;
+  let sameKey = true;
+  for (const tool of tools) {
+    const command = shellCommand(tool.name, tool.input);
+    const run = command === null ? null : matchCommandLook(command, looks);
+    if (run === null || look !== null && run.look !== look) {
+      return null;
     }
     if (look === null) {
-        return null;
+      look = run.look;
+      group = run.match.group;
+    } else if (run.match.group?.key !== group?.key) {
+      sameKey = false;
     }
-    if (sameKey && group !== undefined) {
-        return { look, summary: group.sentence(tools.length) };
-    }
-    return look.sentence === undefined ? null : { look, summary: look.sentence(tools.length) };
+  }
+  if (look === null) {
+    return null;
+  }
+  if (sameKey && group !== undefined) {
+    return {
+      look,
+      summary: group.sentence(tools.length)
+    };
+  }
+  return look.sentence === undefined ? null : {
+    look,
+    summary: look.sentence(tools.length)
+  };
 }
 /* "Read 4 files", "Ran 2 commands", "12 tool calls" when the run mixes kinds, or the sentence of a look all its calls are runs of. */
 export function summarizeGroup(tools, looks) {
-    const looked = lookSummary(tools, looks);
-    if (looked !== null) {
-        return looked.summary;
-    }
-    const names = new Set(tools.map((tool) => tool.name));
-    const only = names.size === 1 ? tools[0].name : null;
-    if (only !== null && toolEntry(only)?.grouped === true) {
-        return i18next.t(`agent-chat:group.tools.${only}`, { count: tools.length });
-    }
-    // Counts the files rather than the calls: three edits to one file are one file edited.
-    if (tools.every((tool) => isFileChange(tool.name))) {
-        const paths = new Set(tools.map(editedPath));
-        return i18next.t('agent-chat:group.edited', { count: paths.size });
-    }
-    if (only !== null) {
-        return i18next.t('agent-chat:group.calls', { name: only, count: tools.length });
-    }
-    return i18next.t('agent-chat:group.toolCalls', { count: tools.length });
+  const looked = lookSummary(tools, looks);
+  if (looked !== null) {
+    return looked.summary;
+  }
+  const names = new Set(tools.map(tool => tool.name));
+  const only = names.size === 1 ? tools[0].name : null;
+  const failed = tools.filter(failedFileChange);
+  if (only !== null && toolEntry(only)?.grouped === true && failed.length === 0) {
+    return i18next.t(`agent-chat:group.tools.${only}`, {
+      count: tools.length
+    });
+  }
+  // Counts the files rather than the calls: three edits to one file are one file edited.
+  if (tools.every(tool => isFileChange(tool.name)) && failed.length < tools.length) {
+    const paths = new Set(tools.filter(tool => !failedFileChange(tool)).map(editedPath));
+    return i18next.t('agent-chat:group.edited', {
+      count: paths.size
+    });
+  }
+  if (only !== null) {
+    return i18next.t('agent-chat:group.calls', {
+      name: only,
+      count: tools.length
+    });
+  }
+  return i18next.t('agent-chat:group.toolCalls', {
+    count: tools.length
+  });
+}
+/* A file change that failed or was refused changed nothing: it counts as a call, never as an edit. */
+function failedFileChange(tool) {
+  return isFileChange(tool.name) && tool.state === 'error';
 }
 function editedPath(tool) {
-    return tool.input?.file_path ?? tool.id;
+  return tool.input?.file_path ?? tool.id;
 }
 /*
  * What a folded turn did, a sentence per kind of call in the order it first came: "Read 11 files",
@@ -75,272 +94,374 @@ function editedPath(tool) {
  * their own are counted together at the end.
  */
 export function summarizeTurn(tools, looks) {
-    // Keyed by the sentence, so its place is where the first call of that kind came.
-    const counts = new Map();
-    const add = (key, say, total) => {
-        const known = counts.get(key);
-        if (known === undefined) {
-            counts.set(key, { count: total ?? 1, say });
-        }
-        else {
-            known.count = total ?? known.count + 1;
-        }
-    };
-    const edited = new Set();
-    let other = 0;
-    for (const tool of tools) {
-        const command = shellCommand(tool.name, tool.input);
-        const run = command === null ? null : matchCommandLook(command, looks);
-        const group = run?.match.group;
-        if (run !== null && group !== undefined) {
-            // Keyed by the program too, so two looks with a key in common keep their own sentences.
-            add(`look:${run.look.program}:${group.key}`, group.sentence);
-        }
-        else if (isFileChange(tool.name)) {
-            edited.add(editedPath(tool));
-            add('agent-chat:group.edited', (count) => i18next.t('agent-chat:group.edited', { count }), edited.size);
-        }
-        else if (toolEntry(tool.name)?.grouped === true) {
-            const key = `agent-chat:group.tools.${tool.name}`;
-            add(key, (count) => i18next.t(key, { count }));
-        }
-        else {
-            other += 1;
-        }
+  // Keyed by the sentence, so its place is where the first call of that kind came.
+  const counts = new Map();
+  const add = (key, say, total) => {
+    const known = counts.get(key);
+    if (known === undefined) {
+      counts.set(key, {
+        count: total ?? 1,
+        say
+      });
+    } else {
+      known.count = total ?? known.count + 1;
     }
-    const parts = [...counts.values()].map(({ count, say }) => say(count));
-    if (other > 0) {
-        parts.push(i18next.t(parts.length === 0 ? 'agent-chat:group.toolCalls' : 'agent-chat:group.otherCalls', { count: other }));
+  };
+  const edited = new Set();
+  let other = 0;
+  for (const tool of tools) {
+    const command = shellCommand(tool.name, tool.input);
+    const run = command === null ? null : matchCommandLook(command, looks);
+    const group = run?.match.group;
+    if (run !== null && group !== undefined) {
+      // Keyed by the program too, so two looks with a key in common keep their own sentences.
+      add(`look:${run.look.program}:${group.key}`, group.sentence);
+    } else if (failedFileChange(tool)) {
+      other += 1;
+    } else if (isFileChange(tool.name)) {
+      edited.add(editedPath(tool));
+      add('agent-chat:group.edited', count => i18next.t('agent-chat:group.edited', {
+        count
+      }), edited.size);
+    } else if (toolEntry(tool.name)?.grouped === true) {
+      const key = `agent-chat:group.tools.${tool.name}`;
+      add(key, count => i18next.t(key, {
+        count
+      }));
+    } else {
+      other += 1;
     }
-    return parts;
+  }
+  const parts = [...counts.values()].map(({
+    count,
+    say
+  }) => say(count));
+  if (other > 0) {
+    parts.push(i18next.t(parts.length === 0 ? 'agent-chat:group.toolCalls' : 'agent-chat:group.otherCalls', {
+      count: other
+    }));
+  }
+  return parts;
 }
 /*
  * What a turn nobody asked for is about. The CLI wakes the agent when a background subagent settles
  * and hands over its summary; without one all that is known is that the agent went on by itself.
  */
 export function agentTurnLabel(turn) {
-    const about = (what) => (turn.label ? i18next.t('agent-chat:turn.about', { what, label: turn.label }) : what);
-    // A turn the machine opened with the results of tasks this chat gave; the label is their titles.
-    if (turn.taskIds !== undefined && turn.taskIds.length > 0) {
-        return about(i18next.t('agent-chat:turn.wokenByTask', { count: turn.taskIds.length }));
-    }
-    // A turn the machine opened over a message another node sent; the label names who sent it.
-    if (turn.messageFrom !== undefined && turn.messageFrom.length > 0) {
-        return about(i18next.t('agent-chat:turn.wokenByMessage', { count: turn.messageFrom.length }));
-    }
-    return turn.label ? i18next.t('agent-chat:turn.subagentFinished', { label: turn.label }) : i18next.t('agent-chat:turn.continued');
+  const about = what => turn.label ? i18next.t('agent-chat:turn.about', {
+    what,
+    label: turn.label
+  }) : what;
+  // A turn the machine opened with the results of tasks this chat gave; the label is their titles.
+  if (turn.taskIds !== undefined && turn.taskIds.length > 0) {
+    return about(i18next.t('agent-chat:turn.wokenByTask', {
+      count: turn.taskIds.length
+    }));
+  }
+  // A turn the machine opened over a message another node sent; the label names who sent it.
+  if (turn.messageFrom !== undefined && turn.messageFrom.length > 0) {
+    return about(i18next.t('agent-chat:turn.wokenByMessage', {
+      count: turn.messageFrom.length
+    }));
+  }
+  return turn.label ? i18next.t('agent-chat:turn.subagentFinished', {
+    label: turn.label
+  }) : i18next.t('agent-chat:turn.continued');
 }
 /* The items of the turn tell a turn a person stopped from one the machine ended after a restart. */
 export function turnLabel(turn, items = []) {
-    const duration = formatElapsedShort((turn.endedAt ?? turn.createdAt) - turn.createdAt);
-    switch (turn.state) {
-        case 'aborted':
-            return abortedByMachine(turn, items) ? i18next.t('agent-chat:turn.stopped', { duration }) : i18next.t('agent-chat:turn.youStopped', { duration });
-        case 'error':
-            return i18next.t('agent-chat:turn.failed', { duration });
-        default:
-            return i18next.t('agent-chat:turn.worked', { duration });
-    }
+  const duration = formatElapsedShort((turn.endedAt ?? turn.createdAt) - turn.createdAt);
+  switch (turn.state) {
+    case 'aborted':
+      return abortedByMachine(turn, items) ? i18next.t('agent-chat:turn.stopped', {
+        duration
+      }) : i18next.t('agent-chat:turn.youStopped', {
+        duration
+      });
+    case 'error':
+      return i18next.t('agent-chat:turn.failed', {
+        duration
+      });
+    default:
+      return i18next.t('agent-chat:turn.worked', {
+        duration
+      });
+  }
 }
 // A subagent's own work, and an agent it opened, belong to its row, not to the thread; an old record has no row for it.
 function parentOf(item) {
-    return item.kind === 'tool' || item.kind === 'assistant' || item.kind === 'subagent' ? (item.parentToolUseId ?? null) : null;
+  return item.kind === 'tool' || item.kind === 'assistant' || item.kind === 'subagent' ? item.parentToolUseId ?? null : null;
 }
 // Deeper than the CLI forwards any call; it also ends a chain of rows that would name each other.
 const MAX_NESTING = 8;
 function branchOf(item, options, children, depth = 0) {
-    const own = children.get(item.toolUseId) ?? [];
-    return {
-        id: item.id,
-        item,
-        children: own.filter((child) => child.kind !== 'subagent'),
-        nested: depth >= MAX_NESTING
-            ? []
-            : own.filter((child) => child.kind === 'subagent').map((child) => branchOf(child, options, children, depth + 1)),
-        expanded: options.expandedSubagents.has(item.id)
-    };
+  const own = children.get(item.toolUseId) ?? [];
+  return {
+    id: item.id,
+    item,
+    children: own.filter(child => child.kind !== 'subagent'),
+    nested: depth >= MAX_NESTING ? [] : own.filter(child => child.kind === 'subagent').map(child => branchOf(child, options, children, depth + 1)),
+    expanded: options.expandedSubagents.has(item.id)
+  };
 }
 /* The branch a subagent's row sits in, its own or one it hangs under, anywhere in the thread's rows. */
 export function findSubagentBranch(rows, toolUseId) {
-    const search = (branch) => {
-        if (branch.item.toolUseId === toolUseId) {
-            return branch;
-        }
-        for (const child of branch.nested) {
-            const found = search(child);
-            if (found) {
-                return found;
-            }
-        }
-        return null;
-    };
-    for (let index = 0; index < rows.length; index++) {
-        const row = rows[index];
-        const branch = row.kind === 'subagent' ? search(row) : null;
-        if (branch) {
-            return { index, branch };
-        }
+  const search = branch => {
+    if (branch.item.toolUseId === toolUseId) {
+      return branch;
+    }
+    for (const child of branch.nested) {
+      const found = search(child);
+      if (found) {
+        return found;
+      }
     }
     return null;
+  };
+  for (let index = 0; index < rows.length; index++) {
+    const row = rows[index];
+    const branch = row.kind === 'subagent' ? search(row) : null;
+    if (branch) {
+      return {
+        index,
+        branch
+      };
+    }
+  }
+  return null;
 }
 /* What each subagent did, keyed by the call that spawned it, in the order it happened. */
 function groupChildren(items) {
-    const children = new Map();
-    for (const item of items) {
-        const parent = parentOf(item);
-        if (parent === null) {
-            continue;
-        }
-        const bucket = children.get(parent);
-        if (bucket) {
-            bucket.push(item);
-        }
-        else {
-            children.set(parent, [item]);
-        }
+  const children = new Map();
+  for (const item of items) {
+    const parent = parentOf(item);
+    if (parent === null) {
+      continue;
+    }
+    const bucket = children.get(parent);
+    if (bucket) {
+      bucket.push(item);
+    } else {
+      children.set(parent, [item]);
     }
-    return children;
+  }
+  return children;
 }
 function flushTools(buffer, rows, options) {
-    if (buffer.length === 0) {
-        return;
-    }
-    const tools = buffer.splice(0);
-    const live = tools.filter((tool) => tool.state === 'running');
-    const settled = tools.filter((tool) => tool.state !== 'running');
-    if (settled.length === 1) {
-        rows.push({ kind: 'work', id: settled[0].id, tool: settled[0] });
-    }
-    else if (settled.length > 1) {
-        const id = `group-${settled[0].id}`;
-        const expanded = options.expandedGroups.has(id);
-        const looked = lookSummary(settled, options.commandLooks);
-        rows.push(looked === null
-            ? { kind: 'work-group', id, tools: settled, summary: summarizeGroup(settled), expanded }
-            : { kind: 'work-group', id, tools: settled, summary: looked.summary, expanded, look: looked.look });
-        if (expanded) {
-            for (const tool of settled) {
-                rows.push({ kind: 'work', id: tool.id, tool });
-            }
-        }
-    }
-    for (const tool of live) {
-        rows.push({ kind: 'work-live', id: tool.id, tool });
+  if (buffer.length === 0) {
+    return;
+  }
+  const tools = buffer.splice(0);
+  const live = tools.filter(tool => tool.state === 'running');
+  const settled = tools.filter(tool => tool.state !== 'running');
+  if (settled.length === 1) {
+    rows.push({
+      kind: 'work',
+      id: settled[0].id,
+      tool: settled[0]
+    });
+  } else if (settled.length > 1) {
+    const id = `group-${settled[0].id}`;
+    const expanded = options.expandedGroups.has(id);
+    const looked = lookSummary(settled, options.commandLooks);
+    rows.push(looked === null ? {
+      kind: 'work-group',
+      id,
+      tools: settled,
+      summary: summarizeGroup(settled),
+      expanded
+    } : {
+      kind: 'work-group',
+      id,
+      tools: settled,
+      summary: looked.summary,
+      expanded,
+      look: looked.look
+    });
+    if (expanded) {
+      for (const tool of settled) {
+        rows.push({
+          kind: 'work',
+          id: tool.id,
+          tool
+        });
+      }
     }
+  }
+  for (const tool of live) {
+    rows.push({
+      kind: 'work-live',
+      id: tool.id,
+      tool
+    });
+  }
 }
 function isImageRow(row) {
-    return (row.kind === 'work' || row.kind === 'work-live') && isImageGeneration(row.tool);
+  return (row.kind === 'work' || row.kind === 'work-live') && isImageGeneration(row.tool);
 }
 /* Rows for a run of items, in order, with tool runs folded and a subagent's work under its own row. */
 function rowsForItems(items, options, children) {
-    const rows = [];
-    const tools = [];
-    for (const item of items) {
-        if (parentOf(item) !== null) {
-            continue;
-        }
-        const report = handbackReportOf(item);
-        if (item.kind === 'tool' && item.workflow !== undefined) {
-            flushTools(tools, rows, options);
-            rows.push({ kind: 'workflow', id: item.id, tool: item, workflow: item.workflow });
-            continue;
-        }
-        if (item.kind === 'tool' && isImageGeneration(item)) {
-            flushTools(tools, rows, options);
-            rows.push({ kind: item.state === 'running' ? 'work-live' : 'work', id: item.id, tool: item });
-            continue;
-        }
-        if (item.kind === 'tool' && report === null) {
-            tools.push(item);
-            continue;
-        }
-        if (report !== null) {
-            flushTools(tools, rows, options);
-            rows.push({ kind: 'report', id: item.id, text: report });
-            continue;
-        }
-        flushTools(tools, rows, options);
-        switch (item.kind) {
-            case 'subagent':
-                rows.push({ kind: 'subagent', ...branchOf(item, options, children) });
-                break;
-            case 'user':
-                rows.push({ kind: 'user', id: item.id, item });
-                break;
-            case 'assistant':
-                if (item.text !== '' || item.streaming) {
-                    rows.push({ kind: 'assistant', id: item.id, item });
-                }
-                break;
-            case 'thinking':
-                rows.push({ kind: 'thinking', id: item.id, item });
-                break;
-            case 'approval':
-                // A pending one sits on the composer; only its outcome belongs in the transcript.
-                if (item.decision !== 'pending') {
-                    rows.push({ kind: 'approval', id: item.id, item });
-                }
-                break;
-            case 'question':
-                if (item.state !== 'pending') {
-                    rows.push({ kind: 'question', id: item.id, item });
-                }
-                break;
-            case 'note':
-                rows.push({ kind: 'note', id: item.id, level: item.level, text: item.text, ...(item.from === undefined ? {} : { from: item.from }) });
-                break;
-            case 'compaction':
-                rows.push({ kind: 'compaction', id: item.id, preTokens: item.preTokens });
-                break;
-            case 'turn':
-                break;
-        }
+  const rows = [];
+  const tools = [];
+  for (const item of items) {
+    if (parentOf(item) !== null) {
+      continue;
+    }
+    const report = handbackReportOf(item);
+    if (item.kind === 'tool' && item.workflow !== undefined) {
+      flushTools(tools, rows, options);
+      rows.push({
+        kind: 'workflow',
+        id: item.id,
+        tool: item,
+        workflow: item.workflow
+      });
+      continue;
+    }
+    if (item.kind === 'tool' && isImageGeneration(item)) {
+      flushTools(tools, rows, options);
+      rows.push({
+        kind: item.state === 'running' ? 'work-live' : 'work',
+        id: item.id,
+        tool: item
+      });
+      continue;
+    }
+    if (item.kind === 'tool' && report === null) {
+      tools.push(item);
+      continue;
+    }
+    if (report !== null) {
+      flushTools(tools, rows, options);
+      rows.push({
+        kind: 'report',
+        id: item.id,
+        text: report
+      });
+      continue;
     }
     flushTools(tools, rows, options);
-    return rows;
+    switch (item.kind) {
+      case 'subagent':
+        rows.push({
+          kind: 'subagent',
+          ...branchOf(item, options, children)
+        });
+        break;
+      case 'user':
+        rows.push({
+          kind: 'user',
+          id: item.id,
+          item
+        });
+        break;
+      case 'assistant':
+        if (item.text !== '' || item.streaming) {
+          rows.push({
+            kind: 'assistant',
+            id: item.id,
+            item
+          });
+        }
+        break;
+      case 'thinking':
+        rows.push({
+          kind: 'thinking',
+          id: item.id,
+          item
+        });
+        break;
+      case 'approval':
+        // A pending one sits on the composer; only its outcome belongs in the transcript.
+        if (item.decision !== 'pending') {
+          rows.push({
+            kind: 'approval',
+            id: item.id,
+            item
+          });
+        }
+        break;
+      case 'question':
+        if (item.state !== 'pending') {
+          rows.push({
+            kind: 'question',
+            id: item.id,
+            item
+          });
+        }
+        break;
+      case 'note':
+        rows.push({
+          kind: 'note',
+          id: item.id,
+          level: item.level,
+          text: item.text,
+          ...(item.from === undefined ? {} : {
+            from: item.from
+          })
+        });
+        break;
+      case 'compaction':
+        rows.push({
+          kind: 'compaction',
+          id: item.id,
+          preTokens: item.preTokens
+        });
+        break;
+      case 'turn':
+        break;
+    }
+  }
+  flushTools(tools, rows, options);
+  return rows;
 }
 /* The card of a settled turn: the checkpoint diff when the host took one, else what the tool calls carry. */
 function changedFilesRow(turn, items) {
-    const edits = items.filter((item) => item.kind === 'tool' && item.state === 'done' && isFileChange(item.name) && hasFileChanges(item));
-    const diff = turn.checkpointDiff ?? null;
-    const empty = diff === null ? edits.length === 0 : diff.files.length === 0;
-    if (empty) {
-        return null;
-    }
-    const moved = turn.checkpointHead !== undefined && turn.checkpointHeadAfter !== undefined && turn.checkpointHead !== turn.checkpointHeadAfter;
-    return {
-        kind: 'changed-files',
-        id: `files-${turn.id}`,
-        turnId: turn.id,
-        tools: edits,
-        diff,
-        checkpoint: turn.checkpoint !== undefined,
-        ...(moved ? { baseMoved: { from: turn.checkpointHead, to: turn.checkpointHeadAfter } } : {})
-    };
+  const edits = items.filter(item => item.kind === 'tool' && item.state === 'done' && isFileChange(item.name) && hasFileChanges(item));
+  const diff = turn.checkpointDiff ?? null;
+  const empty = diff === null ? edits.length === 0 : diff.files.length === 0;
+  if (empty) {
+    return null;
+  }
+  const moved = turn.checkpointHead !== undefined && turn.checkpointHeadAfter !== undefined && turn.checkpointHead !== turn.checkpointHeadAfter;
+  return {
+    kind: 'changed-files',
+    id: `files-${turn.id}`,
+    turnId: turn.id,
+    tools: edits,
+    diff,
+    checkpoint: turn.checkpoint !== undefined,
+    ...(moved ? {
+      baseMoved: {
+        from: turn.checkpointHead,
+        to: turn.checkpointHeadAfter
+      }
+    } : {})
+  };
 }
 /*
  * The closing answer of a settled turn. A turn may end on a call the person turned down, as an agent that stops
  * there does: the answer before it closes the turn, and the refused call and its denial stay in sight with it.
  */
 function lastAssistantRow(rows) {
-    const refused = new Set();
-    for (let i = rows.length - 1; i >= 0; i--) {
-        const row = rows[i];
-        if (row.kind === 'assistant') {
-            return row;
-        }
-        if (row.kind === 'approval' && row.item.decision === 'deny' && row.item.toolUseId !== null) {
-            refused.add(row.item.toolUseId);
-            continue;
-        }
-        if (row.kind === 'work' && refused.has(row.tool.toolUseId)) {
-            continue;
-        }
-        if (row.kind !== 'note' && !isImageRow(row)) {
-            return null;
-        }
+  const refused = new Set();
+  for (let i = rows.length - 1; i >= 0; i--) {
+    const row = rows[i];
+    if (row.kind === 'assistant') {
+      return row;
     }
-    return null;
+    if (row.kind === 'approval' && row.item.decision === 'deny' && row.item.toolUseId !== null) {
+      refused.add(row.item.toolUseId);
+      continue;
+    }
+    if (row.kind === 'work' && refused.has(row.tool.toolUseId)) {
+      continue;
+    }
+    if (row.kind !== 'note' && !isImageRow(row)) {
+      return null;
+    }
+  }
+  return null;
 }
 /*
  * The rows of a running turn with its latest thought over the call it led to, so what the model
@@ -349,106 +470,129 @@ function lastAssistantRow(rows) {
  * came after the call.
  */
 function withLiveThought(rows, items) {
-    const thoughtAt = items.findLastIndex((item) => item.kind === 'thinking' && parentOf(item) === null);
-    const thought = items[thoughtAt];
-    if (thought?.kind !== 'thinking' || thought.text === '') {
-        return rows;
-    }
-    const after = new Set(items.slice(thoughtAt + 1).map((item) => item.id));
-    const index = rows.findIndex((row) => row.kind === 'work-live' && after.has(row.tool.id));
-    const call = rows[index];
-    const shownAt = rows.findIndex((row) => row.kind === 'thinking' && row.id === thought.id);
-    const inSight = shownAt !== -1 && shownAt < index && !rows.slice(shownAt + 1, index).some((row) => row.kind === 'work');
-    if (call?.kind !== 'work-live' || inSight) {
-        return rows;
-    }
-    return [...rows.slice(0, index), { kind: 'live-thought', id: `live-thought-${thought.id}`, item: thought, at: call.tool.createdAt }, ...rows.slice(index)];
+  const thoughtAt = items.findLastIndex(item => item.kind === 'thinking' && parentOf(item) === null);
+  const thought = items[thoughtAt];
+  if (thought?.kind !== 'thinking' || thought.text === '') {
+    return rows;
+  }
+  const after = new Set(items.slice(thoughtAt + 1).map(item => item.id));
+  const index = rows.findIndex(row => row.kind === 'work-live' && after.has(row.tool.id));
+  const call = rows[index];
+  const shownAt = rows.findIndex(row => row.kind === 'thinking' && row.id === thought.id);
+  const inSight = shownAt !== -1 && shownAt < index && !rows.slice(shownAt + 1, index).some(row => row.kind === 'work');
+  if (call?.kind !== 'work-live' || inSight) {
+    return rows;
+  }
+  return [...rows.slice(0, index), {
+    kind: 'live-thought',
+    id: `live-thought-${thought.id}`,
+    item: thought,
+    at: call.tool.createdAt
+  }, ...rows.slice(index)];
 }
 /* Items grouped by turn, in order of first appearance; runs of turnless items keep their place. */
 function chunksByTurn(items) {
-    const chunks = [];
-    const byTurn = new Map();
-    for (const item of items) {
-        if (item.turnId === null) {
-            const last = chunks[chunks.length - 1];
-            if (last && last.turnId === null) {
-                last.items.push(item);
-            }
-            else {
-                chunks.push({ turnId: null, items: [item] });
-            }
-            continue;
-        }
-        let bucket = byTurn.get(item.turnId);
-        if (!bucket) {
-            bucket = [];
-            byTurn.set(item.turnId, bucket);
-            chunks.push({ turnId: item.turnId, items: bucket });
-        }
-        bucket.push(item);
+  const chunks = [];
+  const byTurn = new Map();
+  for (const item of items) {
+    if (item.turnId === null) {
+      const last = chunks[chunks.length - 1];
+      if (last && last.turnId === null) {
+        last.items.push(item);
+      } else {
+        chunks.push({
+          turnId: null,
+          items: [item]
+        });
+      }
+      continue;
     }
-    return chunks;
+    let bucket = byTurn.get(item.turnId);
+    if (!bucket) {
+      bucket = [];
+      byTurn.set(item.turnId, bucket);
+      chunks.push({
+        turnId: item.turnId,
+        items: bucket
+      });
+    }
+    bucket.push(item);
+  }
+  return chunks;
 }
 /* The whole thread as rows; items without a turn (older records) are shown as they are. */
 export function deriveTimelineRows(items, options) {
-    const rows = [];
-    const children = groupChildren(items);
-    for (const chunk of chunksByTurn(items)) {
-        if (chunk.turnId === null) {
-            rows.push(...rowsForItems(chunk.items, options, children));
-            continue;
-        }
-        const turnId = chunk.turnId;
-        const turn = chunk.items.find((item) => item.kind === 'turn');
-        const conversation = chunk.items.filter((item) => item.kind !== 'turn');
-        if (turn?.origin === 'agent') {
-            // The agent started this one itself, so there is no message of the person to show above it.
-            rows.push({ kind: 'turn-start', id: `start-${turnId}`, turn, label: agentTurnLabel(turn) });
-        }
-        const active = turnId === options.activeTurnId || turn?.state === 'running';
-        if (!turn || active) {
-            const live = rowsForItems(conversation, options, children);
-            rows.push(...(active ? withLiveThought(live, conversation) : live));
-            if (active) {
-                rows.push({ kind: 'working', id: `working-${turnId}`, startedAt: turn?.createdAt ?? Date.now() });
-            }
-            continue;
-        }
-        // Steering splits the conversation inside a turn. Earlier responses keep their place above it.
-        const lastUser = conversation.findLastIndex((item) => item.kind === 'user');
-        rows.push(...rowsForItems(conversation.slice(0, lastUser + 1), options, children));
-        const rest = conversation.slice(lastUser + 1);
-        const work = rowsForItems(rest, options, children);
-        // The closing answer stays visible; the work after the last input folds behind the label.
-        const finalAssistant = lastAssistantRow(work);
-        const before = finalAssistant ? work.slice(0, work.indexOf(finalAssistant)) : work;
-        // Images remain a turn's visible result, and a workflow or a background subagent may still be running after its turn ends.
-        const standing = before.filter((row) => isImageRow(row) || (row.kind === 'workflow' && row.tool.state === 'running') || (row.kind === 'subagent' && row.item.status === 'running'));
-        const folded = before.filter((row) => !standing.includes(row));
-        const expanded = options.expandedTurns.has(turnId);
-        if (folded.length > 0) {
-            const tools = rest.filter((item) => item.kind === 'tool' && parentOf(item) === null && handbackReportOf(item) === null && !isImageGeneration(item));
-            rows.push({
-                kind: 'turn-fold',
-                id: `fold-${turnId}`,
-                turn,
-                label: turnLabel(turn, chunk.items),
-                work: summarizeTurn(tools, options.commandLooks),
-                hiddenCount: folded.length,
-                expanded
-            });
-        }
-        rows.push(...(expanded ? before : standing));
-        const changed = changedFilesRow(turn, conversation);
-        if (changed) {
-            rows.push(changed);
-        }
-        if (finalAssistant) {
-            rows.push(...work.slice(work.indexOf(finalAssistant)));
-        }
-        if (options.forkedTurns?.has(turnId) === true) {
-            rows.push({ kind: 'forks', id: `forks-${turnId}`, turnId });
-        }
+  const rows = [];
+  const children = groupChildren(items);
+  for (const chunk of chunksByTurn(items)) {
+    if (chunk.turnId === null) {
+      rows.push(...rowsForItems(chunk.items, options, children));
+      continue;
     }
-    return rows;
-}
+    const turnId = chunk.turnId;
+    const turn = chunk.items.find(item => item.kind === 'turn');
+    const conversation = chunk.items.filter(item => item.kind !== 'turn');
+    if (turn?.origin === 'agent') {
+      // The agent started this one itself, so there is no message of the person to show above it.
+      rows.push({
+        kind: 'turn-start',
+        id: `start-${turnId}`,
+        turn,
+        label: agentTurnLabel(turn)
+      });
+    }
+    const active = turnId === options.activeTurnId || turn?.state === 'running';
+    if (!turn || active) {
+      const live = rowsForItems(conversation, options, children);
+      rows.push(...(active ? withLiveThought(live, conversation) : live));
+      if (active) {
+        rows.push({
+          kind: 'working',
+          id: `working-${turnId}`,
+          startedAt: turn?.createdAt ?? Date.now()
+        });
+      }
+      continue;
+    }
+    // Steering splits the conversation inside a turn. Earlier responses keep their place above it.
+    const lastUser = conversation.findLastIndex(item => item.kind === 'user');
+    rows.push(...rowsForItems(conversation.slice(0, lastUser + 1), options, children));
+    const rest = conversation.slice(lastUser + 1);
+    const work = rowsForItems(rest, options, children);
+    // The closing answer stays visible; the work after the last input folds behind the label.
+    const finalAssistant = lastAssistantRow(work);
+    const before = finalAssistant ? work.slice(0, work.indexOf(finalAssistant)) : work;
+    // Images remain a turn's visible result, and a workflow or a background subagent may still be running after its turn ends.
+    const standing = before.filter(row => isImageRow(row) || row.kind === 'workflow' && row.tool.state === 'running' || row.kind === 'subagent' && row.item.status === 'running');
+    const folded = before.filter(row => !standing.includes(row));
+    const expanded = options.expandedTurns.has(turnId);
+    if (folded.length > 0) {
+      const tools = rest.filter(item => item.kind === 'tool' && parentOf(item) === null && handbackReportOf(item) === null && !isImageGeneration(item));
+      rows.push({
+        kind: 'turn-fold',
+        id: `fold-${turnId}`,
+        turn,
+        label: turnLabel(turn, chunk.items),
+        work: summarizeTurn(tools, options.commandLooks),
+        hiddenCount: folded.length,
+        expanded
+      });
+    }
+    rows.push(...(expanded ? before : standing));
+    const changed = changedFilesRow(turn, conversation);
+    if (changed) {
+      rows.push(changed);
+    }
+    if (finalAssistant) {
+      rows.push(...work.slice(work.indexOf(finalAssistant)));
+    }
+    if (options.forkedTurns?.has(turnId) === true) {
+      rows.push({
+        kind: 'forks',
+        id: `forks-${turnId}`,
+        turnId
+      });
+    }
+  }
+  return rows;
+}