Skip to content

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.tsx
index 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.ts
index 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.ts
index 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): boolean
switch (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): boolean
return 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): boolean
a.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.tsx
index 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(
<MessagesTimeline
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index 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" }>["grouped
type 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 (
<div
className={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: Time
data-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-ignore
onClick={() => 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 (
<button
type="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; classN
return <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: Time
const 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 (
<div
className={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}
+ >
<WorkEntryIconSvg
name={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.css
index 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-in
diff --git a/apps/web/src/session-logic.test.ts b/apps/web/src/session-logic.test.ts
index 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.ts
index 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 | un
return 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 | nul
function 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 {