Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
feat(web): collapse tool activity into one line (#7152)
maria4a9edff4c109
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsxindex 336f7ed82..ec32db182 100644--- a/apps/web/src/components/ChatView.tsx+++ b/apps/web/src/components/ChatView.tsx@@ -561,8 +561,10 @@ function useLocalDispatchState(input: {threadError: string | null | undefined;}) {const [localDispatch, setLocalDispatch] = useState<LocalDispatchSnapshot | null>(null);- const latestUserMessageId =- input.activeThread?.messages.findLast((message) => message.role === "user")?.id ?? null;+ const latestUserMessage = input.activeThread?.messages.findLast(+ (message) => message.role === "user",+ );+ const latestUserMessageId = latestUserMessage?.id ?? null;const resetLocalDispatch = useCallback(() => {setLocalDispatch(null);@@ -612,6 +614,7 @@ function useLocalDispatchState(input: {beginLocalDispatch,resetLocalDispatch,localDispatchStartedAt: activeLocalDispatch?.startedAt ?? null,+ latestUserMessageAt: latestUserMessage?.createdAt ?? null,isPreparingWorktree: activeLocalDispatch?.preparingWorktree ?? false,isSendBusy: activeLocalDispatch !== null,};@@ -2325,6 +2328,7 @@ function ChatViewContent(props: ChatViewProps) {beginLocalDispatch,resetLocalDispatch,localDispatchStartedAt,+ latestUserMessageAt,isPreparingWorktree,isSendBusy,} = useLocalDispatchState({@@ -2340,6 +2344,7 @@ function ChatViewContent(props: ChatViewProps) {activeLatestTurn,activeThread?.session ?? null,localDispatchStartedAt,+ latestUserMessageAt,);useEffect(() => {attachmentPreviewHandoffByMessageIdRef.current = attachmentPreviewHandoffByMessageId;@@ -6389,7 +6394,6 @@ function ChatViewContent(props: ChatViewProps) {key={activeThread.id}isWorking={isWorking}workingStepLabel={workingStepLabel}- activeTurnInProgress={isWorking || !latestTurnSettled}activeTurnStartedAt={activeWorkStartedAt}listRef={legendListRef}timelineEntries={timelineEntries}diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.logic.test.tsindex 70a330d46..6d9a9c37e 100644--- a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts+++ b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts@@ -545,7 +545,7 @@ describe("deriveMessagesTimelineRows", () => {"user-entry","turn-fold:turn-1","assistant-thought-entry",- "work-entry-1",+ "work-toggle:work-entry-1","assistant-final-entry",]);expect(@@ -800,12 +800,362 @@ describe("deriveMessagesTimelineRows", () => {expect(rows.some((row) => row.kind === "turn-fold")).toBe(false);expect(rows.map((row) => row.id)).toEqual([- "assistant-thought-entry",- "work-entry-1","working-indicator-row",+ "assistant-thought-entry",+ "work-live:work-entry-1",+ ]);+ });++ it("keeps adjacent active tool calls in one replacing row", () => {+ const rows = deriveMessagesTimelineRows({+ timelineEntries: [+ {+ id: "completed-command-entry",+ kind: "work",+ createdAt: "2026-01-01T00:00:05Z",+ entry: {+ id: "completed-command",+ createdAt: "2026-01-01T00:00:05Z",+ turnId: "turn-1" as never,+ label: "Ran rg",+ command: "rg toolCall",+ requestKind: "command",+ tone: "tool" as const,+ toolLifecycleStatus: "completed" as const,+ },+ },+ {+ id: "completed-edit-entry",+ kind: "work",+ createdAt: "2026-01-01T00:00:06Z",+ entry: {+ id: "completed-edit",+ createdAt: "2026-01-01T00:00:06Z",+ turnId: "turn-1" as never,+ label: "Edited files",+ requestKind: "file-change",+ changedFiles: ["src/one.ts", "src/two.ts"],+ tone: "tool" as const,+ toolLifecycleStatus: "completed" as const,+ },+ },+ {+ id: "running-command-entry",+ kind: "work",+ createdAt: "2026-01-01T00:00:07Z",+ entry: {+ id: "running-command",+ createdAt: "2026-01-01T00:00:07Z",+ turnId: "turn-1" as never,+ label: "Running tests",+ command: "vp test run",+ requestKind: "command",+ tone: "tool" as const,+ toolLifecycleStatus: "inProgress" as const,+ },+ },+ ],+ latestTurn: {+ turnId: "turn-1" as never,+ state: "running",+ startedAt: "2026-01-01T00:00:00Z",+ completedAt: null,+ },+ isWorking: true,+ activeTurnStartedAt: "2026-01-01T00:00:00Z",+ turnDiffSummaryByAssistantMessageId: new Map(),+ revertTurnCountByUserMessageId: new Map(),+ });++ expect(rows.map((row) => row.kind)).toEqual(["working", "work-live"]);+ expect(rows.find((row) => row.kind === "work-live")).toMatchObject({+ entry: { id: "running-command" },+ groupedEntries: [+ { id: "completed-command" },+ { id: "completed-edit" },+ { id: "running-command" },+ ],+ });+ });++ it("summarizes a tool run after commentary starts a new run", () => {+ const rows = deriveMessagesTimelineRows({+ timelineEntries: [+ {+ id: "completed-command-entry",+ kind: "work",+ createdAt: "2026-01-01T00:00:05Z",+ entry: {+ id: "completed-command",+ createdAt: "2026-01-01T00:00:05Z",+ turnId: "turn-1" as never,+ label: "Ran rg",+ command: "rg toolCall",+ requestKind: "command",+ tone: "tool" as const,+ toolLifecycleStatus: "completed" as const,+ },+ },+ {+ id: "assistant-commentary-entry",+ kind: "message",+ createdAt: "2026-01-01T00:00:06Z",+ message: {+ id: "assistant-commentary" as never,+ role: "assistant",+ text: "Checking another thing.",+ turnId: "turn-1" as never,+ createdAt: "2026-01-01T00:00:06Z",+ updatedAt: "2026-01-01T00:00:06Z",+ streaming: false,+ },+ },+ {+ id: "running-command-entry",+ kind: "work",+ createdAt: "2026-01-01T00:00:07Z",+ entry: {+ id: "running-command",+ createdAt: "2026-01-01T00:00:07Z",+ turnId: "turn-1" as never,+ label: "Running tests",+ command: "vp test run",+ requestKind: "command",+ tone: "tool" as const,+ toolLifecycleStatus: "inProgress" as const,+ },+ },+ ],+ latestTurn: {+ turnId: "turn-1" as never,+ state: "running",+ startedAt: "2026-01-01T00:00:00Z",+ completedAt: null,+ },+ isWorking: true,+ activeTurnStartedAt: "2026-01-01T00:00:00Z",+ turnDiffSummaryByAssistantMessageId: new Map(),+ revertTurnCountByUserMessageId: new Map(),+ });++ expect(rows.map((row) => row.kind)).toEqual(["working", "work-toggle", "message", "work-live"]);+ expect(rows.find((row) => row.kind === "work-toggle")).toMatchObject({+ hiddenCount: 1,+ summary: "Ran 1 command",+ });+ });++ it("keeps separated in-progress tool runs visible", () => {+ const rows = deriveMessagesTimelineRows({+ timelineEntries: [+ {+ id: "first-running-entry",+ kind: "work",+ createdAt: "2026-01-01T00:00:05Z",+ entry: {+ id: "first-running",+ createdAt: "2026-01-01T00:00:05Z",+ turnId: "turn-1" as never,+ label: "Running first command",+ command: "rg first",+ requestKind: "command",+ tone: "tool" as const,+ toolLifecycleStatus: "inProgress" as const,+ },+ },+ {+ id: "assistant-commentary-entry",+ kind: "message",+ createdAt: "2026-01-01T00:00:06Z",+ message: {+ id: "assistant-commentary" as never,+ role: "assistant",+ text: "Starting another command.",+ turnId: "turn-1" as never,+ createdAt: "2026-01-01T00:00:06Z",+ updatedAt: "2026-01-01T00:00:06Z",+ streaming: false,+ },+ },+ {+ id: "second-running-entry",+ kind: "work",+ createdAt: "2026-01-01T00:00:07Z",+ entry: {+ id: "second-running",+ createdAt: "2026-01-01T00:00:07Z",+ turnId: "turn-1" as never,+ label: "Running second command",+ command: "rg second",+ requestKind: "command",+ tone: "tool" as const,+ toolLifecycleStatus: "inProgress" as const,+ },+ },+ ],+ latestTurn: {+ turnId: "turn-1" as never,+ state: "running",+ startedAt: "2026-01-01T00:00:00Z",+ completedAt: null,+ },+ isWorking: true,+ activeTurnStartedAt: "2026-01-01T00:00:00Z",+ turnDiffSummaryByAssistantMessageId: new Map(),+ revertTurnCountByUserMessageId: new Map(),+ });++ expect(rows.map((row) => row.kind)).toEqual(["working", "work-live", "message", "work-live"]);+ expect(rows.filter((row) => row.kind === "work-live").map((row) => row.entry.id)).toEqual([+ "first-running",+ "second-running",]);});+ it("does not revive stale in-progress tools before a fresh send has a turn id", () => {+ const rows = deriveMessagesTimelineRows({+ timelineEntries: [+ {+ id: "stale-running-entry",+ kind: "work",+ createdAt: "2026-01-01T00:00:05Z",+ entry: {+ id: "stale-running",+ createdAt: "2026-01-01T00:00:05Z",+ turnId: "turn-1" as never,+ label: "Running stale command",+ command: "rg stale",+ requestKind: "command",+ tone: "tool" as const,+ toolLifecycleStatus: "inProgress" as const,+ },+ },+ {+ id: "user-followup-entry",+ kind: "message",+ createdAt: "2026-01-01T00:01:00Z",+ message: {+ id: "user-followup" as never,+ role: "user",+ text: "continue",+ turnId: null,+ createdAt: "2026-01-01T00:01:00Z",+ updatedAt: "2026-01-01T00:01:00Z",+ streaming: false,+ },+ },+ ],+ latestTurn: null,+ isWorking: true,+ activeTurnStartedAt: "2026-01-01T00:01:00Z",+ turnDiffSummaryByAssistantMessageId: new Map(),+ revertTurnCountByUserMessageId: new Map(),+ });++ expect(rows.some((row) => row.kind === "work-live")).toBe(false);+ });++ it("does not revive separated historical task progress", () => {+ const rows = deriveMessagesTimelineRows({+ timelineEntries: [+ {+ id: "stale-progress-entry",+ kind: "work",+ createdAt: "2026-01-01T00:00:05Z",+ entry: {+ id: "stale-progress",+ createdAt: "2026-01-01T00:00:05Z",+ turnId: "turn-1" as never,+ label: "Old progress",+ tone: "thinking" as const,+ sourceActivityKind: "task.progress" as const,+ },+ },+ {+ id: "assistant-commentary-entry",+ kind: "message",+ createdAt: "2026-01-01T00:00:06Z",+ message: {+ id: "assistant-commentary" as never,+ role: "assistant",+ text: "Starting another command.",+ turnId: "turn-1" as never,+ createdAt: "2026-01-01T00:00:06Z",+ updatedAt: "2026-01-01T00:00:06Z",+ streaming: false,+ },+ },+ {+ id: "running-command-entry",+ kind: "work",+ createdAt: "2026-01-01T00:00:07Z",+ entry: {+ id: "running-command",+ createdAt: "2026-01-01T00:00:07Z",+ turnId: "turn-1" as never,+ label: "Running command",+ command: "rg current",+ requestKind: "command",+ tone: "tool" as const,+ toolLifecycleStatus: "inProgress" as const,+ },+ },+ ],+ latestTurn: {+ turnId: "turn-1" as never,+ state: "running",+ startedAt: "2026-01-01T00:00:00Z",+ completedAt: null,+ },+ isWorking: true,+ activeTurnStartedAt: "2026-01-01T00:00:00Z",+ turnDiffSummaryByAssistantMessageId: new Map(),+ revertTurnCountByUserMessageId: new Map(),+ });++ expect(rows.filter((row) => row.kind === "work-live").map((row) => row.entry.id)).toEqual([+ "running-command",+ ]);+ });++ it("keeps the latest completed tool call live while the turn is running", () => {+ const rows = deriveMessagesTimelineRows({+ timelineEntries: [+ {+ id: "latest-command-entry",+ kind: "work",+ createdAt: "2026-01-01T00:00:05Z",+ entry: {+ id: "latest-command",+ createdAt: "2026-01-01T00:00:05Z",+ turnId: "turn-1" as never,+ label: "Ran rg",+ command: "rg toolCall",+ requestKind: "command",+ tone: "tool" as const,+ toolLifecycleStatus: "completed" as const,+ },+ },+ ],+ latestTurn: {+ turnId: "turn-1" as never,+ state: "running",+ startedAt: "2026-01-01T00:00:00Z",+ completedAt: null,+ },+ isWorking: true,+ activeTurnStartedAt: "2026-01-01T00:00:00Z",+ turnDiffSummaryByAssistantMessageId: new Map(),+ revertTurnCountByUserMessageId: new Map(),+ });++ expect(rows.map((row) => row.kind)).toEqual(["working", "work-live"]);+ expect(rows.find((row) => row.kind === "work-live")).toMatchObject({+ entry: { id: "latest-command" },+ groupedEntries: [{ id: "latest-command" }],+ });+ });+it("does not fold the session's running turn when latestTurn regresses", () => {const rows = deriveMessagesTimelineRows({timelineEntries: [@@ -864,7 +1214,7 @@ describe("deriveMessagesTimelineRows", () => {expect(rows.filter((row) => row.kind === "turn-fold").map((row) => row.turnId)).toEqual(["turn-1",]);- expect(rows.map((row) => row.id)).toContain("running-work-entry");+ expect(rows.map((row) => row.id)).toContain("work-live:running-work-entry");});it("only shows assistant metadata on the terminal assistant message", () => {@@ -1006,18 +1356,19 @@ describe("deriveMessagesTimelineRows", () => {expandedWorkGroupIds: new Set(["work-group:work-entry-1"]),});- expect(collapsedRows.map((row) => row.id)).toEqual(["work-3", "work-toggle:work-entry-1"]);+ expect(collapsedRows.map((row) => row.id)).toEqual(["work-toggle:work-entry-1"]);expect(collapsedRows.find((row) => row.kind === "work-toggle")).toMatchObject({groupId: "work-group:work-entry-1",- hiddenCount: 2,+ hiddenCount: 3,expanded: false,onlyToolEntries: true,+ summary: "Used 3 tools",});expect(expandedRows.map((row) => row.id)).toEqual([+ "work-toggle:work-entry-1","work-1","work-2","work-3",- "work-toggle:work-entry-1",]);expect(expandedRows.find((row) => row.kind === "work-toggle")).toMatchObject({expanded: true,diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.tsindex c89bbd055..716a72ea8 100644--- a/apps/web/src/components/chat/MessagesTimeline.logic.ts+++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts@@ -1,6 +1,7 @@import * as Equal from "effect/Equal";import {formatDuration,+ workEntryDisplayIndicatesToolFailure,workEntryIndicatesToolNeutralStatus,workLogEntryIsToolLike,type TimelineEntry,@@ -17,6 +18,18 @@ export const TIMELINE_MINIMAP_MAX_HEIGHT_CSS = "calc(100vh - 18rem)";export const TIMELINE_CONTENT_MAX_WIDTH = 768;export const TIMELINE_MINIMAP_PERSISTENT_GUTTER = 48;+export function workEntryIsVisibleInGroup(+ entry: WorkLogEntry,+ expandedToolGroupEntry = false,+): boolean {+ return (+ (expandedToolGroupEntry &&+ (entry.toolLifecycleStatus === "inProgress" ||+ entry.sourceActivityKind === "task.progress")) ||+ !workEntryIndicatesToolNeutralStatus(entry)+ );+}+export interface TimelineEndState {readonly isAtEnd?: boolean;readonly contentLength?: number;@@ -170,6 +183,17 @@ export type MessagesTimelineRow =id: string;createdAt: string;groupedEntries: WorkLogEntry[];+ isExpandedToolGroupEntry: boolean;+ isLastExpandedToolGroupEntry: boolean;+ }+ | {+ kind: "work-live";+ id: string;+ createdAt: string;+ entry: WorkLogEntry;+ groupedEntries: WorkLogEntry[];+ groupId: string;+ expanded: boolean;}| {kind: "work-toggle";@@ -179,6 +203,9 @@ export type MessagesTimelineRow =hiddenCount: number;expanded: boolean;onlyToolEntries: boolean;+ summary: string | null;+ summaryKind: ToolGroupSummaryKind | null;+ hasFailure: boolean;}| {kind: "turn-fold";@@ -212,7 +239,12 @@ export type MessagesTimelineRow =createdAt: string;turnPlan: TurnPlanEntry;}- | { kind: "working"; id: string; createdAt: string | null };+ | {+ kind: "working";+ id: string;+ createdAt: string | null;+ showThinking: boolean;+ };export interface StableMessagesTimelineRowsState {byId: Map<string, MessagesTimelineRow>;@@ -242,6 +274,161 @@ export function normalizeCompactToolLabel(value: string): string {return value.replace(/\s+(?:complete|completed)\s*$/i, "").trim();}+type ToolGroupAction = "read" | "edit" | "command" | "code-search" | "search" | "other";+type ToolGroupSummaryKind = ToolGroupAction | "dynamic-tool" | "agent-tool" | "tone-tool" | "mixed";++export function workLogEntryIsLocalCodeSearch(entry: WorkLogEntry): boolean {+ return (+ entry.itemType === "web_search" &&+ /\bgrep\b/i.test(normalizeCompactToolLabel(entry.toolTitle ?? entry.label))+ );+}++export function toolGroupAction(entry: WorkLogEntry): ToolGroupAction {+ if (+ entry.requestKind === "file-read" ||+ entry.itemType === "image_view" ||+ (entry.itemType === "dynamic_tool_call" && entry.toolTitle === "Read File")+ ) {+ return "read";+ }+ if (+ entry.requestKind === "file-change" ||+ entry.itemType === "file_change" ||+ (entry.changedFiles?.length ?? 0) > 0+ ) {+ return "edit";+ }+ if (entry.requestKind === "command" || entry.itemType === "command_execution" || entry.command) {+ return "command";+ }+ if (workLogEntryIsLocalCodeSearch(entry)) return "code-search";+ if (entry.itemType === "web_search") return "search";+ return "other";+}++function toolGroupActionCount(+ action: ToolGroupAction,+ entries: ReadonlyArray<WorkLogEntry>,+): number {+ if (action !== "edit") return entries.length;++ const changedFiles = new Set<string>();+ let editsWithoutFileDetails = 0;+ for (const entry of entries) {+ if (!entry.changedFiles || entry.changedFiles.length === 0) {+ editsWithoutFileDetails += 1;+ continue;+ }+ for (const file of entry.changedFiles) changedFiles.add(file);+ }+ return changedFiles.size + editsWithoutFileDetails;+}++function toolGroupActionLabel(action: ToolGroupAction, count: number): string {+ switch (action) {+ case "read":+ return `Read ${count} ${count === 1 ? "file" : "files"}`;+ case "edit":+ return `Changed ${count} ${count === 1 ? "file" : "files"}`;+ case "command":+ return `Ran ${count} ${count === 1 ? "command" : "commands"}`;+ case "search":+ return `Searched the web ${count} ${count === 1 ? "time" : "times"}`;+ case "code-search":+ return `Searched code ${count} ${count === 1 ? "time" : "times"}`;+ case "other":+ return `Used ${count} ${count === 1 ? "tool" : "tools"}`;+ }+}++/** Immediate, provider-neutral fallback while generated tool summaries are disabled or unavailable. */+export function summarizeToolGroup(entries: ReadonlyArray<WorkLogEntry>): string {+ const summaryEntries = omitSupersededLifecycleMarkers(entries, (entry) => entry);+ const groupedEntries = new Map<ToolGroupAction, WorkLogEntry[]>();+ for (const entry of summaryEntries) {+ const action = toolGroupAction(entry);+ const group = groupedEntries.get(action);+ if (group) group.push(entry);+ else groupedEntries.set(action, [entry]);+ }+ const labels = [...groupedEntries].map(([action, actionEntries]) =>+ toolGroupActionLabel(action, toolGroupActionCount(action, actionEntries)),+ );+ const sentenceLabels = labels.map((label, index) =>+ index === 0 ? label : label.charAt(0).toLowerCase() + label.slice(1),+ );+ if (sentenceLabels.length < 2) return sentenceLabels[0] ?? "";+ if (sentenceLabels.length === 2) return sentenceLabels.join(" and ");+ return `${sentenceLabels.slice(0, -1).join(", ")}, and ${sentenceLabels.at(-1)}`;+}++function omitSupersededLifecycleMarkers<T>(+ entries: readonly T[],+ workEntryFor: (entry: T) => WorkLogEntry,+): T[] {+ const laterTerminalIdentities = new Set<string>();+ const reversedEntries: T[] = [];++ for (let index = entries.length - 1; index >= 0; index -= 1) {+ const entry = entries[index]!;+ const workEntry = workEntryFor(entry);+ const normalizedLabel = normalizeCompactToolLabel(workEntry.toolTitle ?? workEntry.label);+ const identity = [+ workEntry.turnId ?? "no-turn",+ workEntry.itemType ?? "",+ normalizedLabel,+ ].join("\u001f");+ const isStatuslessIdlessMarker =+ workEntry.toolCallId === undefined &&+ workEntry.toolLifecycleStatus === undefined &&+ (workEntry.sourceActivityKind === "tool.started" ||+ workEntry.sourceActivityKind === "tool.updated");+ if (isStatuslessIdlessMarker && laterTerminalIdentities.has(identity)) continue;++ reversedEntries.push(entry);+ if (+ workEntry.sourceActivityKind === "tool.completed" ||+ (workEntry.toolLifecycleStatus !== undefined &&+ workEntry.toolLifecycleStatus !== "inProgress")+ ) {+ laterTerminalIdentities.add(identity);+ }+ }++ return reversedEntries.toReversed();+}++function toolGroupSummaryKind(entries: ReadonlyArray<WorkLogEntry>): ToolGroupSummaryKind {+ const actions = new Set(entries.map(toolGroupAction));+ if (actions.size !== 1) return "mixed";++ const action = actions.values().next().value!;+ if (action !== "other") return action;++ const fallbackKinds = new Set(+ entries.map((entry): ToolGroupSummaryKind => {+ if (entry.itemType === "mcp_tool_call") return "other";+ if (entry.itemType === "dynamic_tool_call") return "dynamic-tool";+ if (entry.itemType === "collab_agent_tool_call" || entry.taskId) return "agent-tool";+ if (entry.tone === "thinking") return "agent-tool";+ if (entry.tone === "tool") return "tone-tool";+ return "other";+ }),+ );+ return fallbackKinds.size === 1 ? fallbackKinds.values().next().value! : "mixed";+}++function workGroupIdentity(timelineEntryId: string, entry: WorkLogEntry): string {+ return entry.toolCallId+ ? `tool:${entry.turnId ?? "no-turn"}:${entry.toolCallId}`+ : timelineEntryId;+}++function workGroupId(timelineEntryId: string, entry: WorkLogEntry): string {+ return `work-group:${workGroupIdentity(timelineEntryId, entry)}`;+}+export function resolveAssistantMessageCopyState({text,showCopyButton,@@ -314,6 +501,25 @@ function deriveUnsettledTurnId(return isSettled ? null : latestTurn.turnId;}+function lastUserMessageIndex(timelineEntries: ReadonlyArray<TimelineEntry>): number {+ return timelineEntries.findLastIndex(+ (entry) => entry.kind === "message" && entry.message.role === "user",+ );+}++function timelineEntryTurnId(entry: TimelineEntry): TurnId | null {+ if (entry.kind === "message") {+ return entry.message.role === "assistant" ? (entry.message.turnId ?? null) : null;+ }+ if (entry.kind === "turn-plan") {+ return entry.turnPlan.turnId;+ }+ if (entry.kind === "proposed-plan") {+ return entry.proposedPlan.turnId;+ }+ return entry.kind === "work" ? (entry.entry.turnId ?? null) : null;+}+/*** Settled turns fold their commentary and tool activity behind a* "Worked for ..." row anchored at the turn's first foldable entry; the@@ -481,21 +687,132 @@ export function deriveMessagesTimelineRows(input: {}}+ let activeTurnHeaderIndex = input.timelineEntries.length;+ if (input.isWorking) {+ const latestUserMessageIndex = lastUserMessageIndex(input.timelineEntries);+ const firstOwnedAfterUser =+ unsettledTurnId === null+ ? -1+ : input.timelineEntries.findIndex(+ (entry, index) =>+ index > latestUserMessageIndex && timelineEntryTurnId(entry) === unsettledTurnId,+ );+ activeTurnHeaderIndex =+ firstOwnedAfterUser >= 0 ? firstOwnedAfterUser : latestUserMessageIndex + 1;+ }+ const entryBelongsToActiveTurn = (entry: TimelineEntry, index: number) =>+ input.isWorking &&+ index >= activeTurnHeaderIndex &&+ (unsettledTurnId === null || timelineEntryTurnId(entry) === unsettledTurnId);+ const workEntryIsInActiveRun = (entry: WorkLogEntry) =>+ input.isWorking &&+ unsettledTurnId !== null &&+ entry.toolLifecycleStatus === "inProgress" &&+ entry.turnId === unsettledTurnId;+ const isVisibleActiveToolEntry = (entry: WorkLogEntry) =>+ workLogEntryIsToolLike(entry) && workEntryIsVisibleInGroup(entry, true);+ const activeEntries = input.isWorking+ ? input.timelineEntries.filter((entry, index) => entryBelongsToActiveTurn(entry, index))+ : [];+ const activeTurnHasVisibleContent = activeEntries.some((entry) => {+ if (entry.kind === "message") {+ return entry.message.role === "assistant" && (entry.message.text?.trim().length ?? 0) > 0;+ }+ if (entry.kind === "work") {+ return (+ entry.entry.agentSpawn === undefined &&+ workLogEntryIsToolLike(entry.entry) &&+ entry.entry.toolLifecycleStatus === "inProgress"+ );+ }+ if (entry.kind === "proposed-plan" || entry.kind === "turn-plan") return true;+ return false;+ });++ const activeToolEntries: Array<Extract<TimelineEntry, { kind: "work" }>> = [];+ for (let index = input.timelineEntries.length - 1; index >= activeTurnHeaderIndex; index -= 1) {+ const entry = input.timelineEntries[index]!;+ if (+ !entryBelongsToActiveTurn(entry, index) ||+ entry.kind !== "work" ||+ entry.entry.agentSpawn !== undefined ||+ entry.entry.tone === "error" ||+ !workLogEntryIsToolLike(entry.entry)+ ) {+ break;+ }+ activeToolEntries.unshift(entry);+ }+ const activeWorkEntryIds = new Set(activeToolEntries.map((entry) => entry.id));+ const visibleActiveToolEntries = omitSupersededLifecycleMarkers(+ activeToolEntries.filter((entry) => isVisibleActiveToolEntry(entry.entry)),+ (entry) => entry.entry,+ );+ const activeWorkAnchor = activeToolEntries[0];+ const latestActiveToolEntry = visibleActiveToolEntries.at(-1);+ const activeWorkPlacementEntryId = latestActiveToolEntry?.id;+ const activeWorkRow =+ activeWorkAnchor && latestActiveToolEntry+ ? (() => {+ const groupId = workGroupId(activeWorkAnchor.id, activeWorkAnchor.entry);+ return {+ kind: "work-live" as const,+ id: `work-live:${workGroupIdentity(activeWorkAnchor.id, activeWorkAnchor.entry)}`,+ createdAt: activeWorkAnchor.createdAt,+ entry: latestActiveToolEntry.entry,+ groupedEntries: visibleActiveToolEntries.map((entry) => entry.entry),+ groupId,+ expanded: input.expandedWorkGroupIds?.has(groupId) ?? false,+ };+ })()+ : null;+ const appendWorkingRow = () => {+ nextRows.push({+ kind: "working",+ id: "working-indicator-row",+ createdAt: input.activeTurnStartedAt,+ showThinking: activeWorkRow === null && !activeTurnHasVisibleContent,+ });+ };+ const appendActiveWorkRows = () => {+ if (activeWorkRow === null) return;+ nextRows.push(activeWorkRow);+ if (!activeWorkRow.expanded) return;+ for (const [entryIndex, workEntry] of activeWorkRow.groupedEntries.entries()) {+ nextRows.push({+ kind: "work",+ id: workEntry.id,+ createdAt: workEntry.createdAt,+ groupedEntries: [workEntry],+ isExpandedToolGroupEntry: true,+ isLastExpandedToolGroupEntry: entryIndex === activeWorkRow.groupedEntries.length - 1,+ });+ }+ };+for (let index = 0; index < input.timelineEntries.length; index += 1) {const timelineEntry = input.timelineEntries[index];if (!timelineEntry) {continue;}- const turnFold = foldsByAnchorEntryId.get(timelineEntry.id);- if (turnFold) {+ if (input.isWorking && index === activeTurnHeaderIndex) {+ appendWorkingRow();+ }++ if (timelineEntry.id === activeWorkPlacementEntryId) {+ appendActiveWorkRows();+ }++ const anchoredTurnFold = foldsByAnchorEntryId.get(timelineEntry.id);+ if (anchoredTurnFold) {nextRows.push({kind: "turn-fold",- id: `turn-fold:${turnFold.turnId}`,- createdAt: turnFold.createdAt,- turnId: turnFold.turnId,- label: turnFold.label,- expanded: input.expandedTurnIds?.has(turnFold.turnId) ?? false,+ id: `turn-fold:${anchoredTurnFold.turnId}`,+ createdAt: anchoredTurnFold.createdAt,+ turnId: anchoredTurnFold.turnId,+ label: anchoredTurnFold.label,+ expanded: input.expandedTurnIds?.has(anchoredTurnFold.turnId) ?? false,});}@@ -503,6 +820,10 @@ export function deriveMessagesTimelineRows(input: {continue;}+ if (activeWorkEntryIds.has(timelineEntry.id)) {+ continue;+ }+if (timelineEntry.kind === "work") {const groupedEntries = [timelineEntry.entry];let cursor = index + 1;@@ -511,6 +832,7 @@ export function deriveMessagesTimelineRows(input: {if (!nextEntry ||nextEntry.kind !== "work" ||+ activeWorkEntryIds.has(nextEntry.id) ||collapsedEntryIds.has(nextEntry.id) ||foldsByAnchorEntryId.has(nextEntry.id)) {@@ -519,19 +841,86 @@ export function deriveMessagesTimelineRows(input: {groupedEntries.push(nextEntry.entry);cursor += 1;}- const visibleGroupedEntries = groupedEntries.filter(- (entry) => !workEntryIndicatesToolNeutralStatus(entry),+ const visibleGroupedEntries = omitSupersededLifecycleMarkers(+ groupedEntries.filter((entry) =>+ workEntryIsVisibleInGroup(entry, workEntryIsInActiveRun(entry)),+ ),+ (entry) => entry,);if (visibleGroupedEntries.length > 0) {- if (visibleGroupedEntries.length <= MAX_VISIBLE_WORK_LOG_ENTRIES) {+ const onlyToolEntries = visibleGroupedEntries.every(+ (entry) =>+ workLogEntryIsToolLike(entry) &&+ entry.agentSpawn === undefined &&+ entry.tone !== "error",+ );+ const activeInProgressToolEntries = visibleGroupedEntries.filter(workEntryIsInActiveRun);+ if (onlyToolEntries && activeInProgressToolEntries.length > 0) {+ const groupId = workGroupId(timelineEntry.id, timelineEntry.entry);+ const expanded = input.expandedWorkGroupIds?.has(groupId) ?? false;+ const latestActiveToolEntry = activeInProgressToolEntries.at(-1)!;+ nextRows.push({+ kind: "work-live",+ id: `work-live:${workGroupIdentity(timelineEntry.id, timelineEntry.entry)}`,+ createdAt: timelineEntry.createdAt,+ entry: latestActiveToolEntry,+ groupedEntries: visibleGroupedEntries,+ groupId,+ expanded,+ });+ if (expanded) {+ for (const [entryIndex, workEntry] of visibleGroupedEntries.entries()) {+ nextRows.push({+ kind: "work",+ id: workEntry.id,+ createdAt: workEntry.createdAt,+ groupedEntries: [workEntry],+ isExpandedToolGroupEntry: true,+ isLastExpandedToolGroupEntry: entryIndex === visibleGroupedEntries.length - 1,+ });+ }+ }+ } else if (onlyToolEntries) {+ const groupId = workGroupId(timelineEntry.id, timelineEntry.entry);+ const expanded = input.expandedWorkGroupIds?.has(groupId) ?? false;+ const summaryKind = toolGroupSummaryKind(visibleGroupedEntries);+ nextRows.push({+ kind: "work-toggle",+ id: `work-toggle:${timelineEntry.id}`,+ createdAt: timelineEntry.createdAt,+ groupId,+ hiddenCount: visibleGroupedEntries.length,+ expanded,+ onlyToolEntries: true,+ summary: summarizeToolGroup(visibleGroupedEntries),+ summaryKind,+ hasFailure: visibleGroupedEntries.some((entry) =>+ workEntryDisplayIndicatesToolFailure(entry),+ ),+ });+ if (expanded) {+ for (const [entryIndex, workEntry] of visibleGroupedEntries.entries()) {+ nextRows.push({+ kind: "work",+ id: workEntry.id,+ createdAt: workEntry.createdAt,+ groupedEntries: [workEntry],+ isExpandedToolGroupEntry: true,+ isLastExpandedToolGroupEntry: entryIndex === visibleGroupedEntries.length - 1,+ });+ }+ }+ } else if (visibleGroupedEntries.length <= MAX_VISIBLE_WORK_LOG_ENTRIES) {nextRows.push({kind: "work",id: timelineEntry.id,createdAt: timelineEntry.createdAt,groupedEntries: visibleGroupedEntries,+ isExpandedToolGroupEntry: false,+ isLastExpandedToolGroupEntry: false,});} else {- const groupId = `work-group:${timelineEntry.id}`;+ const groupId = workGroupId(timelineEntry.id, timelineEntry.entry);const expanded = input.expandedWorkGroupIds?.has(groupId) ?? false;// Agent-spawn CTA rows are always visible: a running fleet must// never hide behind a "+N tool calls" toggle. Selection is by@@ -555,6 +944,8 @@ export function deriveMessagesTimelineRows(input: {id: workEntry.id,createdAt: workEntry.createdAt,groupedEntries: [workEntry],+ isExpandedToolGroupEntry: false,+ isLastExpandedToolGroupEntry: false,});}@@ -566,8 +957,11 @@ export function deriveMessagesTimelineRows(input: {groupId,hiddenCount: hiddenEntries.length,expanded,- onlyToolEntries: visibleGroupedEntries.every((entry) =>- workLogEntryIsToolLike(entry),+ onlyToolEntries: hiddenEntries.every(workLogEntryIsToolLike),+ summary: null,+ summaryKind: null,+ hasFailure: hiddenEntries.some((entry) =>+ workEntryDisplayIndicatesToolFailure(entry),),});}@@ -633,12 +1027,8 @@ export function deriveMessagesTimelineRows(input: {});}- if (input.isWorking) {- nextRows.push({- kind: "working",- id: "working-indicator-row",- createdAt: input.activeTurnStartedAt,- });+ if (input.isWorking && activeTurnHeaderIndex === input.timelineEntries.length) {+ appendWorkingRow();}return nextRows;@@ -670,7 +1060,9 @@ function isRowUnchanged(a: MessagesTimelineRow, b: MessagesTimelineRow): booleanswitch (a.kind) {case "working":- return a.createdAt === (b as typeof a).createdAt;+ return (+ a.createdAt === (b as typeof a).createdAt && a.showThinking === (b as typeof a).showThinking+ );case "turn-fold": {const bf = b as typeof a;@@ -687,8 +1079,25 @@ function isRowUnchanged(a: MessagesTimelineRow, b: MessagesTimelineRow): booleanreturn a.createdAt === bp.createdAt && a.turnPlan.plan === bp.turnPlan.plan;}- case "work":- return Equal.equals(a.groupedEntries, (b as typeof a).groupedEntries);+ case "work": {+ const bw = b as typeof a;+ return (+ a.isExpandedToolGroupEntry === bw.isExpandedToolGroupEntry &&+ a.isLastExpandedToolGroupEntry === bw.isLastExpandedToolGroupEntry &&+ Equal.equals(a.groupedEntries, bw.groupedEntries)+ );+ }++ case "work-live": {+ const bw = b as typeof a;+ return (+ a.createdAt === bw.createdAt &&+ a.groupId === bw.groupId &&+ a.expanded === bw.expanded &&+ Equal.equals(a.entry, bw.entry) &&+ Equal.equals(a.groupedEntries, bw.groupedEntries)+ );+ }case "work-toggle": {const bw = b as typeof a;@@ -697,7 +1106,10 @@ function isRowUnchanged(a: MessagesTimelineRow, b: MessagesTimelineRow): booleana.groupId === bw.groupId &&a.hiddenCount === bw.hiddenCount &&a.expanded === bw.expanded &&- a.onlyToolEntries === bw.onlyToolEntries+ a.onlyToolEntries === bw.onlyToolEntries &&+ a.summary === bw.summary &&+ a.summaryKind === bw.summaryKind &&+ a.hasFailure === bw.hasFailure);}diff --git a/apps/web/src/components/chat/MessagesTimeline.test.tsx b/apps/web/src/components/chat/MessagesTimeline.test.tsxindex 617ee0b80..1969f0000 100644--- a/apps/web/src/components/chat/MessagesTimeline.test.tsx+++ b/apps/web/src/components/chat/MessagesTimeline.test.tsx@@ -176,7 +176,6 @@ const MESSAGE_CREATED_AT = "2026-03-17T19:12:28.000Z";function buildProps() {return {isWorking: false,- activeTurnInProgress: false,activeTurnStartedAt: null,listRef: createRef<LegendListRef | null>(),latestTurn: null,@@ -237,6 +236,44 @@ function buildAssistantTimelineEntry(text: string) {}describe("MessagesTimeline", () => {+ it("renders the worked-for row at assistant response text size", () => {+ const turnId = TurnId.make("turn-with-fold");+ const assistantEntry = buildAssistantTimelineEntry("Done.");+ const markup = renderToStaticMarkup(+ <MessagesTimeline+ {...buildProps()}+ latestTurn={{+ turnId,+ state: "completed",+ startedAt: "2026-03-17T19:12:20.000Z",+ completedAt: "2026-03-17T19:12:28.000Z",+ }}+ timelineEntries={[+ {+ id: "work-entry-with-fold",+ kind: "work",+ createdAt: "2026-03-17T19:12:22.000Z",+ entry: {+ id: "work-with-fold",+ createdAt: "2026-03-17T19:12:22.000Z",+ turnId,+ label: "Ran command",+ tone: "tool",+ toolLifecycleStatus: "completed",+ },+ },+ {+ ...assistantEntry,+ message: { ...assistantEntry.message, turnId },+ },+ ]}+ />,+ );++ expect(markup).toContain("Worked for 8.0s");+ expect(markup).toContain("px-1 text-sm leading-relaxed text-muted-foreground");+ });+it("uses the larger leading inset only when the top fade is enabled", () => {const timelineEntries = [buildUserTimelineEntry("Hello")];@@ -700,7 +737,7 @@ describe("MessagesTimeline", () => {expect(markup).toContain("Work Log");});- it("formats changed file paths from the workspace root", () => {+ it("summarizes changed files in one line", () => {const markup = renderToStaticMarkup(<MessagesTimeline{...buildProps()}@@ -722,10 +759,159 @@ describe("MessagesTimeline", () => {/>,);- expect(markup).toContain("t3code/apps/web/src/session-logic.ts");+ expect(markup).toContain("Changed 1 file");expect(markup).not.toContain("C:/Users/mike/dev-stuff/t3code/apps/web/src/session-logic.ts");});+ it("shows the animated one-line label for a live tool group", () => {+ const turnId = TurnId.make("turn-live");+ const markup = renderToStaticMarkup(+ <MessagesTimeline+ {...buildProps()}+ isWorking+ activeTurnStartedAt={MESSAGE_CREATED_AT}+ latestTurn={{+ turnId,+ state: "running",+ startedAt: MESSAGE_CREATED_AT,+ completedAt: null,+ }}+ runningTurnId={turnId}+ timelineEntries={[+ {+ id: "entry-live",+ kind: "work",+ createdAt: MESSAGE_CREATED_AT,+ entry: {+ id: "work-live",+ createdAt: MESSAGE_CREATED_AT,+ turnId,+ toolCallId: "call-live",+ label: "Run tests",+ tone: "tool",+ itemType: "command_execution",+ command: "pnpm test",+ toolLifecycleStatus: "inProgress",+ },+ },+ ]}+ />,+ );++ expect(markup).toContain("Working for");+ expect(markup).toContain("Running pnpm");+ expect(markup).toContain("live-activity-focus");+ });++ it("scopes a live row failure to the tool named by the row", () => {+ const turnId = TurnId.make("turn-live");+ const markup = renderToStaticMarkup(+ <MessagesTimeline+ {...buildProps()}+ isWorking+ activeTurnStartedAt={MESSAGE_CREATED_AT}+ latestTurn={{+ turnId,+ state: "running",+ startedAt: MESSAGE_CREATED_AT,+ completedAt: null,+ }}+ runningTurnId={turnId}+ timelineEntries={[+ {+ id: "entry-failed",+ kind: "work",+ createdAt: MESSAGE_CREATED_AT,+ entry: {+ id: "work-failed",+ createdAt: MESSAGE_CREATED_AT,+ turnId,+ toolCallId: "call-failed",+ label: "Run lint",+ tone: "tool",+ itemType: "command_execution",+ command: "pnpm lint",+ toolLifecycleStatus: "failed",+ },+ },+ {+ id: "entry-running",+ kind: "work",+ createdAt: MESSAGE_CREATED_AT,+ entry: {+ id: "work-running",+ createdAt: MESSAGE_CREATED_AT,+ turnId,+ toolCallId: "call-running",+ label: "Run tests",+ tone: "tool",+ itemType: "command_execution",+ command: "pnpm test",+ toolLifecycleStatus: "inProgress",+ },+ },+ ]}+ />,+ );++ expect(markup).toContain("Running pnpm");+ expect(markup).not.toContain("tool call failed");+ });++ it("keeps terminal command copy live while the parent turn is active", () => {+ const turnId = TurnId.make("turn-live");+ const markup = renderToStaticMarkup(+ <MessagesTimeline+ {...buildProps()}+ isWorking+ activeTurnStartedAt={MESSAGE_CREATED_AT}+ latestTurn={{+ turnId,+ state: "running",+ startedAt: MESSAGE_CREATED_AT,+ completedAt: null,+ }}+ runningTurnId={turnId}+ timelineEntries={[+ {+ id: "entry-failed",+ kind: "work",+ createdAt: MESSAGE_CREATED_AT,+ entry: {+ id: "work-failed",+ createdAt: MESSAGE_CREATED_AT,+ turnId,+ toolCallId: "call-failed",+ label: "Run lint",+ tone: "tool",+ itemType: "command_execution",+ command: "pnpm lint",+ toolLifecycleStatus: "failed",+ },+ },+ ]}+ />,+ );++ expect(markup).toContain("Running pnpm");+ expect(markup).toContain("tool call failed");+ });++ it("aligns the iconless Thinking row with the working timer", () => {+ const markup = renderToStaticMarkup(+ <MessagesTimeline+ {...buildProps()}+ isWorking+ activeTurnStartedAt={MESSAGE_CREATED_AT}+ timelineEntries={[]}+ />,+ );++ expect(markup).toContain("Working for");+ expect(markup).toContain("Thinking");+ expect(markup).toContain("gap-1.5 py-0.5 px-1");+ });+it("renders review comment contexts as structured cards instead of raw tags", () => {const markup = renderToStaticMarkup(<MessagesTimelinediff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsxindex c90aa771f..8b724d08b 100644--- a/apps/web/src/components/chat/MessagesTimeline.tsx+++ b/apps/web/src/components/chat/MessagesTimeline.tsx@@ -33,9 +33,7 @@ import { LegendList, type LegendListRef } from "@legendapp/list/react";import { FileDiff } from "@pierre/diffs/react";import {deriveTimelineEntries,- workEntryIndicatesToolFailure,- workEntryIndicatesToolNeutralStatus,- workEntryIndicatesToolSuccess,+ workEntryDisplayIndicatesToolFailure,workLogEntryIsToolLike,} from "../../session-logic";import { type TurnDiffSummary } from "../../types";@@ -57,7 +55,7 @@ import {MessageCircleIcon,MousePointerClickIcon,PaintbrushIcon,- MinusIcon,+ SearchIcon,SquarePenIcon,TerminalIcon,Undo2Icon,@@ -84,6 +82,8 @@ import {resolveTimelineMinimapInteractiveWidth,resolveTimelineMinimapTopPercent,shouldPreserveAssistantLineBreaks,+ toolGroupAction,+ workEntryIsVisibleInGroup,type StableMessagesTimelineRowsState,type MessagesTimelineRow,TIMELINE_MINIMAP_MIN_ITEMS,@@ -150,7 +150,6 @@ interface TimelineRowSharedState {interface TimelineRowActivityState {isWorking: boolean;isRevertingCheckpoint: boolean;- activeTurnInProgress: boolean;latestTurnId: TurnId | null;/** Current plan step label for the working row, when the turn has a plan. */workingStepLabel: string | null;@@ -207,7 +206,6 @@ interface MessagesTimelineProps {onOpenAgents?: () => void;isWorking: boolean;workingStepLabel?: string | null;- activeTurnInProgress: boolean;activeTurnStartedAt: string | null;listRef: React.RefObject<LegendListRef | null>;timelineEntries: ReturnType<typeof deriveTimelineEntries>;@@ -251,7 +249,6 @@ interface MessagesTimelineProps {export const MessagesTimeline = memo(function MessagesTimeline({isWorking,workingStepLabel = null,- activeTurnInProgress,activeTurnStartedAt,agentPanelModel = EMPTY_AGENT_PANEL_MODEL,onOpenAgents = NOOP_OPEN_AGENTS,@@ -540,11 +537,10 @@ export const MessagesTimeline = memo(function MessagesTimeline({() => ({isWorking,isRevertingCheckpoint,- activeTurnInProgress,latestTurnId: latestTurn?.turnId ?? null,workingStepLabel,}),- [activeTurnInProgress, isRevertingCheckpoint, isWorking, latestTurn?.turnId, workingStepLabel],+ [isRevertingCheckpoint, isWorking, latestTurn?.turnId, workingStepLabel],);// Stable renderItem — no closure deps. Row components read shared state@@ -921,17 +917,34 @@ type TimelineWorkEntry = Extract<MessagesTimelineRow, { kind: "work" }>["groupedtype TimelineRow = MessagesTimelineRow;const TimelineRowContent = memo(function TimelineRowContent({ row }: { row: TimelineRow }) {+ const isExpandedToolGroupEntry = row.kind === "work" && row.isExpandedToolGroupEntry;+ const isLastExpandedToolGroupEntry = row.kind === "work" && row.isLastExpandedToolGroupEntry;+ const isExpandedToolGroupHeader =+ (row.kind === "work-toggle" && row.summary !== null && row.onlyToolEntries && row.expanded) ||+ (row.kind === "work-live" && row.expanded);+return (<divclassName={cn(// Commentary (non-terminal assistant) rows carry no metadata row, so// they sit closer to the work that follows them.- (row.kind === "message" && row.message.role === "assistant" && !row.showAssistantMeta) ||- row.kind === "work" ||- row.kind === "work-toggle" ||- row.kind === "turn-plan"- ? "pb-2"- : "pb-4",+ isExpandedToolGroupEntry+ ? isLastExpandedToolGroupEntry+ ? "pb-1"+ : "pb-0"+ : isExpandedToolGroupHeader+ ? "pb-0"+ : row.kind === "turn-fold" || row.kind === "working"+ ? "pb-1.5"+ : (row.kind === "message" &&+ row.message.role === "assistant" &&+ !row.showAssistantMeta) ||+ row.kind === "work" ||+ row.kind === "work-live" ||+ row.kind === "work-toggle" ||+ row.kind === "turn-plan"+ ? "pb-2"+ : "pb-4",row.kind === "message" && row.message.role === "assistant" ? "group/assistant" : null,)}data-timeline-row-id={row.id}@@ -939,7 +952,13 @@ const TimelineRowContent = memo(function TimelineRowContent({ row }: { row: Timedata-message-id={row.kind === "message" ? row.message.id : undefined}data-message-role={row.kind === "message" ? row.message.role : undefined}>- {row.kind === "work" ? <WorkGroupSection groupedEntries={row.groupedEntries} /> : null}+ {row.kind === "work" ? (+ <WorkGroupSection+ groupedEntries={row.groupedEntries}+ isExpandedToolGroupEntry={row.isExpandedToolGroupEntry}+ />+ ) : null}+ {row.kind === "work-live" ? <LiveWorkEntryTimelineRow row={row} /> : null}{row.kind === "work-toggle" ? <WorkGroupToggleTimelineRow row={row} /> : null}{row.kind === "turn-fold" ? <TurnFoldTimelineRow row={row} /> : null}{row.kind === "message" && row.message.role === "user" ? <UserTimelineRow row={row} /> : null}@@ -1093,7 +1112,7 @@ function TurnFoldTimelineRow({ row }: { row: Extract<TimelineRow, { kind: "turn-aria-expanded={row.expanded}data-scroll-anchor-ignoreonClick={() => ctx.onToggleTurnFold(row.turnId)}- className="flex cursor-pointer select-none items-center gap-1 rounded-md px-1 text-xs text-muted-foreground tabular-nums transition-colors hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring/70"+ className="flex cursor-pointer select-none items-center gap-1 rounded-md px-1 text-sm leading-relaxed text-muted-foreground tabular-nums transition-colors hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring/70"><span>{row.label}</span><Icon className="size-3.5" />@@ -1282,14 +1301,9 @@ const TurnPlanTimelineRow = memo(function TurnPlanTimelineRow({function WorkingTimelineRow({ row }: { row: Extract<TimelineRow, { kind: "working" }> }) {const { workingStepLabel } = use(TimelineRowActivityCtx);return (- <div className="py-0.5 pl-1.5">- <div className="flex min-w-0 items-center gap-2 pt-1 text-secondary-label text-[11px] tabular-nums">- <span className="inline-flex items-center gap-[3px]">- <span className="h-1 w-1 rounded-full bg-muted-foreground/30 animate-status-pulse" />- <span className="h-1 w-1 rounded-full bg-muted-foreground/30 animate-status-pulse [animation-delay:200ms]" />- <span className="h-1 w-1 rounded-full bg-muted-foreground/30 animate-status-pulse [animation-delay:400ms]" />- </span>- <span className="shrink-0">+ <div>+ <div className="border-b border-border/60 pb-2 pt-1">+ <div className="px-1 text-sm leading-relaxed text-muted-foreground tabular-nums">{row.createdAt ? (<>Working for <WorkingTimer createdAt={row.createdAt} />@@ -1297,11 +1311,16 @@ function WorkingTimelineRow({ row }: { row: Extract<TimelineRow, { kind: "workin) : ("Working...")}- </span>- {workingStepLabel ? (- <span className="min-w-0 truncate text-muted-foreground/55">· {workingStepLabel}</span>- ) : null}+ {workingStepLabel ? (+ <span className="ml-2 text-muted-foreground/55">· {workingStepLabel}</span>+ ) : null}+ </div></div>+ {row.showThinking ? (+ <div className="mt-1">+ <ThinkingActivityRow />+ </div>+ ) : null}</div>);}@@ -1342,13 +1361,16 @@ function WorkingTimer({ createdAt }: { createdAt: string }) {/** Renders one or more already-derived work log rows. Overflow expansion is modeled as LegendList data. */const WorkGroupSection = memo(function WorkGroupSection({groupedEntries,+ isExpandedToolGroupEntry,}: {groupedEntries: Extract<MessagesTimelineRow, { kind: "work" }>["groupedEntries"];+ isExpandedToolGroupEntry: boolean;}) {const { workspaceRoot } = use(TimelineRowCtx);const nonEmptyEntries = useMemo(- () => groupedEntries.filter((entry) => !workEntryIndicatesToolNeutralStatus(entry)),- [groupedEntries],+ () =>+ groupedEntries.filter((entry) => workEntryIsVisibleInGroup(entry, isExpandedToolGroupEntry)),+ [groupedEntries, isExpandedToolGroupEntry],);const onlyToolEntries = nonEmptyEntries.every((entry) => workLogEntryIsToolLike(entry));const groupLabel = onlyToolEntries@@ -1356,11 +1378,15 @@ const WorkGroupSection = memo(function WorkGroupSection({? "1 tool call": `${nonEmptyEntries.length} tool calls`: "Work Log";+ const GroupContainer = isExpandedToolGroupEntry ? "div" : "section";if (nonEmptyEntries.length === 0) return null;return (- <section className="-mx-1 space-y-0.5 px-1 py-0.5" aria-label={groupLabel}>+ <GroupContainer+ className={cn("-mx-1 px-1", isExpandedToolGroupEntry ? "py-0" : "space-y-0.5 py-0.5")}+ aria-label={isExpandedToolGroupEntry ? undefined : groupLabel}+ >{!onlyToolEntries && (<p className="px-0.5 pb-0.5 font-medium text-secondary-label text-[11px]">{groupLabel}</p>)}@@ -1370,19 +1396,170 @@ const WorkGroupSection = memo(function WorkGroupSection({key={workEntry.id}workEntry={workEntry}workspaceRoot={workspaceRoot}+ isExpandedToolGroupEntry={isExpandedToolGroupEntry}/>))}</div>- </section>+ </GroupContainer>);});+function LiveActivityRow({+ label,+ iconName,+ failed = false,+}: {+ label: string;+ iconName?: WorkEntryIconName;+ failed?: boolean;+}) {+ return (+ <div className="relative min-h-6 w-fit max-w-full min-w-0 overflow-hidden rounded-md text-sm leading-relaxed">+ <LiveActivityContent+ label={label}+ iconName={iconName}+ failed={failed}+ announceFailure={failed}+ />+ <div+ aria-hidden+ className="live-activity-focus pointer-events-none absolute inset-y-0 select-none"+ >+ <div className="live-activity-focus-counter">+ <div className="live-activity-focus-aligned">+ <LiveActivityContent label={label} iconName={iconName} failed={failed} highlighted />+ </div>+ </div>+ </div>+ </div>+ );+}++function ThinkingActivityRow() {+ return <LiveActivityRow label="Thinking" />;+}++function LiveActivityContent({+ label,+ iconName,+ failed = false,+ announceFailure = false,+ highlighted = false,+}: {+ label: string;+ iconName: WorkEntryIconName | undefined;+ failed?: boolean;+ announceFailure?: boolean;+ highlighted?: boolean;+}) {+ const resolvedIconName = failed ? "x" : iconName;++ return (+ <div+ className={cn(+ "flex min-h-6 min-w-0 items-center gap-1.5 py-0.5",+ resolvedIconName ? "px-0.5" : "px-1",+ highlighted ? "text-foreground" : "text-secondary-label",+ )}+ >+ {resolvedIconName ? (+ <span+ className={cn(+ "flex size-6 shrink-0 items-center justify-center",+ failed ? "text-destructive" : highlighted ? "text-foreground" : "text-icon-muted",+ )}+ role={announceFailure ? "img" : undefined}+ aria-label={announceFailure ? "Tool call failed" : undefined}+ >+ <WorkEntryIconSvg+ name={resolvedIconName}+ className={cn("block size-4 shrink-0 stroke-[1.8]", !highlighted && "opacity-70")}+ />+ </span>+ ) : null}+ <span className="min-w-0 flex-1 truncate">{label}</span>+ </div>+ );+}++function LiveWorkEntryTimelineRow({ row }: { row: Extract<TimelineRow, { kind: "work-live" }> }) {+ const ctx = use(TimelineRowCtx);+ const label = liveWorkEntryLabel(row.entry, ctx.workspaceRoot);+ const failed = workEntryDisplayIndicatesToolFailure(row.entry);++ return (+ <button+ type="button"+ className="group/live-work flex min-h-6 w-full max-w-full cursor-pointer items-center rounded-md text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring/70"+ aria-label={failed ? `${label}, tool call failed` : undefined}+ aria-expanded={row.expanded}+ onClick={() => ctx.onToggleWorkGroup(row.groupId, row.id)}+ >+ <LiveActivityRow label={label} iconName={workEntryIconName(row.entry)} failed={failed} />+ </button>+ );+}++function toolGroupSummaryIconName(+ kind: Extract<TimelineRow, { kind: "work-toggle" }>["summaryKind"],+): WorkEntryIconName {+ switch (kind) {+ case "read":+ return "eye";+ case "edit":+ return "square-pen";+ case "command":+ return "terminal";+ case "search":+ return "globe";+ case "code-search":+ return "search";+ case "other":+ return "wrench";+ case "dynamic-tool":+ return "hammer";+ case "agent-tool":+ return "bot";+ case "tone-tool":+ return "zap";+ case "mixed":+ case null:+ return "hammer";+ }+}+function WorkGroupToggleTimelineRow({row,}: {row: Extract<TimelineRow, { kind: "work-toggle" }>;}) {const ctx = use(TimelineRowCtx);+ if (row.onlyToolEntries && row.summary) {+ return (+ <button+ type="button"+ className="group/tool-group flex min-h-6 w-full cursor-pointer items-center gap-1.5 rounded-md px-0.5 py-0.5 text-left text-sm leading-relaxed transition-colors duration-150 hover:bg-accent/20 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring/70"+ aria-label={row.hasFailure ? `${row.summary}, tool call failed` : undefined}+ aria-expanded={row.expanded}+ onClick={() => ctx.onToggleWorkGroup(row.groupId, row.id)}+ >+ <span+ className={cn(+ "flex size-6 shrink-0 items-center justify-center",+ row.hasFailure ? "text-destructive" : "text-icon-muted",+ )}+ role={row.hasFailure ? "img" : undefined}+ aria-label={row.hasFailure ? "Tool call failed" : undefined}+ >+ <WorkEntryIconSvg+ name={row.hasFailure ? "x" : toolGroupSummaryIconName(row.summaryKind)}+ className="size-4 shrink-0 stroke-[1.8] opacity-70"+ />+ </span>+ <span className="min-w-0 flex-1 truncate text-secondary-label">{row.summary}</span>+ </button>+ );+ }const labelNoun = row.onlyToolEntries? row.hiddenCount === 1? "tool call"@@ -1390,21 +1567,33 @@ function WorkGroupToggleTimelineRow({: row.hiddenCount === 1? "log entry": "log entries";+ const showHiddenFailure = row.hasFailure && !row.expanded;return (<buttontype="button"- className="flex w-full cursor-pointer items-center gap-1.5 rounded-md px-0.5 py-0.5 text-left text-[12px] leading-5 transition-colors duration-150 hover:bg-accent/20 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring/70"+ className="flex min-h-6 w-full cursor-pointer items-center gap-1.5 rounded-md px-0.5 py-0.5 text-left text-sm leading-relaxed transition-colors duration-150 hover:bg-accent/20 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring/70"aria-expanded={row.expanded}onClick={() => ctx.onToggleWorkGroup(row.groupId, row.id)}>- <span className="flex size-5 shrink-0 items-center justify-center text-icon-muted">- <ChevronDownIcon- className={cn(- "size-3.5 shrink-0 opacity-70 transition-transform duration-200",- row.expanded && "rotate-180",- )}- />+ <span+ className={cn(+ "flex size-6 shrink-0 items-center justify-center",+ showHiddenFailure ? "text-destructive" : "text-icon-muted",+ )}+ role={showHiddenFailure ? "img" : undefined}+ aria-label={showHiddenFailure ? "Hidden work includes a failure" : undefined}+ >+ {showHiddenFailure ? (+ <WorkEntryIconSvg name="x" className="size-4 shrink-0 stroke-[1.8] opacity-70" />+ ) : (+ <ChevronDownIcon+ className={cn(+ "size-4 shrink-0 opacity-70 transition-transform duration-200",+ row.expanded && "rotate-180",+ )}+ />+ )}</span>{row.expanded ? (<span className="font-medium text-foreground">@@ -1947,6 +2136,7 @@ type WorkEntryIconName =| "globe"| "hammer"| "message-circle"+ | "search"| "square-pen"| "terminal"| "wrench"@@ -1969,6 +2159,8 @@ function WorkEntryIconSvg({ name, className }: { name: WorkEntryIconName; classNreturn <HammerIcon className={className} aria-hidden />;case "message-circle":return <MessageCircleIcon className={className} aria-hidden />;+ case "search":+ return <SearchIcon className={className} aria-hidden />;case "square-pen":return <SquarePenIcon className={className} aria-hidden />;case "terminal":@@ -2035,6 +2227,192 @@ function workEntryRawCommand(return rawCommand === workEntry.command.trim() ? null : rawCommand;}+type CommandWrapper = "env" | "sudo";++const COMMAND_WRAPPER_OPTIONS_WITH_VALUE: Record<CommandWrapper, ReadonlySet<string>> = {+ env: new Set(["-C", "--chdir", "-S", "--split-string", "-u", "--unset"]),+ sudo: new Set(["-C", "--close-from", "-D", "--chdir", "-g", "--group", "-u", "--user"]),+};++const COMMAND_WRAPPER_FLAGS: Record<CommandWrapper, ReadonlySet<string>> = {+ env: new Set(["-0", "--null", "-i", "--ignore-environment", "--debug", "-v"]),+ sudo: new Set(["-A", "--askpass", "-b", "--background", "-E", "-H", "-i", "-n", "-S"]),+};++function tokenizeShellCommand(command: string): string[] | null {+ const input = command.trim();+ const tokens: string[] = [];+ let current = "";+ let quote: '"' | "'" | null = null;+ let escaping = false;+ let substitutionDepth = 0;+ let tokenStarted = false;++ for (let index = 0; index < input.length; index += 1) {+ const character = input[index]!;+ if (escaping) {+ current += character;+ escaping = false;+ tokenStarted = true;+ continue;+ }+ if (character === "\\" && quote !== "'") {+ const nextCharacter = input[index + 1];+ const isWindowsDrivePath = quote === null && /^[A-Za-z]:/.test(current);+ if (+ (quote === '"' || isWindowsDrivePath) &&+ nextCharacter !== undefined &&+ nextCharacter !== '"' &&+ nextCharacter !== "\\" &&+ nextCharacter !== "$" &&+ nextCharacter !== "`" &&+ nextCharacter !== "\n"+ ) {+ current += character;+ tokenStarted = true;+ continue;+ }+ escaping = true;+ tokenStarted = true;+ continue;+ }+ if (quote !== null) {+ if (character === quote) {+ quote = null;+ } else {+ current += character;+ }+ tokenStarted = true;+ continue;+ }+ if (character === "$" && input[index + 1] === "(") {+ current += "$(";+ substitutionDepth += 1;+ tokenStarted = true;+ index += 1;+ continue;+ }+ if (character === ")" && substitutionDepth > 0) {+ current += character;+ substitutionDepth -= 1;+ tokenStarted = true;+ continue;+ }+ if (character === '"' || character === "'") {+ quote = character;+ tokenStarted = true;+ continue;+ }+ if (/\s/u.test(character)) {+ if (substitutionDepth > 0) {+ current += character;+ tokenStarted = true;+ continue;+ }+ if (tokenStarted) {+ tokens.push(current);+ current = "";+ tokenStarted = false;+ }+ continue;+ }+ current += character;+ tokenStarted = true;+ }++ if (quote !== null || escaping || substitutionDepth > 0) return null;+ if (tokenStarted) tokens.push(current);+ return tokens;+}++function commandProgramName(command: string, depth = 0): string | null {+ if (depth >= 8) return null;+ const tokens = tokenizeShellCommand(command);+ if (tokens === null) return null;+ let index = 0;+ let wrapper: CommandWrapper | null = null;++ while (index < tokens.length) {+ const token = tokens[index];+ if (!token) return null;+ if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(token)) {+ index += 1;+ continue;+ }+ const tokenProgram = token.split(/[\\/]/).at(-1);+ if (tokenProgram === "env" || tokenProgram === "sudo") {+ wrapper = tokenProgram;+ index += 1;+ continue;+ }+ if (wrapper !== null && token === "--") {+ wrapper = null;+ index += 1;+ continue;+ }+ if (wrapper !== null && token.startsWith("-")) {+ if (wrapper === "env" && (token === "-S" || token === "--split-string")) {+ const splitCommand = tokens[index + 1];+ return splitCommand ? commandProgramName(splitCommand, depth + 1) : null;+ }+ if (wrapper === "env" && token.startsWith("--split-string=")) {+ return commandProgramName(token.slice("--split-string=".length), depth + 1);+ }+ if (COMMAND_WRAPPER_OPTIONS_WITH_VALUE[wrapper].has(token)) {+ if (tokens[index + 1] === undefined) return null;+ index += 2;+ continue;+ }+ if (COMMAND_WRAPPER_FLAGS[wrapper].has(token)) {+ index += 1;+ continue;+ }+ const equalsIndex = token.indexOf("=");+ if (token.startsWith("--") && equalsIndex > 2) {+ if (!COMMAND_WRAPPER_OPTIONS_WITH_VALUE[wrapper].has(token.slice(0, equalsIndex))) {+ return null;+ }+ index += 1;+ continue;+ }+ if (/^-[A-Za-z].+/.test(token) && !token.startsWith("--")) {+ let consumesNextToken = false;+ for (const [optionIndex, option] of token.slice(1).split("").entries()) {+ const shortOption = `-${option}`;+ if (COMMAND_WRAPPER_OPTIONS_WITH_VALUE[wrapper].has(shortOption)) {+ consumesNextToken = optionIndex === token.length - 2;+ break;+ }+ if (!COMMAND_WRAPPER_FLAGS[wrapper].has(shortOption)) return null;+ }+ if (consumesNextToken && tokens[index + 1] === undefined) return null;+ index += consumesNextToken ? 2 : 1;+ continue;+ }+ return null;+ }+ return token.split(/[\\/]/).at(-1) || null;+ }++ return null;+}++function liveWorkEntryLabel(+ workEntry: TimelineWorkEntry,+ workspaceRoot: string | undefined,+): string {+ const command = workEntry.command?.trim();+ if (command) {+ // This row describes the active parent turn, not the command lifecycle.+ // Keep its live "Running" copy until the turn or contiguous tool run settles.+ const program = commandProgramName(command);+ if (program) return `Running ${program}`;+ return "Running command";+ }++ return workEntryPreview(workEntry, workspaceRoot) ?? toolWorkEntryHeading(workEntry);+}+function buildToolCallExpandedBody(workEntry: TimelineWorkEntry,workspaceRoot: string | undefined,@@ -2073,18 +2451,8 @@ function workEntryIconName(workEntry: TimelineWorkEntry): WorkEntryIconName {) {return "message-circle";}- if (workEntry.requestKind === "command") return "terminal";- if (workEntry.requestKind === "file-read") return "eye";- if (workEntry.requestKind === "file-change") return "square-pen";-- if (workEntry.itemType === "command_execution" || workEntry.command) {- return "terminal";- }- if (workEntry.itemType === "file_change" || (workEntry.changedFiles?.length ?? 0) > 0) {- return "square-pen";- }- if (workEntry.itemType === "web_search") return "globe";- if (workEntry.itemType === "image_view") return "eye";+ const action = toolGroupAction(workEntry);+ if (action !== "other") return toolGroupSummaryIconName(action);switch (workEntry.itemType) {case "mcp_tool_call":@@ -2217,43 +2585,43 @@ const AgentSpawnCtaRow = memo(function AgentSpawnCtaRow(props: { workEntry: Timeconst SimpleWorkEntryRow = memo(function SimpleWorkEntryRow(props: {workEntry: TimelineWorkEntry;workspaceRoot: string | undefined;+ isExpandedToolGroupEntry: boolean;}) {- const { workEntry, workspaceRoot } = props;+ const { workEntry, workspaceRoot, isExpandedToolGroupEntry } = props;// Before any hooks: spawn CTA rows render their own component.if (workEntry.agentSpawn) {return <AgentSpawnCtaRow workEntry={workEntry} />;}- return <PlainWorkEntryRow workEntry={workEntry} workspaceRoot={workspaceRoot} />;+ return (+ <PlainWorkEntryRow+ workEntry={workEntry}+ workspaceRoot={workspaceRoot}+ isExpandedToolGroupEntry={isExpandedToolGroupEntry}+ />+ );});const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {workEntry: TimelineWorkEntry;workspaceRoot: string | undefined;+ isExpandedToolGroupEntry: boolean;}) {- const { workEntry, workspaceRoot } = props;- const activity = use(TimelineRowActivityCtx);+ const { workEntry, workspaceRoot, isExpandedToolGroupEntry } = props;const [expanded, setExpanded] = useState(false);const iconConfig = workToneIcon(workEntry.tone);const showWarningIndicator = workEntry.sourceActivityKind === "runtime.warning";- const entryIconName = showWarningIndicator ? "x" : workEntryIconName(workEntry);- const heading = toolWorkEntryHeading(workEntry);- const rawPreview = workEntryPreview(workEntry, workspaceRoot);- const preview =- rawPreview &&- normalizeCompactToolLabel(rawPreview).toLowerCase() ===- normalizeCompactToolLabel(heading).toLowerCase()- ? null- : rawPreview;- const displayText = preview ? `${heading} - ${preview}` : heading;+ const showFailedIndicator = workEntryDisplayIndicatesToolFailure(workEntry);+ const entryIconName =+ showWarningIndicator || showFailedIndicator ? "x" : workEntryIconName(workEntry);+ const displayText = workEntryPreview(workEntry, workspaceRoot) ?? toolWorkEntryHeading(workEntry);const expandedBody = buildToolCallExpandedBody(workEntry, workspaceRoot);const canExpand = expandedBody !== null;- const showFailedIndicator = workEntryIndicatesToolFailure(workEntry);const showDestructiveRowStyle =showFailedIndicator &&(workEntry.sourceActivityKind === "runtime.error" || !workLogEntryIsToolLike(workEntry));const iconWrapperClass = cn(- "flex size-5 shrink-0 items-center justify-center",- showWarningIndicator+ "flex size-6 shrink-0 items-center justify-center",+ showWarningIndicator || showFailedIndicator? "text-destructive": showDestructiveRowStyle? "text-destructive"@@ -2265,17 +2633,19 @@ const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {? "font-medium text-warning": showDestructiveRowStyle? "font-medium text-destructive"- : "font-medium text-foreground";- const turnSettled = !activity.activeTurnInProgress;- const showNeutralIndicator = !turnSettled && workEntryIndicatesToolNeutralStatus(workEntry);- const showSuccessIndicator =- workEntryIndicatesToolSuccess(workEntry) ||- (turnSettled && workEntryIndicatesToolNeutralStatus(workEntry));+ : workLogEntryIsToolLike(workEntry)+ ? "text-secondary-label"+ : "text-foreground/80";+ const showEntryIcon = !isExpandedToolGroupEntry || showWarningIndicator || showFailedIndicator;+ const accessibleDisplayText = showFailedIndicator+ ? `${displayText}, tool call failed`+ : displayText;const rowToggleProps = canExpand? {role: "button" as const,tabIndex: 0 as const,- "aria-label": displayText,+ "aria-label": accessibleDisplayText,+ "aria-expanded": expanded,onClick: () => setExpanded((v) => !v),onKeyDown: (e: KeyboardEvent<HTMLDivElement>) => {if (e.key === "Enter" || e.key === " ") {@@ -2289,85 +2659,45 @@ const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {return (<divclassName={cn(- "flex flex-col rounded-md px-0.5 py-0.5 transition-colors",+ "flex flex-col rounded-md px-0.5 transition-colors",+ isExpandedToolGroupEntry ? "py-0" : "py-0.5",canExpand &&"cursor-pointer hover:bg-accent/20 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring/70",)}{...rowToggleProps}><div className="flex select-none items-center gap-1.5 transition-[opacity,translate] duration-200">- <span className={iconWrapperClass}>+ <span+ className={cn(iconWrapperClass, !showEntryIcon && "invisible")}+ role={showFailedIndicator ? "img" : undefined}+ aria-label={showFailedIndicator ? "Tool call failed" : undefined}+ aria-hidden={!showEntryIcon}+ ><WorkEntryIconSvgname={entryIconName}- className="block size-3.5 shrink-0 stroke-[1.8] opacity-80"+ className="block size-4 shrink-0 stroke-[1.8] opacity-70"/></span><div className="flex min-w-0 flex-1 items-center gap-1.5"><div className="min-w-0 flex-1 overflow-hidden">- <p className="flex min-w-0 w-full items-baseline gap-1.5 text-[12px] leading-5">- <span className={cn("min-w-0 shrink truncate", headingClass)}>{heading}</span>- {preview && (- <span className="min-w-0 flex-1 truncate text-secondary-label">{preview}</span>- )}+ <p className="flex min-w-0 w-full items-baseline gap-1.5 text-sm leading-relaxed">+ <span className={cn("min-w-0 flex-1 truncate", headingClass)}>{displayText}</span></p></div>- <div className="flex shrink-0 items-center gap-px text-icon-muted">- <span- className="flex size-4 shrink-0 items-center justify-center"- aria-hidden={!canExpand}- >- {canExpand ? (- <ChevronDownIcon- className={cn(- "size-3 shrink-0 opacity-70 transition-transform duration-200",- expanded && "rotate-180",- )}- aria-hidden- />- ) : null}- </span>- <span className="flex size-4 shrink-0 items-center justify-center">- {showFailedIndicator ? (- <Tooltip>- <TooltipTrigger- render={- <span- className="flex size-4 items-center justify-center"- aria-label="Tool call failed"- />- }- >- <XIcon className="block size-3 shrink-0 text-destructive" aria-hidden />- </TooltipTrigger>- <TooltipPopup>Failed</TooltipPopup>- </Tooltip>- ) : showSuccessIndicator ? (- <Tooltip>- <TooltipTrigger- render={<span className="flex size-4 items-center justify-center" />}- >- <span className="inline-flex size-4 items-center justify-center">- <CheckIcon- className="block size-3 shrink-0 stroke-current"- stroke="currentColor"- aria-hidden- />- </span>- </TooltipTrigger>- <TooltipPopup>Completed</TooltipPopup>- </Tooltip>- ) : showNeutralIndicator ? (- <Tooltip>- <TooltipTrigger- render={<span className="flex size-4 items-center justify-center" />}- >- <MinusIcon className="block size-3 shrink-0 opacity-70" aria-hidden />- </TooltipTrigger>- <TooltipPopup>Empty</TooltipPopup>- </Tooltip>- ) : null}- </span>- </div>+ <span+ className={cn(+ "flex size-4 shrink-0 items-center justify-center",+ !canExpand && "invisible",+ )}+ aria-hidden+ >+ <ChevronDownIcon+ className={cn(+ "size-3 shrink-0 text-icon-muted opacity-70 transition-transform duration-200",+ expanded && "rotate-180",+ )}+ />+ </span></div></div>{expanded && canExpand && expandedBody ? (diff --git a/apps/web/src/index.css b/apps/web/src/index.cssindex 07b6313a5..71f9443f7 100644--- a/apps/web/src/index.css+++ b/apps/web/src/index.css@@ -431,6 +431,80 @@ html[data-mobile-composer-route-transition="true"]::view-transition-old(t3-mobil}}+@keyframes live-activity-focus {+ 0% {+ transform: translateX(0);+ }+ 100% {+ transform: translateX(100%);+ }+}++@keyframes live-activity-focus-counter {+ 0% {+ transform: translateX(0);+ }+ 100% {+ transform: translateX(-100%);+ }+}++@utility live-activity-focus {+ --live-activity-focus-width: 4.5rem;++ right: auto;+ left: calc(-1 * var(--live-activity-focus-width));+ width: calc(100% + var(--live-activity-focus-width) + var(--live-activity-focus-width));+ -webkit-mask-image: linear-gradient(+ to right,+ transparent 0,+ rgb(0 0 0 / 12%) 0.675rem,+ rgb(0 0 0 / 55%) 1.575rem,+ black 2.25rem,+ rgb(0 0 0 / 55%) 2.925rem,+ rgb(0 0 0 / 12%) 3.825rem,+ transparent var(--live-activity-focus-width),+ transparent 100%+ );+ -webkit-mask-repeat: no-repeat;+ mask-image: linear-gradient(+ to right,+ transparent 0,+ rgb(0 0 0 / 12%) 0.675rem,+ rgb(0 0 0 / 55%) 1.575rem,+ black 2.25rem,+ rgb(0 0 0 / 55%) 2.925rem,+ rgb(0 0 0 / 12%) 3.825rem,+ transparent var(--live-activity-focus-width),+ transparent 100%+ );+ mask-repeat: no-repeat;+ animation: live-activity-focus 2.2s linear infinite;+ will-change: transform;++ @media (prefers-reduced-motion: reduce) {+ animation: none;+ opacity: 0;+ will-change: auto;+ }+}++@utility live-activity-focus-counter {+ width: 100%;+ animation: live-activity-focus-counter 2.2s linear infinite;+ will-change: transform;++ @media (prefers-reduced-motion: reduce) {+ animation: none;+ will-change: auto;+ }+}++@utility live-activity-focus-aligned {+ width: calc(100% - var(--live-activity-focus-width) - var(--live-activity-focus-width));+ margin-left: var(--live-activity-focus-width);+}+@layer base {:root {/* Keep the original T3 Code artwork palettes as the defaults. Built-indiff --git a/apps/web/src/session-logic.test.ts b/apps/web/src/session-logic.test.tsindex 7671f7fdb..e94712d3e 100644--- a/apps/web/src/session-logic.test.ts+++ b/apps/web/src/session-logic.test.ts@@ -1184,6 +1184,108 @@ describe("deriveWorkLogEntries", () => {const [entry] = deriveWorkLogEntries(activities);expect(entry?.toolData).toEqual(item);+ expect(entry?.toolCallId).toBe("call-1");+ });++ it("collapses interleaved lifecycle updates by tool call id", () => {+ const activities: OrchestrationThreadActivity[] = [+ makeActivity({+ id: "tool-a-progress",+ createdAt: "2026-02-23T00:00:01.000Z",+ turnId: "turn-1",+ kind: "tool.updated",+ summary: "Tool A",+ payload: {+ itemType: "command_execution",+ toolCallId: "call-a",+ status: "inProgress",+ data: { command: "vp test run" },+ },+ }),+ makeActivity({+ id: "tool-b-progress",+ createdAt: "2026-02-23T00:00:02.000Z",+ turnId: "turn-1",+ kind: "tool.updated",+ summary: "Tool B",+ payload: {+ itemType: "command_execution",+ toolCallId: "call-b",+ status: "inProgress",+ data: { command: "vp lint" },+ },+ }),+ makeActivity({+ id: "tool-a-complete",+ createdAt: "2026-02-23T00:00:03.000Z",+ turnId: "turn-1",+ kind: "tool.completed",+ summary: "Tool A completed",+ payload: {+ itemType: "command_execution",+ toolCallId: "call-a",+ status: "completed",+ },+ }),+ makeActivity({+ id: "tool-b-complete",+ createdAt: "2026-02-23T00:00:04.000Z",+ turnId: "turn-1",+ kind: "tool.completed",+ summary: "Tool B completed",+ payload: {+ itemType: "command_execution",+ toolCallId: "call-b",+ status: "completed",+ },+ }),+ ];++ expect(deriveWorkLogEntries(activities)).toMatchObject([+ {+ id: "tool-a-complete",+ command: "vp test run",+ toolCallId: "call-a",+ toolLifecycleStatus: "completed",+ },+ {+ id: "tool-b-complete",+ command: "vp lint",+ toolCallId: "call-b",+ toolLifecycleStatus: "completed",+ },+ ]);+ });++ it("does not merge reused tool call ids across turns", () => {+ const activities: OrchestrationThreadActivity[] = [+ makeActivity({+ id: "turn-1-tool",+ createdAt: "2026-02-23T00:00:01.000Z",+ turnId: "turn-1",+ kind: "tool.updated",+ summary: "Tool",+ payload: {+ itemType: "command_execution",+ toolCallId: "reused-call",+ status: "inProgress",+ },+ }),+ makeActivity({+ id: "turn-2-tool",+ createdAt: "2026-02-23T00:00:02.000Z",+ turnId: "turn-2",+ kind: "tool.completed",+ summary: "Tool completed",+ payload: {+ itemType: "command_execution",+ toolCallId: "reused-call",+ status: "completed",+ },+ }),+ ];++ expect(deriveWorkLogEntries(activities)).toHaveLength(2);});it("unwraps PowerShell command wrappers for displayed command text", () => {@@ -1850,6 +1952,20 @@ describe("deriveActiveWorkStartedAt", () => {).toBe("2026-02-27T21:11:00.000Z");});+ it("falls back to the latest user message while a running turn is being acknowledged", () => {+ expect(+ deriveActiveWorkStartedAt(+ latestTurn,+ {+ status: "running",+ activeTurnId: TurnId.make("turn-2"),+ },+ null,+ "2026-02-27T21:11:00.000Z",+ ),+ ).toBe("2026-02-27T21:11:00.000Z");+ });+it("falls back to sendStartedAt once the latest turn is settled", () => {expect(deriveActiveWorkStartedAt(diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.tsindex d43b5d873..482425842 100644--- a/apps/web/src/session-logic.ts+++ b/apps/web/src/session-logic.ts@@ -65,6 +65,8 @@ export interface WorkLogEntry {id: string;createdAt: string;turnId?: TurnId | null;+ /** Stable provider identity across in-progress and completed lifecycle updates. */+ toolCallId?: string;label: string;detail?: string;command?: string;@@ -224,8 +226,10 @@ function toolDetailTextLooksLikeFailure(text: string): boolean {return false;}-/** True when the row should show a failure affordance (explicit status/tone or error-shaped tool output). */-export function workEntryIndicatesToolFailure(entry: WorkLogEntry): boolean {+function workEntryIndicatesToolFailureFromOutput(+ entry: WorkLogEntry,+ includeCommand: boolean,+): boolean {if (entry.tone === "error") {return true;}@@ -240,7 +244,7 @@ export function workEntryIndicatesToolFailure(entry: WorkLogEntry): boolean {if (entry.detail) {parts.push(entry.detail);}- if (entry.command) {+ if (includeCommand && entry.command) {parts.push(entry.command);}const blob = parts.join("\n");@@ -250,6 +254,16 @@ export function workEntryIndicatesToolFailure(entry: WorkLogEntry): boolean {return toolDetailTextLooksLikeFailure(blob);}+/** True when a tool failed, including providers that put error output in `command`. */+export function workEntryIndicatesToolFailure(entry: WorkLogEntry): boolean {+ return workEntryIndicatesToolFailureFromOutput(entry, true);+}++/** True when the rendered result indicates failure. The command itself is user intent, not output. */+export function workEntryDisplayIndicatesToolFailure(entry: WorkLogEntry): boolean {+ return workEntryIndicatesToolFailureFromOutput(entry, false);+}+/** Tool/command row completed without failure (blue check affordance). */export function workEntryIndicatesToolSuccess(entry: WorkLogEntry): boolean {if (!workLogEntryIsToolLike(entry)) {@@ -338,13 +352,14 @@ export function deriveActiveWorkStartedAt(latestTurn: LatestTurnTiming | null,session: SessionActivityState | null,sendStartedAt: string | null,+ latestUserMessageAt: string | null = null,): string | null {const runningTurnId = session?.status === "running" ? session.activeTurnId : null;if (runningTurnId !== null) {if (latestTurn?.turnId === runningTurnId) {- return latestTurn.startedAt ?? sendStartedAt;+ return latestTurn.startedAt ?? sendStartedAt ?? latestUserMessageAt;}- return sendStartedAt;+ return sendStartedAt ?? latestUserMessageAt;}if (!isLatestTurnSettled(latestTurn, session)) {return latestTurn?.startedAt ?? sendStartedAt;@@ -1010,6 +1025,13 @@ function agentSpawnGroupKey(entry: DerivedWorkLogEntry): string {return entry.turnId ? `direct:${entry.turnId}` : `direct:task:${taskId}`;}+function toolLifecycleCollapseMapKey(entry: DerivedWorkLogEntry): string | undefined {+ if (entry.activityKind !== "tool.updated" && entry.activityKind !== "tool.completed") {+ return undefined;+ }+ return entry.toolCallId ? `tool:${entry.turnId ?? "no-turn"}:${entry.toolCallId}` : undefined;+}+function collapseDerivedWorkLogEntries(entries: ReadonlyArray<DerivedWorkLogEntry>,): DerivedWorkLogEntry[] {@@ -1026,6 +1048,7 @@ function collapseDerivedWorkLogEntries(// own turn splintered one batch into a stream of "Kicked off N subagents"// rows (live-test finding, thread 7ac7ef05).const groupKeyByTaskId = new Map<string, string>();+ const toolLifecycleRowIndex = new Map<string, number>();for (const entry of entries) {const isTaskRow =entry.taskId !== undefined &&@@ -1070,12 +1093,36 @@ function collapseDerivedWorkLogEntries(});continue;}+ const lifecycleKey = toolLifecycleCollapseMapKey(entry);+ if (lifecycleKey !== undefined) {+ const matchingLifecycleIndex = toolLifecycleRowIndex.get(lifecycleKey);+ const matchingEntry =+ matchingLifecycleIndex === undefined ? undefined : collapsed[matchingLifecycleIndex];+ if (+ matchingLifecycleIndex !== undefined &&+ matchingEntry &&+ shouldCollapseToolLifecycleEntries(matchingEntry, entry)+ ) {+ collapsed[matchingLifecycleIndex] = mergeDerivedWorkLogEntries(matchingEntry, entry);+ continue;+ }+ toolLifecycleRowIndex.delete(lifecycleKey);+ }const previous = collapsed.at(-1);if (previous && shouldCollapseToolLifecycleEntries(previous, entry)) {- collapsed[collapsed.length - 1] = mergeDerivedWorkLogEntries(previous, entry);+ const previousIndex = collapsed.length - 1;+ const previousKey = toolLifecycleCollapseMapKey(previous);+ if (previousKey !== undefined) toolLifecycleRowIndex.delete(previousKey);+ const merged = mergeDerivedWorkLogEntries(previous, entry);+ collapsed[previousIndex] = merged;+ const mergedKey = toolLifecycleCollapseMapKey(merged);+ if (mergedKey !== undefined) toolLifecycleRowIndex.set(mergedKey, previousIndex);continue;}collapsed.push(entry);+ if (lifecycleKey !== undefined) {+ toolLifecycleRowIndex.set(lifecycleKey, collapsed.length - 1);+ }}return collapsed;}@@ -1090,6 +1137,9 @@ function shouldCollapseToolLifecycleEntries(if (next.activityKind !== "tool.updated" && next.activityKind !== "tool.completed") {return false;}+ if (previous.turnId !== next.turnId) {+ return false;+ }if (previous.activityKind === "tool.completed") {return false;}@@ -1161,7 +1211,7 @@ function deriveToolLifecycleCollapseKey(entry: DerivedWorkLogEntry): string | unreturn undefined;}if (entry.toolCallId) {- return `tool:${entry.toolCallId}`;+ return `tool:${entry.turnId ?? "no-turn"}:${entry.toolCallId}`;}const normalizedLabel = normalizeCompactToolLabel(entry.toolTitle ?? entry.label);const detail = entry.detail?.trim() ?? "";@@ -1393,7 +1443,7 @@ function extractToolTitle(payload: Record<string, unknown> | null): string | nulfunction extractToolCallId(payload: Record<string, unknown> | null): string | null {const data = asRecord(payload?.data);- return asTrimmedString(data?.toolCallId);+ return asTrimmedString(payload?.toolCallId) ?? asTrimmedString(data?.toolCallId);}function normalizeInlinePreview(value: string): string {