import { worktreeSetupAgentStarted } from "@t3tools/client-runtime/worktree-setup";
import { resolveUserMessagePresentation } from "@t3tools/client-runtime/user-message";
import { isLiveSubagentTurnItem } from "@t3tools/client-runtime/state/subagentRuntime";
import * as DateTime from "effect/DateTime";
import * as Equal from "effect/Equal";
import {
assistantCitationLabel,
collectAssistantCitations,
} from "@t3tools/shared/assistantCitations";
import { shallow } from "zustand/vanilla/shallow";
import { claudeResumeCompactionAge } from "@t3tools/shared/claudeCompaction";
import {
IDLE_COMPACTING_LABELS,
IDLE_COMPACTION_TITLES,
} from "@t3tools/client-runtime/user-message";
import type { HandoffTimelineRun } from "@t3tools/client-runtime/handoff";
import { renderCodexDirectivesForCopy } from "@t3tools/shared/codexMarkdownDirectives";
import {
commandDisplayText,
commandProgramName,
} from "@t3tools/client-runtime/work-log/command-label";
import {
liveActivityToolStatus,
normalizeCompactToolLabel,
resolveWorkEntryToolPresentation,
summarizeToolGroup,
toolGroupAction,
toolGroupSummaryKind,
contextCompactionTokenCounts,
type ToolGroupSummaryKind,
liveThoughtLine,
workEntryHiddenByToolCallVisibility,
} from "@t3tools/client-runtime/work-log/presentation";
import {
deriveRevertTurnCountByUserMessageId,
formatDuration,
isStreamingMessageTextUpdate,
isStreamingTurnItemTextUpdate,
timelineEntryIsPersistentResourceCard,
workEntryDisplayIndicatesToolFailure,
workEntryIndicatesToolSuccess,
workEntryIndicatesToolNeutralStatus,
workLogEntryIsToolLike,
type TimelineEntry,
type WorkLogEntry,
} from "../../session-logic";
import {
type ChatMessage,
type ProposedPlan,
type ThreadShell,
type TurnDiffSummary,
} from "../../types";
import {
idleCompactionOf,
isCompactionCommandMessage,
type MessageId,
type OrchestrationV2IdleCompaction,
type WorktreeSetupSnapshot,
type OrchestrationV2ProjectedTurnItem,
type RunAttemptId,
type RuntimeRequestId,
RunId,
type ThreadId,
type TurnItemId,
} from "@t3tools/contracts";
import type { ThreadRunSummary } from "@t3tools/client-runtime/state/shell";
import type { ToolCallVisibility } from "@t3tools/contracts/settings";
import { resolveT3McpToolDefinition } from "@t3tools/shared/t3McpToolPresentation";
import { compactDynamicToolOutput } from "@t3tools/shared/toolOutput";
import { htmlRenderReferencesEqual, type HtmlRenderReference } from "@t3tools/shared/htmlRender";
import { mcpAppReferencesEqual, type McpAppReference } from "@t3tools/shared/mcpApp";
import { dynamicToolTitle } from "@t3tools/shared/toolActivity";
import { formatWorkspaceRelativePath } from "../../filePathDisplay";
import {
collectToolFilePaths,
formatReadToolLabel,
formatSearchToolLabel,
} from "@t3tools/shared/toolActivity";
import { isWindowsAbsolutePath } from "@t3tools/shared/path";
function timelineEntryRunId(entry: TimelineEntry): RunId | null {
if (entry.kind === "message") {
return entry.message.role === "assistant" ? (entry.message.runId ?? null) : null;
}
if (entry.kind === "proposed-plan") {
return entry.proposedPlan.runId;
}
if (entry.kind === "html-render" || entry.kind === "mcp-app") return entry.runId;
return entry.kind === "work" ? (entry.entry.runId ?? null) : null;
}
function workEntryIsActiveTurnActivity(entry: WorkLogEntry): boolean {
return (
entry.toolLifecycleStatus === "inProgress" ||
(entry.toolLifecycleStatus === undefined &&
(entry.sourceActivityKind === "task.progress" || workLogEntryIsToolLike(entry)))
);
}
function singleToolCallLabel(entry: WorkLogEntry): string {
if (entry.itemType === "reasoning") return entry.detail?.trim().replace(/\s+/g, " ") || "Thought";
const toolPresentation = resolveWorkEntryToolPresentation(entry, "completed");
if (toolPresentation) return toolPresentation.displayName;
const item = entry.structuredPayload;
const title =
item?.type === "dynamic_tool" ? dynamicToolTitle(item.toolName, item.input, item.title) : null;
if (title) return title;
if (entry.itemType === "web_search") return entry.toolTitle ?? "Web search";
return workEntryDisplayLabel(entry, undefined);
}
function workEntryToolDataRecord(entry: WorkLogEntry): Record<string, unknown> | undefined {
return entry.toolData !== null &&
typeof entry.toolData === "object" &&
!Array.isArray(entry.toolData)
? (entry.toolData as Record<string, unknown>)
: undefined;
}
function workEntryReadRawPaths(entry: WorkLogEntry): readonly string[] {
const fromChanged = entry.changedFiles ?? [];
if (fromChanged.length > 0) return fromChanged;
const structured = entry.structuredPayload;
if (structured?.type === "dynamic_tool") {
const structuredPaths = collectToolFilePaths({ input: structured.input });
if (structuredPaths.length > 0) return structuredPaths;
}
return collectToolFilePaths(workEntryToolDataRecord(entry));
}
function workEntryReadPaths(entry: WorkLogEntry, workspaceRoot: string | undefined): string[] {
return workEntryReadRawPaths(entry).map((filePath) =>
formatWorkspaceRelativePath(filePath, workspaceRoot),
);
}
export function workEntryDisplayLabel(entry: WorkLogEntry, workspaceRoot: string | undefined) {
if (entry.itemType === "system_notice") return entry.label;
if (entry.itemType === "reasoning" || entry.tone === "thinking") {
const thought = entry.detail?.trim().replace(/\s+/g, " ");
return thought || entry.label;
}
const toolPresentation = resolveWorkEntryToolPresentation(entry);
if (toolPresentation) return toolPresentation.displayName;
if (entry.command?.trim()) return commandDisplayText(entry.command);
const action = toolGroupAction(entry);
if (action === "code-search" || action === "search") {
const searchLabel =
entry.itemType === "file_search"
? entry.label
: formatSearchToolLabel(workEntryToolDataRecord(entry));
if (searchLabel) return searchLabel;
}
const readPaths = action === "read" ? workEntryReadPaths(entry, workspaceRoot) : [];
if (action === "read" && readPaths[0]) {
return formatReadToolLabel(readPaths[0], readPaths.length - 1);
}
const providerRetry =
entry.projectedItem?.item.type === "error" && entry.projectedItem.item.retry !== undefined;
const item = entry.structuredPayload;
const title =
item?.type === "dynamic_tool" ? dynamicToolTitle(item.toolName, item.input, item.title) : null;
if (title) return title;
const compactDetail = entry.detail?.trim();
const detailIsSearchOutput =
(action === "code-search" || action === "search") && /[\r\n]/.test(compactDetail ?? "");
if (compactDetail && !providerRetry && action !== "read" && !detailIsSearchOutput) {
return compactDetail;
}
const [firstPath] = entry.changedFiles ?? [];
if (firstPath) {
const path = formatWorkspaceRelativePath(firstPath, workspaceRoot);
return entry.changedFiles!.length === 1
? path
: `${path} +${entry.changedFiles!.length - 1} more`;
}
if (action === "read" && !entry.viewedImagePath) {
return "Read file";
}
const heading = normalizeCompactToolLabel(entry.toolTitle || entry.label);
return `${heading.charAt(0).toUpperCase()}${heading.slice(1)}`;
}
export function threadReadTargetId(entry: Pick<WorkLogEntry, "structuredPayload">) {
const item = entry.structuredPayload;
if (item?.type !== "dynamic_tool") return null;
if (resolveT3McpToolDefinition(item.toolName)?.summaryAction !== "thread-read") return null;
const input = item.input;
const threadId =
input !== null && typeof input === "object" && "threadId" in input ? input.threadId : null;
return typeof threadId === "string" && threadId.trim().length > 0 ? threadId.trim() : null;
}
const THREAD_READ_OBJECT = " a T3 thread";
export function threadReadTargetTitle(
shell: Pick<ThreadShell, "title" | "archivedAt" | "deletedAt"> | null,
) {
if (!shell || shell.archivedAt !== null || shell.deletedAt !== null) return null;
return shell.title.trim() || null;
}
export function threadReadLabelPrefix(label: string) {
return label.endsWith(THREAD_READ_OBJECT)
? `${label.slice(0, -THREAD_READ_OBJECT.length)} thread`
: null;
}
export function workEntryReadOutput(
entry: Pick<
WorkLogEntry,
"changedFiles" | "detail" | "viewedImagePath" | "structuredPayload" | "toolData"
>,
workspaceRoot: string | undefined,
): string | null {
const paths = [
...new Set(
workEntryReadRawPaths(entry as WorkLogEntry)
.map((path) => {
const trimmed = path.trim().replaceAll("\\", "/");
if (!workspaceRoot || trimmed.startsWith("/") || isWindowsAbsolutePath(trimmed)) {
return trimmed;
}
const root = workspaceRoot.replaceAll("\\", "/").replace(/\/+$/, "");
const relative = trimmed.replace(/^\.\//, "").replace(/^\/+/, "");
return `${root}/${relative}`;
})
.filter((path) => path.length > 0),
),
];
if (paths.length > 0) {
return paths.join("\n");
}
return null;
}
export function liveWorkEntryLabel(
entry: WorkLogEntry,
workspaceRoot: string | undefined,
active: boolean,
) {
const status = liveActivityToolStatus(entry.toolLifecycleStatus, active);
if (entry.itemType === "reasoning") {
return (
entry.detail?.trim().replace(/\s+/g, " ") ||
(status === "inProgress" ? "Thinking" : "Thought")
);
}
const toolPresentation = resolveWorkEntryToolPresentation({
...entry,
toolLifecycleStatus: status,
});
if (toolPresentation) return toolPresentation.displayName;
const command = entry.command?.trim();
if (command) {
const verb =
status === "inProgress"
? "Running"
: status === "failed"
? "Failed"
: status === "declined"
? "Declined"
: status === "stopped"
? "Stopped"
: "Ran";
return `${verb} ${commandProgramName(command) ?? "command"}`;
}
return workEntryDisplayLabel(entry, workspaceRoot);
}
export function workEntryIsVisibleInGroup(
entry: WorkLogEntry,
expandedToolGroupEntry = false,
): boolean {
if (entry.itemType === "reasoning") return Boolean(entry.detail?.trim());
return (
(expandedToolGroupEntry &&
(entry.toolLifecycleStatus === "inProgress" ||
entry.sourceActivityKind === "task.progress")) ||
entry.toolLifecycleStatus === "stopped" ||
!workEntryIndicatesToolNeutralStatus(entry)
);
}
const TIMELINE_MINIMAP_ITEM_SPACING = 8;
export const TIMELINE_MINIMAP_MIN_ITEMS = 2;
const TIMELINE_MINIMAP_MAX_HEIGHT_CSS = "calc(100vh - 18rem)";
const TIMELINE_MINIMAP_PERSISTENT_GUTTER = 48;
export interface WorkGroupScrollAnchor {
readonly entryId: string;
readonly offset: number;
}
export function resolveWorkGroupScrollIndex(
entries: ReadonlyArray<{ readonly id: string }>,
anchor: WorkGroupScrollAnchor | undefined,
): { index: number; viewOffset: number } | undefined {
if (!anchor) return undefined;
const index = entries.findIndex((entry) => entry.id === anchor.entryId);
return index < 0 ? undefined : { index, viewOffset: -anchor.offset };
}
export function shouldFollowWorkGroupAppend(
previous: ReadonlyArray<{ readonly id: string }>,
entries: ReadonlyArray<{ readonly id: string }>,
distanceFromEnd: number,
): boolean {
return (
previous.length > 0 &&
entries.length > previous.length &&
distanceFromEnd <= 1 &&
previous.every((entry, index) => entry.id === entries[index]?.id)
);
}
interface TimelineEndState {
readonly isAtEnd?: boolean;
readonly isNearEnd?: boolean;
readonly contentLength?: number;
readonly scroll?: number;
readonly scrollLength?: number;
}
// Streaming can briefly unset isAtEnd; re-arm near the content bottom.
const TIMELINE_FOLLOW_REARM_THRESHOLD_PX = 40;
export function resolveTimelineIsAtEnd(state: TimelineEndState | undefined): boolean | undefined {
if (!state) {
return undefined;
}
const { contentLength, scroll, scrollLength } = state;
if (contentLength === undefined || scroll === undefined || scrollLength === undefined) {
return state.isAtEnd;
}
// LegendList double-subtracts the composer inset, so its isAtEnd is only a fallback.
return contentLength - scroll - scrollLength <= TIMELINE_FOLLOW_REARM_THRESHOLD_PX;
}
export function resolveTimelineMinimapHeightStyle(itemCount: number): string {
const naturalHeight = Math.max(1, (itemCount - 1) * TIMELINE_MINIMAP_ITEM_SPACING);
return `min(${naturalHeight}px, ${TIMELINE_MINIMAP_MAX_HEIGHT_CSS})`;
}
export function resolveTimelineMinimapTopPercent(index: number, itemCount: number): number {
if (itemCount <= 1) {
return 0;
}
return (Math.max(0, Math.min(index, itemCount - 1)) / (itemCount - 1)) * 100;
}
export function resolveTimelineMinimapIndexFromPointer(input: {
readonly itemCount: number;
readonly railTop: number;
readonly railHeight: number;
readonly pointerY: number;
}): number | null {
if (input.itemCount <= 0 || input.railHeight <= 0) {
return null;
}
if (input.itemCount === 1) {
return 0;
}
const progress = Math.max(0, Math.min(1, (input.pointerY - input.railTop) / input.railHeight));
return Math.max(0, Math.min(input.itemCount - 1, Math.round(progress * (input.itemCount - 1))));
}
/** Recheck the rendered buffer: LegendList's unbuffered range can lag during scrolling. */
export function resolveTimelineMinimapVisibleRange(state: {
readonly startBuffered: number | null | undefined;
readonly endBuffered: number | null | undefined;
readonly scroll: number;
readonly scrollLength: number;
readonly positionAtIndex: (index: number) => number | undefined;
readonly sizeAtIndex: (index: number) => number | undefined;
}) {
let start: number | null = null;
let end: number | null = null;
if (state.startBuffered == null || state.endBuffered == null || state.startBuffered < 0) {
return { start, end };
}
const bottom = state.scroll + state.scrollLength;
for (let index = state.startBuffered; index <= state.endBuffered; index += 1) {
const top = state.positionAtIndex(index);
const height = state.sizeAtIndex(index);
if (
top != null &&
Number.isFinite(top) &&
top < bottom &&
top + Math.max(1, height != null && Number.isFinite(height) ? height : 1) > state.scroll
) {
start ??= index;
end = index;
}
}
return { start, end };
}
export function isTimelineMinimapRowVisible(
rowIndex: number,
visibleStart: number | null | undefined,
visibleEnd: number | null | undefined,
): boolean {
return (
visibleStart != null && visibleEnd != null && rowIndex >= visibleStart && rowIndex <= visibleEnd
);
}
export function resolveTimelineMinimapCurrentIndex(input: {
readonly visibleStart: number | null | undefined;
readonly visibleEnd: number | null | undefined;
readonly rowIndices: ReadonlyArray<number>;
}): number | null {
if (input.visibleStart == null || input.visibleEnd == null) {
return null;
}
let precedingIndex: number | null = null;
for (const [index, rowIndex] of input.rowIndices.entries()) {
if (rowIndex >= input.visibleStart) {
// Prefer the first visible user message, otherwise the turn being read.
return rowIndex <= input.visibleEnd ? index : precedingIndex;
}
precedingIndex = index;
}
return precedingIndex;
}
function resolveTimelineSideGutter(viewportWidth: number, contentWidth: number): number {
if (!Number.isFinite(viewportWidth) || viewportWidth <= 0 || !Number.isFinite(contentWidth)) {
return 0;
}
return Math.max(0, (viewportWidth - Math.min(viewportWidth, contentWidth)) / 2);
}
export function resolveTimelineMinimapHasPersistentGutter(
viewportWidth: number,
contentWidth: number,
): boolean {
return (
resolveTimelineSideGutter(viewportWidth, contentWidth) >= TIMELINE_MINIMAP_PERSISTENT_GUTTER
);
}
const TIMELINE_MINIMAP_HIT_STRIP_LEFT = 12;
const TIMELINE_MINIMAP_HIT_STRIP_MAX_WIDTH = 40;
const TIMELINE_MINIMAP_EXPANDED_HIT_STRIP_WIDTH = "22rem";
export function resolveTimelineMinimapHitStripWidth(
viewportWidth: number,
contentWidth: number,
): number {
const sideGutter = resolveTimelineSideGutter(viewportWidth, contentWidth);
return Math.max(
0,
Math.min(
TIMELINE_MINIMAP_HIT_STRIP_MAX_WIDTH,
Math.floor(sideGutter) - TIMELINE_MINIMAP_HIT_STRIP_LEFT,
),
);
}
const TIMELINE_MINIMAP_NAVIGATION_REACH = 14;
export function resolveTimelineMinimapNavigationInteractive(collapsedWidth: number): boolean {
return collapsedWidth >= TIMELINE_MINIMAP_NAVIGATION_REACH;
}
export function resolveTimelineMinimapInteractiveWidth(
collapsedWidth: number,
expanded: boolean,
): number | string {
return expanded ? TIMELINE_MINIMAP_EXPANDED_HIT_STRIP_WIDTH : collapsedWidth;
}
function computeElapsedMs(startIso: string, endIso: string): number | null {
const start = Date.parse(startIso);
const end = Date.parse(endIso);
if (!Number.isFinite(start) || !Number.isFinite(end)) return null;
return Math.max(0, end - start);
}
function maxIsoTimestamp(a: string | null, b: string | null): string | null {
if (a === null) return b;
if (b === null) return a;
const aMs = Date.parse(a);
const bMs = Date.parse(b);
if (!Number.isFinite(aMs)) return b;
if (!Number.isFinite(bMs)) return a;
return bMs > aMs ? b : a;
}
export type TimelineLatestRun = Pick<
ThreadRunSummary,
"runId" | "status" | "startedAt" | "completedAt" | "turnEnded"
>;
const LIVE_ACTIVITY_ROW_ID = "live-activity-row";
export type MessagesTimelineRow = MessagesTimelineRowContent & {
readonly continuesWorkLog?: boolean;
};
type MessagesTimelineRowContent =
| {
kind: "worktree-setup";
id: string;
createdAt: string | null;
snapshot: WorktreeSetupSnapshot;
embedded: boolean;
}
| {
kind: "work";
id: string;
createdAt: string;
groupedEntries: WorkLogEntry[];
isExpandedToolGroup: boolean;
displayLabel?: string;
}
| {
kind: "work-live";
id: string;
createdAt: string;
entry: WorkLogEntry;
groupedEntries: WorkLogEntry[];
groupId: string;
expanded: boolean;
active: boolean;
thought?: WorkLogEntry;
}
| {
kind: "working";
id: string;
createdAt: string | null;
/** A running compaction owns the working row, so its divider appears only once it ends. */
compacting?: true;
}
| {
kind: "thinking";
id: string;
createdAt: string | null;
groupId?: string;
expanded?: boolean;
}
| {
kind: "work-toggle";
id: string;
createdAt: string;
runId?: RunId | null;
groupId: string;
hiddenCount: number;
expanded: boolean;
summary: string;
summaryKind: ToolGroupSummaryKind;
toolSurface?: WorkLogEntry["toolSurface"];
toolIcon?: WorkLogEntry["toolIcon"];
hasFailure: boolean;
}
| {
kind: "turn-fold";
deferredWorkItemIds?: ReadonlyArray<string>;
id: string;
createdAt: string;
runId: RunId;
label: string;
expanded: boolean;
}
| {
kind: "attempt-fold";
deferredWorkItemIds?: ReadonlyArray<string>;
id: string;
createdAt: string;
runId: RunId;
attemptId: RunAttemptId;
label: string;
expanded: boolean;
}
| {
kind: "context-compaction";
id: string;
createdAt: string;
label: string;
tokenCounts: ReturnType<typeof contextCompactionTokenCounts>;
active: boolean;
/** Replaces "Context compacted" when T3 Code compacted without being asked. */
title?: string;
failed?: true;
/** The provider's reason, when a failed compaction gave one. */
failure?: string;
}
| {
kind: "message";
id: string;
createdAt: string;
message: ChatMessage;
projectedItem?: OrchestrationV2ProjectedTurnItem;
showAssistantMeta: boolean;
showAssistantCopyButton: boolean;
assistantCopyStreaming: boolean;
assistantTurnDiffSummary?: TurnDiffSummary | undefined;
revertTurnCount?: number | undefined;
/** Another of your messages follows directly, so the two sit closer together. */
groupedWithNext?: boolean;
/** Another of your messages sits directly above, so the joined corners tighten. */
groupedWithPrevious?: boolean;
/** Set when the message above is a steer too, so the label shows once. */
continuesSteer?: boolean;
}
| {
kind: "assistant-meta";
projectedItem?: OrchestrationV2ProjectedTurnItem;
id: string;
createdAt: string;
message: ChatMessage;
showAssistantCopyButton: boolean;
assistantCopyStreaming: boolean;
}
| {
kind: "event";
id: string;
createdAt: string;
projectedItem: OrchestrationV2ProjectedTurnItem;
subagents?: ReadonlyArray<OrchestrationV2ProjectedTurnItem>;
resourceSummary?: boolean;
}
| {
kind: "proposed-plan";
id: string;
createdAt: string;
proposedPlan: ProposedPlan;
}
| {
kind: "html-render";
id: string;
createdAt: string;
htmlRender: HtmlRenderReference;
}
| {
kind: "mcp-app";
id: string;
createdAt: string;
sourceThreadId: ThreadId;
itemId: TurnItemId;
revision: string;
mcpApp: McpAppReference;
};
export interface StableMessagesTimelineRowsState {
byId: Map<string, MessagesTimelineRow>;
result: MessagesTimelineRow[];
}
function workGroupId(timelineEntryId: string): string {
return `work-group:${timelineEntryId}`;
}
function expandedWorkGroupRow(
groupId: string,
createdAt: string,
groupedEntries: WorkLogEntry[],
): Extract<MessagesTimelineRow, { kind: "work" }> {
return {
kind: "work",
id: `${groupId}:details`,
createdAt,
groupedEntries,
isExpandedToolGroup: true,
};
}
export function resolveAssistantMessageCopyState({
text,
showCopyButton,
streaming,
}: {
text: string | null;
showCopyButton: boolean;
streaming: boolean;
}) {
const hasText = text !== null && text.trim().length > 0;
const visible = showCopyButton && hasText && !streaming;
return {
text: hasText ? (visible ? renderCodexDirectivesForCopy(text) : text) : null,
visible,
};
}
function deriveTerminalAssistantMessageIds(timelineEntries: ReadonlyArray<TimelineEntry>) {
const lastAssistantMessageIdByResponseKey = new Map<string, string>();
let nullTurnResponseIndex = 0;
for (const timelineEntry of timelineEntries) {
if (timelineEntry.kind !== "message") {
continue;
}
const { message } = timelineEntry;
if (message.role === "user") {
nullTurnResponseIndex += 1;
continue;
}
if (message.role !== "assistant") {
continue;
}
const responseKey = message.runId
? `turn:${message.runId}`
: `unkeyed:${nullTurnResponseIndex}`;
lastAssistantMessageIdByResponseKey.set(responseKey, message.id);
}
return new Set(lastAssistantMessageIdByResponseKey.values());
}
interface TurnFold {
runId: RunId;
anchorEntryId: string;
createdAt: string;
hiddenEntryIds: ReadonlySet<string>;
/** Every entry in the segment, including the cards a fold never hides. */
entryIds: ReadonlySet<string>;
label: string;
}
interface SupersededAttemptFold {
readonly deferredWorkItemIds: ReadonlyArray<string>;
readonly runId: RunId;
readonly attemptId: RunAttemptId;
readonly anchorEntryId: string;
readonly createdAt: string;
readonly hiddenEntryIds: ReadonlySet<string>;
}
// Interrupted streams can be `completed`; only the attempt's last output proves completion.
function completeSupersededReplyEntryIds(
timelineEntries: ReadonlyArray<TimelineEntry>,
): ReadonlySet<string> {
const lastOutputByAttemptId = new Map<RunAttemptId, TimelineEntry>();
for (const entry of timelineEntries) {
if (
entry.attempt?.status !== "superseded" ||
(entry.kind === "message" && entry.message.role === "user") ||
(entry.kind === "work" &&
(entry.entry.itemType === "system_notice" || entry.entry.itemType === "notification")) ||
(entry.kind !== "message" && entry.kind !== "work")
) {
continue;
}
const previous = lastOutputByAttemptId.get(entry.attempt.id);
const deferredEnd =
previous?.kind === "work"
? previous.entry.projectedItem?.item.deferredWork?.lastOrdinal
: undefined;
const ordinal =
entry.kind === "work"
? entry.entry.projectedItem?.item.ordinal
: entry.kind === "message"
? entry.projectedItem?.item.ordinal
: undefined;
if (deferredEnd !== undefined && ordinal !== undefined && deferredEnd > ordinal) continue;
lastOutputByAttemptId.set(entry.attempt.id, entry);
}
const replyEntryIds = new Set<string>();
for (const entry of lastOutputByAttemptId.values()) {
const supersededAt = entry.attempt?.completedAt ?? null;
const item = entry.kind === "message" ? entry.projectedItem?.item : undefined;
if (
entry.kind === "message" &&
!entry.message.streaming &&
item?.type === "assistant_message" &&
item.status === "completed" &&
item.completedAt !== null &&
supersededAt !== null &&
DateTime.isLessThan(item.completedAt, supersededAt)
) {
replyEntryIds.add(entry.id);
}
}
return replyEntryIds;
}
function deriveSupersededAttemptFolds(
timelineEntries: ReadonlyArray<TimelineEntry>,
unfoldedRunIds: ReadonlySet<RunId>,
liveSubagentEntryIds: ReadonlySet<string>,
completeReplyEntryIds: ReadonlySet<string>,
): ReadonlyMap<string, SupersededAttemptFold> {
const completeAttemptIds = new Set(
timelineEntries.flatMap((entry) =>
entry.attempt !== undefined && completeReplyEntryIds.has(entry.id) ? [entry.attempt.id] : [],
),
);
const entriesByAttemptId = new Map<RunAttemptId, TimelineEntry[]>();
for (const entry of timelineEntries) {
if (
entry.attempt?.status !== "superseded" ||
completeAttemptIds.has(entry.attempt.id) ||
unfoldedRunIds.has(entry.attempt.runId) ||
(entry.kind === "message" && entry.message.role === "user") ||
(entry.kind === "event" && entry.projectedItem.item.type === "handoff") ||
entry.kind === "html-render" ||
entry.kind === "mcp-app" ||
timelineEntryIsPersistentResourceCard(entry) ||
liveSubagentEntryIds.has(entry.id) ||
(entry.kind === "work" && entry.entry.itemType === "system_notice")
) {
continue;
}
const entries = entriesByAttemptId.get(entry.attempt.id) ?? [];
entries.push(entry);
entriesByAttemptId.set(entry.attempt.id, entries);
}
const foldsByAnchorEntryId = new Map<string, SupersededAttemptFold>();
for (const entries of entriesByAttemptId.values()) {
const firstEntry = entries[0];
const attempt = firstEntry?.attempt;
if (firstEntry === undefined || attempt === undefined) continue;
foldsByAnchorEntryId.set(firstEntry.id, {
deferredWorkItemIds: entries.flatMap((entry) =>
entry.kind === "work" && entry.entry.projectedItem?.item.deferredWork
? [String(entry.entry.projectedItem.sourceItemId)]
: [],
),
runId: attempt.runId,
attemptId: attempt.id,
anchorEntryId: firstEntry.id,
createdAt: firstEntry.createdAt,
hiddenEntryIds: new Set(entries.map((entry) => entry.id)),
});
}
return foldsByAnchorEntryId;
}
// After send, the previous turn stays active until the server creates its replacement.
function deriveUnsettledRunId(
latestRun: TimelineLatestRun | null,
runningRunId: RunId | null = null,
): RunId | null {
if (runningRunId !== null) return runningRunId;
if (!latestRun) {
return null;
}
const isSettled =
latestRun.completedAt !== null &&
latestRun.status !== "running" &&
latestRun.status !== "starting" &&
latestRun.status !== "waiting";
return isSettled ? null : latestRun.runId;
}
// Children can outlive their launching turn; keep cards visible while the footer counts them.
function liveSubagentCardEntryIds(entries: ReadonlyArray<TimelineEntry>): ReadonlySet<string> {
const visible = new Set<string>();
let batch: Array<Extract<TimelineEntry, { kind: "event" }>> = [];
const flush = () => {
if (batch.length === 0) return;
if (batch.some((entry) => isLiveSubagentTurnItem(entry.projectedItem.item))) {
for (const entry of batch) visible.add(entry.id);
}
batch = [];
};
for (const entry of entries) {
if (entry.kind !== "event" || entry.projectedItem.item.type !== "subagent") {
flush();
continue;
}
const item = entry.projectedItem.item;
const previous = batch.at(-1)?.projectedItem.item;
if (
previous !== undefined &&
(previous.runId !== item.runId || previous.providerTurnId !== item.providerTurnId)
) {
flush();
}
batch.push(entry);
}
flush();
return visible;
}
function timelineEntryFoldRunId(entry: TimelineEntry, runlessKey: RunId | null): RunId | null {
if (entry.kind === "work" && entry.entry.itemType === "system_notice") return null;
if (entry.kind === "message" && entry.message.role === "assistant") {
return entry.message.runId ?? runlessKey;
}
if (entry.kind === "work") {
return entry.entry.runId ?? runlessKey;
}
if (
entry.kind === "event" &&
(timelineEntryIsPersistentResourceCard(entry) || entry.projectedItem.item.type === "subagent")
) {
return entry.projectedItem.item.runId ?? runlessKey;
}
return null;
}
function timelineEntryIsSteer(entry: TimelineEntry): boolean {
return (
entry.kind === "message" &&
entry.message.role === "user" &&
(entry.message.inputIntent === "steer" ||
entry.message.inputIntent === "promoted_queued_to_steer")
);
}
function timelineEntryStartsResponse(entry: TimelineEntry): boolean {
return (
(entry.kind === "message" && entry.message.role === "user" && !timelineEntryIsSteer(entry)) ||
(entry.kind === "work" && entry.entry.itemType === "notification")
);
}
function timelineEntryEnd(entry: TimelineEntry): string {
return entry.kind === "message" ? entry.message.updatedAt : entry.createdAt;
}
function timelineEntryIsCompaction(entry: TimelineEntry): boolean {
return entry.kind === "work" && entry.entry.sourceActivityKind === "context-compaction";
}
function responseBoundaryRunId(entry: TimelineEntry): RunId | null {
if (entry.kind === "message") return entry.message.runId ?? null;
if (entry.kind === "work") return entry.entry.runId ?? null;
return null;
}
// Group promptless restarts under the initiating prompt until settled.
function lastResponseBoundaryIndex(timelineEntries: ReadonlyArray<TimelineEntry>): number {
return timelineEntries.findLastIndex(timelineEntryStartsResponse);
}
function deriveActiveVisualResponseRunIds(input: {
timelineEntries: ReadonlyArray<TimelineEntry>;
unsettledRunId: RunId | null;
isWorking: boolean;
}): ReadonlySet<RunId> {
const runIds = new Set<RunId>();
if (input.unsettledRunId === null) {
return runIds;
}
runIds.add(input.unsettledRunId);
if (!input.isWorking) {
return runIds;
}
const latestResponseBoundaryIndex = lastResponseBoundaryIndex(input.timelineEntries);
for (
let index = latestResponseBoundaryIndex + 1;
index < input.timelineEntries.length;
index += 1
) {
const runId = timelineEntryRunId(input.timelineEntries[index]!);
if (runId !== null) {
runIds.add(runId);
}
}
return runIds;
}
function timelineEntryFailedItem(entry: TimelineEntry) {
const item =
entry.kind === "event"
? entry.projectedItem.item
: entry.kind === "work"
? entry.entry.projectedItem?.item
: null;
return item?.type === "error" && item.status === "failed" && item.parentItemId === null
? item
: null;
}
function failedTimelineRunIds(
entries: ReadonlyArray<TimelineEntry>,
latestRun: TimelineLatestRun | null,
) {
const failed = new Set<RunId>();
if (latestRun?.status === "failed") failed.add(latestRun.runId);
for (const entry of entries) {
const runId = timelineEntryFailedItem(entry)?.runId;
if (runId) failed.add(runId);
}
return failed;
}
/** Usage-limit pauses keep their tool groups; any other failure itemizes the run's work. */
function itemizedFailedRunIds(
entries: ReadonlyArray<TimelineEntry>,
failedRunIds: ReadonlySet<RunId>,
) {
const usageLimited = new Set<RunId>();
const otherFailures = new Set<RunId>();
for (const entry of entries) {
const item = timelineEntryFailedItem(entry);
if (item?.runId) {
(item.failure.class === "usage_limit" ? usageLimited : otherFailures).add(item.runId);
}
}
return new Set(
[...failedRunIds].filter((runId) => !usageLimited.has(runId) || otherFailures.has(runId)),
);
}
function deriveTurnFolds(input: {
timelineEntries: ReadonlyArray<TimelineEntry>;
terminalAssistantMessageIds: ReadonlySet<string>;
latestRun: TimelineLatestRun | null;
unfoldedRunIds: ReadonlySet<RunId>;
runlessWorkActive: boolean;
liveSubagentEntryIds: ReadonlySet<string>;
completeSupersededReplyEntryIds: ReadonlySet<string>;
}): ReadonlyMap<string, TurnFold> {
const interruptedRunIds = new Set<RunId>();
const promptIndexByRunId = new Map<RunId, number>();
for (const [index, entry] of input.timelineEntries.entries()) {
if (timelineEntryStartsResponse(entry)) {
const runId = responseBoundaryRunId(entry);
if (runId !== null && !promptIndexByRunId.has(runId)) promptIndexByRunId.set(runId, index);
}
if (
entry.kind === "event" &&
entry.projectedItem.item.runId !== null &&
(entry.projectedItem.item.type === "run_interrupt_request" ||
entry.projectedItem.item.type === "run_interrupt_result")
) {
interruptedRunIds.add(entry.projectedItem.item.runId);
}
}
interface TurnGroup {
entries: Array<TimelineEntry>;
terminalEntry: Extract<TimelineEntry, { kind: "message" }> | null;
hasStreamingMessage: boolean;
// Entry timestamps omit startup and can collapse steered turns to an instant.
startBoundary: string | null;
anchorEntryId: string;
/**
* Each steer after the turn has produced output starts a new segment at
* this index into `entries`, so the steer sits between the work it split.
*/
steerSegments: Array<{ startIndex: number; steer: TimelineEntry }>;
}
const groupsByRunId = new Map<RunId, TurnGroup>();
const runlessFailedKeys = new Set<RunId>();
// Key runless responses per prompt to prevent V2 runs unfolding imported turns.
let runlessKey: RunId | null = null;
let responseKey: RunId | null = null;
let pendingBoundary: { createdAt: string; anchorEntryId: string } | null = null;
for (const [index, entry] of input.timelineEntries.entries()) {
if (timelineEntryStartsResponse(entry)) {
const nextEntry = input.timelineEntries[index + 1];
pendingBoundary = nextEntry
? { createdAt: entry.createdAt, anchorEntryId: nextEntry.id }
: null;
const boundaryRunId = responseBoundaryRunId(entry);
runlessKey = boundaryRunId == null ? RunId.make(`runless:${entry.id}`) : null;
responseKey = boundaryRunId ?? runlessKey;
continue;
}
if (entry.kind === "message" && timelineEntryIsSteer(entry)) {
const steerRunId = entry.message.runId ?? responseKey;
const group = steerRunId === null ? undefined : groupsByRunId.get(steerRunId);
if (group !== undefined && group.entries.length > 0) {
// Back-to-back steers split once, after the last of them.
if (group.steerSegments.at(-1)?.startIndex === group.entries.length) {
group.steerSegments.pop();
}
group.steerSegments.push({ startIndex: group.entries.length, steer: entry });
}
continue;
}
const ownRunId = timelineEntryFoldRunId(entry, runlessKey);
if (!ownRunId) {
continue;
}
// Resumed subagents keep their position and fold with their original turn.
const runId =
responseKey !== null && (promptIndexByRunId.get(ownRunId) ?? -1) > index
? responseKey
: ownRunId;
if (runId === runlessKey && timelineEntryFailedItem(entry) !== null) {
runlessFailedKeys.add(runId);
}
let group = groupsByRunId.get(runId);
if (!group) {
group = {
entries: [],
terminalEntry: null,
hasStreamingMessage: false,
startBoundary: pendingBoundary?.createdAt ?? null,
anchorEntryId: pendingBoundary?.anchorEntryId ?? entry.id,
steerSegments: [],
};
pendingBoundary = null;
groupsByRunId.set(runId, group);
}
group.entries.push(entry);
if (entry.kind === "message") {
if (input.terminalAssistantMessageIds.has(entry.message.id)) {
group.terminalEntry = entry;
}
if (entry.message.streaming) {
group.hasStreamingMessage = true;
}
}
}
const foldsByAnchorEntryId = new Map<string, TurnFold>();
for (const [runId, group] of groupsByRunId) {
if (
input.unfoldedRunIds.has(runId) ||
interruptedRunIds.has(runId) ||
runlessFailedKeys.has(runId) ||
(input.runlessWorkActive && runId === runlessKey)
) {
continue;
}
if (group.hasStreamingMessage) {
continue;
}
const hiddenEntryIds = new Set<string>();
const terminalEntryIndex = group.terminalEntry
? group.entries.findIndex((entry) => entry.id === group.terminalEntry?.id)
: group.entries.length;
for (const [index, entry] of group.entries.entries()) {
if (entry.id === group.terminalEntry?.id) {
continue;
}
const isCompaction = timelineEntryIsCompaction(entry);
const isFoldableTrailingActivity =
entry.kind === "work" &&
entry.entry.toolLifecycleStatus !== "inProgress" &&
!workEntryDisplayIndicatesToolFailure(entry.entry);
if (!isCompaction && index > terminalEntryIndex && !isFoldableTrailingActivity) {
continue;
}
if (
isCompaction ||
timelineEntryIsPersistentResourceCard(entry) ||
input.liveSubagentEntryIds.has(entry.id) ||
input.completeSupersededReplyEntryIds.has(entry.id)
) {
continue;
}
if (entry.kind === "work" && entry.entry.itemType === "notification") continue;
if (entry.kind === "work" && entry.entry.questionAnswer !== undefined) continue;
hiddenEntryIds.add(entry.id);
}
if (hiddenEntryIds.size === 0) {
continue;
}
const hidesNonCompactionWork = (entries: ReadonlyArray<TimelineEntry>) =>
entries.some((entry) => hiddenEntryIds.has(entry.id) && !timelineEntryIsCompaction(entry));
if (!hidesNonCompactionWork(group.entries)) {
continue;
}
const firstEntry = group.entries[0];
const lastEntry = group.entries.at(-1);
if (!firstEntry || !lastEntry) {
continue;
}
const isLatestInterruptedTurn =
input.latestRun?.runId === runId && input.latestRun.status === "interrupted";
// A turn cut short by a steer leaves trailing work entries behind its
// terminal message — take whichever ended last.
const lastEntryEnd = timelineEntryEnd(lastEntry);
const elapsedMs =
input.latestRun?.runId === runId && input.latestRun.startedAt && input.latestRun.completedAt
? computeElapsedMs(input.latestRun.startedAt, input.latestRun.completedAt)
: computeElapsedMs(
group.startBoundary ?? firstEntry.createdAt,
maxIsoTimestamp(group.terminalEntry?.message.updatedAt ?? null, lastEntryEnd) ??
lastEntryEnd,
);
const duration = elapsedMs !== null ? formatDuration(elapsedMs) : null;
const label = isLatestInterruptedTurn
? duration
? `You stopped after ${duration}`
: "You stopped this response"
: duration
? `Worked for ${duration}`
: "Worked";
// The top row keeps the whole turn's time, steers included. Work after a
// steer folds under its own row below that steer, keyed apart from the run
// so each segment opens on its own.
const segmentHiddenIds = (entries: ReadonlyArray<TimelineEntry>) =>
new Set(entries.flatMap((entry) => (hiddenEntryIds.has(entry.id) ? [entry.id] : [])));
const firstSegment = group.entries.slice(0, group.steerSegments[0]?.startIndex);
foldsByAnchorEntryId.set(group.anchorEntryId, {
runId,
anchorEntryId: group.anchorEntryId,
createdAt: group.startBoundary ?? firstEntry.createdAt,
hiddenEntryIds: segmentHiddenIds(firstSegment),
entryIds: new Set(firstSegment.map((entry) => entry.id)),
label,
});
for (const [index, { startIndex, steer }] of group.steerSegments.entries()) {
const entries = group.entries.slice(startIndex, group.steerSegments[index + 1]?.startIndex);
const anchorEntry = entries[0];
if (anchorEntry === undefined || !hidesNonCompactionWork(entries)) continue;
const segmentMs = computeElapsedMs(
steer.createdAt,
entries.map(timelineEntryEnd).reduce<string | null>(maxIsoTimestamp, null) ??
steer.createdAt,
);
foldsByAnchorEntryId.set(anchorEntry.id, {
runId: RunId.make(`${runId}:steer:${steer.id}`),
anchorEntryId: anchorEntry.id,
createdAt: steer.createdAt,
hiddenEntryIds: segmentHiddenIds(entries),
entryIds: new Set(entries.map((entry) => entry.id)),
label: segmentMs !== null ? `Continued for ${formatDuration(segmentMs)}` : "Continued",
});
}
}
return foldsByAnchorEntryId;
}
function attachTrailingToolGroupsToAssistant(
rows: ReadonlyArray<MessagesTimelineRow>,
): MessagesTimelineRow[] {
const messageRowsWithoutMeta = new Set<string>();
const metaRowsAfterIndex = new Map<
number,
Extract<MessagesTimelineRow, { kind: "assistant-meta" }>
>();
for (const [messageIndex, row] of rows.entries()) {
const runId = row.kind === "message" ? (row.message.runId ?? null) : null;
if (
row.kind !== "message" ||
row.message.role !== "assistant" ||
!row.showAssistantMeta ||
runId === null
) {
continue;
}
let lastTrailingWorkIndex = -1;
let hasTrailingToolGroup = false;
for (let index = messageIndex + 1; index < rows.length; index += 1) {
const candidate = rows[index];
if (!candidate || candidate.kind === "message") {
break;
}
if (candidate.kind === "work-toggle" && candidate.runId === runId) {
hasTrailingToolGroup = true;
lastTrailingWorkIndex = index;
continue;
}
if (
candidate.kind === "event" &&
candidate.resourceSummary &&
candidate.projectedItem.item.runId === runId
) {
hasTrailingToolGroup = true;
lastTrailingWorkIndex = index;
continue;
}
if (
candidate.kind === "work" &&
candidate.groupedEntries.some((entry) => entry.runId === runId)
) {
if (
!candidate.isExpandedToolGroup &&
candidate.groupedEntries.some(
(entry) =>
workLogEntryIsToolLike(entry) ||
(entry.projectedItem?.item.type === "error" &&
entry.projectedItem.item.status === "failed"),
)
) {
hasTrailingToolGroup = true;
}
if (hasTrailingToolGroup) {
lastTrailingWorkIndex = index;
}
}
}
if (lastTrailingWorkIndex < 0) {
continue;
}
messageRowsWithoutMeta.add(row.id);
metaRowsAfterIndex.set(lastTrailingWorkIndex, {
kind: "assistant-meta",
id: `assistant-meta:${row.message.id}`,
...(row.projectedItem === undefined ? {} : { projectedItem: row.projectedItem }),
createdAt: rows[lastTrailingWorkIndex]?.createdAt ?? row.message.updatedAt,
message: row.message,
showAssistantCopyButton: row.showAssistantCopyButton,
assistantCopyStreaming: row.assistantCopyStreaming,
});
}
const result: MessagesTimelineRow[] = [];
for (const [index, row] of rows.entries()) {
if (row.kind === "message" && messageRowsWithoutMeta.has(row.id)) {
result.push({ ...row, showAssistantMeta: false, showAssistantCopyButton: false });
} else {
result.push(row);
}
const metaRow = metaRowsAfterIndex.get(index);
if (metaRow) {
result.push(metaRow);
}
}
return result;
}
// Hide delegation rows only when task ids identify durable child cards; prompts can repeat.
function withoutSubagentDelegationRows(entries: ReadonlyArray<TimelineEntry>) {
const childrenByRun = new Map<RunId, Set<string>>();
for (const entry of entries) {
if (entry.kind !== "event" || entry.projectedItem.item.type !== "subagent") continue;
const item = entry.projectedItem.item;
if (item.origin !== "app_owned" || item.runId === null) continue;
const children = childrenByRun.get(item.runId) ?? new Set<string>();
children.add(item.subagentId);
childrenByRun.set(item.runId, children);
}
return entries.filter((entry) => {
if (entry.kind !== "work" || workEntryDisplayIndicatesToolFailure(entry.entry)) return true;
const item = entry.entry.projectedItem?.item ?? entry.entry.structuredPayload;
if (
item?.type !== "dynamic_tool" ||
item.runId === null ||
(item.status !== "running" && item.status !== "completed") ||
resolveT3McpToolDefinition(item.toolName)?.summaryAction !== "delegate"
)
return true;
const output = compactDynamicToolOutput(item.output);
if (output?.isError) return true;
if (output?.taskId !== undefined) {
return !childrenByRun.get(item.runId)?.has(output.taskId);
}
return true;
});
}
const supersededReasoningEntries = new WeakMap<TimelineEntry, TimelineEntry>();
function settleSupersededReasoning(entries: ReadonlyArray<TimelineEntry>) {
return entries.map((entry, index) => {
if (
index === entries.length - 1 ||
entry.kind !== "work" ||
entry.entry.itemType !== "reasoning" ||
entry.entry.toolLifecycleStatus !== "inProgress"
) {
return entry;
}
let settled = supersededReasoningEntries.get(entry);
if (!settled) {
settled = { ...entry, entry: { ...entry.entry, toolLifecycleStatus: "completed" } };
supersededReasoningEntries.set(entry, settled);
}
return settled;
});
}
function workShownAsFinalAnswerOnly(
entry: TimelineEntry,
pendingApprovalRequestIds: ReadonlySet<RuntimeRequestId> | undefined,
): boolean {
if (entry.kind === "event") return entry.projectedItem.item.type !== "subagent";
if (entry.kind !== "work") return true;
const work = entry.entry;
const item = work.projectedItem?.item;
return (
(item?.type === "approval_request" &&
pendingApprovalRequestIds?.has(item.requestId) === true) ||
work.questionAnswer !== undefined ||
timelineEntryIsCompaction(entry) ||
timelineEntryStartsResponse(entry) ||
work.tone === "error" ||
work.sourceActivityKind === "runtime.error" ||
(work.itemType === "error" && work.toolLifecycleStatus !== "completed")
);
}
function deriveInFlightSteerAnswerIds(entries: ReadonlyArray<TimelineEntry>): ReadonlySet<string> {
const ids = new Set<string>();
let awaitingReply = false;
let candidate: string | null = null;
for (const entry of entries) {
if (entry.kind === "work" && entry.entry.itemType === "reasoning") continue;
const reply = entry.kind === "message" && entry.message.role === "assistant" ? entry : null;
if (candidate !== null && reply !== null) ids.add(candidate);
candidate = null;
if (timelineEntryIsSteer(entry)) {
awaitingReply = true;
} else if (entry.kind === "message" && entry.message.role === "user") {
awaitingReply = false;
} else if (reply !== null && awaitingReply) {
candidate = reply.message.id;
awaitingReply = false;
}
}
return ids;
}
export function liveAnswerPreview(entries: ReadonlyArray<TimelineEntry>): string | null {
const boundary = lastResponseBoundaryIndex(entries);
for (let index = entries.length - 1; index > boundary; index -= 1) {
const entry = entries[index]!;
const text =
entry.kind === "message" && entry.message.role === "assistant"
? entry.message.text
: entry.kind === "work" && entry.entry.itemType === "reasoning"
? (entry.entry.detail ?? "")
: "";
const line = liveThoughtLine(text);
if (line !== "") return line;
}
return null;
}
function timelineRowEntries(
input: Pick<
MessagesTimelineRowsInput,
| "timelineEntries"
| "toolCallVisibility"
| "revealedMessageId"
| "isWorking"
| "latestRun"
| "runningRunId"
| "pendingApprovalRequestIds"
>,
) {
const visibility = input.toolCallVisibility ?? "showAll";
const entries = input.timelineEntries;
let shown = entries;
if (visibility === "zen") {
const answering = input.isWorking && input.latestRun?.turnEnded !== true;
const answeringRunId = answering
? deriveUnsettledRunId(input.latestRun ?? null, input.runningRunId ?? null)
: null;
const answeringFrom = answering ? lastResponseBoundaryIndex(entries) + 1 : entries.length;
const terminalIds = deriveTerminalAssistantMessageIds(entries);
const steerAnswerIds = deriveInFlightSteerAnswerIds(entries);
shown = entries.filter((entry, index) => {
if (entry.kind !== "message") {
return workShownAsFinalAnswerOnly(entry, input.pendingApprovalRequestIds);
}
const { message } = entry;
return (
message.role !== "assistant" ||
message.id === input.revealedMessageId ||
steerAnswerIds.has(message.id) ||
(terminalIds.has(message.id) &&
index < answeringFrom &&
(answeringRunId === null || message.runId !== answeringRunId))
);
});
} else if (visibility !== "showAll") {
shown = entries.filter(
(entry) =>
entry.kind !== "work" || !workEntryHiddenByToolCallVisibility(entry.entry, visibility),
);
}
return withoutSubagentDelegationRows(settleSupersededReasoning(shown));
}
function deriveTimelineTurnFolds(
input: Pick<
MessagesTimelineRowsInput,
| "timelineEntries"
| "latestRun"
| "isWorking"
| "runlessWorkActive"
| "runningRunId"
| "toolCallVisibility"
| "revealedMessageId"
>,
) {
if (input.toolCallVisibility === "zen") return new Map<string, TurnFold>();
const timelineEntries = timelineRowEntries(input);
const unsettledRunId = deriveUnsettledRunId(input.latestRun ?? null, input.runningRunId ?? null);
const failedRunIds = failedTimelineRunIds(timelineEntries, input.latestRun ?? null);
const activeVisualResponseRunIds = deriveActiveVisualResponseRunIds({
timelineEntries,
unsettledRunId,
isWorking: input.isWorking,
});
return deriveTurnFolds({
timelineEntries,
terminalAssistantMessageIds: deriveTerminalAssistantMessageIds(timelineEntries),
latestRun: input.latestRun ?? null,
unfoldedRunIds: new Set([...activeVisualResponseRunIds, ...failedRunIds]),
runlessWorkActive: input.isWorking && input.runlessWorkActive === true,
liveSubagentEntryIds: liveSubagentCardEntryIds(timelineEntries),
completeSupersededReplyEntryIds: completeSupersededReplyEntryIds(timelineEntries),
});
}
export function deriveMessagesTimelineRows(input: {
timelineEntries: ReadonlyArray<TimelineEntry>;
pendingApprovalRequestIds?: ReadonlySet<RuntimeRequestId>;
latestRun?: TimelineLatestRun | null;
runningRunId?: RunId | null;
expandedRunIds?: ReadonlySet<RunId>;
expandedAttemptIds?: ReadonlySet<RunAttemptId>;
expandedWorkGroupIds?: ReadonlySet<string>;
isWorking: boolean;
/** Native subagent work has no app run; runless entries form the live response. */
runlessWorkActive?: boolean;
activeTurnStartedAt?: string | null;
turnDiffSummaries: ReadonlyArray<TurnDiffSummary>;
supportsConversationRollback: boolean;
threadStartCheckpointReady?: boolean;
availableRevertTurnCounts?: ReadonlySet<number> | undefined;
worktreeSetup?: WorktreeSetupSnapshot | null;
toolCallVisibility?: ToolCallVisibility;
revealedMessageId?: MessageId | null;
}): MessagesTimelineRow[] {
const timelineEntries = timelineRowEntries(input);
const isPendingApproval = (entry: WorkLogEntry) => {
const item = entry.projectedItem?.item;
return (
item?.type === "approval_request" &&
input.pendingApprovalRequestIds?.has(item.requestId) === true
);
};
const turnDiffSummaryByAssistantMessageId = new Map<MessageId, TurnDiffSummary>();
for (const summary of input.turnDiffSummaries) {
if (summary.assistantMessageId) {
turnDiffSummaryByAssistantMessageId.set(summary.assistantMessageId, summary);
}
}
const unsettledRunId = deriveUnsettledRunId(input.latestRun ?? null, input.runningRunId ?? null);
const revertTurnCountByUserMessageId = input.supportsConversationRollback
? deriveRevertTurnCountByUserMessageId({
timelineEntries: input.timelineEntries,
checkpoints: input.turnDiffSummaries,
threadStartCheckpointReady: input.threadStartCheckpointReady === true,
unsettledRunId,
availableRevertTurnCounts: input.availableRevertTurnCounts,
})
: new Map<MessageId, number>();
const nextRows: MessagesTimelineRow[] = [];
const terminalAssistantMessageIds = deriveTerminalAssistantMessageIds(timelineEntries);
const failedRunIds = failedTimelineRunIds(timelineEntries, input.latestRun ?? null);
const itemizedRunIds = itemizedFailedRunIds(timelineEntries, failedRunIds);
const liveSubagentEntryIds = liveSubagentCardEntryIds(timelineEntries);
const completeSupersededReplyIds = completeSupersededReplyEntryIds(timelineEntries);
const supersededFoldsByAnchorEntryId = deriveSupersededAttemptFolds(
timelineEntries,
failedRunIds,
liveSubagentEntryIds,
completeSupersededReplyIds,
);
const supersededWorkItemIds = new Set(
[...supersededFoldsByAnchorEntryId.values()].flatMap((fold) => fold.deferredWorkItemIds),
);
const activeVisualResponseRunIds = deriveActiveVisualResponseRunIds({
timelineEntries: timelineEntries,
unsettledRunId,
isWorking: input.isWorking,
});
const runlessWorkActive = input.isWorking && input.runlessWorkActive === true;
const foldsByAnchorEntryId =
input.toolCallVisibility === "zen"
? new Map<string, TurnFold>()
: deriveTurnFolds({
timelineEntries: timelineEntries,
terminalAssistantMessageIds,
latestRun: input.latestRun ?? null,
unfoldedRunIds: new Set([...activeVisualResponseRunIds, ...failedRunIds]),
runlessWorkActive,
liveSubagentEntryIds,
completeSupersededReplyEntryIds: completeSupersededReplyIds,
});
const timelineEntryById = new Map(timelineEntries.map((entry) => [entry.id, entry]));
const collapsedEntryIds = new Set<string>();
const collapsedFoldMemberIds = new Set<string>();
for (const fold of foldsByAnchorEntryId.values()) {
if (!input.expandedRunIds?.has(fold.runId)) {
for (const entryId of fold.hiddenEntryIds) {
collapsedEntryIds.add(entryId);
}
for (const entryId of fold.entryIds) {
collapsedFoldMemberIds.add(entryId);
}
}
}
const collapsedSupersededEntryIds = new Set<string>();
for (const fold of supersededFoldsByAnchorEntryId.values()) {
if (!input.expandedAttemptIds?.has(fold.attemptId)) {
for (const entryId of fold.hiddenEntryIds) {
collapsedSupersededEntryIds.add(entryId);
}
}
}
if (input.pendingApprovalRequestIds?.size) {
for (const entry of timelineEntries) {
if (entry.kind === "work" && isPendingApproval(entry.entry)) {
collapsedEntryIds.delete(entry.id);
collapsedSupersededEntryIds.delete(entry.id);
}
}
}
const runIdIsActiveResponse = (runId: RunId | null | undefined) =>
runId == null ? runlessWorkActive : activeVisualResponseRunIds.has(runId);
const workEntryIsInActiveRun = (entry: WorkLogEntry) =>
input.isWorking &&
entry.toolLifecycleStatus === "inProgress" &&
(entry.runId == null ? runlessWorkActive : entry.runId === unsettledRunId);
const activeTurnHeaderIndex = input.isWorking
? lastResponseBoundaryIndex(timelineEntries) + 1
: timelineEntries.length;
const activeToolEntries: Array<Extract<TimelineEntry, { kind: "work" }>> = [];
if (input.isWorking && (unsettledRunId !== null || runlessWorkActive)) {
let tailAttemptId: string | null | undefined;
for (let index = timelineEntries.length - 1; index >= activeTurnHeaderIndex; index -= 1) {
const entry = timelineEntries[index]!;
if (
entry.kind !== "work" ||
entry.entry.tone === "error" ||
entry.entry.sourceActivityKind === "runtime.error" ||
entry.entry.itemType === "system_notice" ||
entry.entry.itemType === "notification" ||
entry.entry.itemType === "todo_list" ||
entry.entry.questionAnswer !== undefined ||
isPendingApproval(entry.entry) ||
!runIdIsActiveResponse(entry.entry.runId) ||
entry.entry.sourceActivityKind === "context-compaction" ||
collapsedEntryIds.has(entry.id) ||
collapsedSupersededEntryIds.has(entry.id) ||
foldsByAnchorEntryId.has(entry.id) ||
supersededFoldsByAnchorEntryId.has(entry.id)
) {
break;
}
if (tailAttemptId === undefined) {
tailAttemptId = entry.attempt?.id ?? null;
} else if ((entry.attempt?.id ?? null) !== tailAttemptId) {
break;
}
activeToolEntries.push(entry);
}
}
activeToolEntries.reverse();
const visibleActiveToolEntries = activeToolEntries.filter((entry) =>
workEntryIsVisibleInGroup(entry.entry, true),
);
const activeWorkAnchor = activeToolEntries[0];
const latestVisibleToolEntry = visibleActiveToolEntries.at(-1);
const latestRunningToolEntry = visibleActiveToolEntries.findLast((entry) =>
workEntryIsActiveTurnActivity(entry.entry),
);
const latestToolKeepsActivityLive =
latestRunningToolEntry !== undefined ||
(latestVisibleToolEntry !== undefined &&
workEntryIndicatesToolSuccess(latestVisibleToolEntry.entry) &&
!input.pendingApprovalRequestIds?.size);
const latestToolFailed =
latestRunningToolEntry === undefined &&
latestVisibleToolEntry !== undefined &&
latestVisibleToolEntry.entry.toolLifecycleStatus !== "declined" &&
workEntryDisplayIndicatesToolFailure(latestVisibleToolEntry.entry);
const latestThoughtEntry = visibleActiveToolEntries.findLast(
(entry) => entry.entry.itemType === "reasoning" && (entry.entry.detail?.trim() ?? "") !== "",
);
const activeWorkPlacementEntryId = latestVisibleToolEntry?.id;
const activeWorkRow =
activeWorkAnchor && latestVisibleToolEntry && !latestToolFailed
? (() => {
const groupId = workGroupId(activeWorkAnchor.id);
return {
kind: "work-live" as const,
id: latestToolKeepsActivityLive
? LIVE_ACTIVITY_ROW_ID
: `work-live:${activeWorkAnchor.id}`,
createdAt: activeWorkAnchor.createdAt,
entry: (latestRunningToolEntry ?? latestVisibleToolEntry).entry,
groupedEntries: visibleActiveToolEntries.map((entry) => entry.entry),
groupId,
expanded: input.expandedWorkGroupIds?.has(groupId) ?? false,
active: latestToolKeepsActivityLive,
...(latestThoughtEntry ? { thought: latestThoughtEntry.entry } : {}),
};
})()
: null;
const activeWorkEntryIds = new Set(
activeWorkRow !== null || latestToolFailed ? activeToolEntries.map((entry) => entry.id) : [],
);
// A bare `/compact` turn is the compaction itself: one compaction row stands in for its prompt
// and working indicator, from the moment the turn starts. Likewise an answered "compact before
// continuing?" question folds into the compaction it asked for.
const compactionRuns = new Map<RunId, OrchestrationV2IdleCompaction | undefined>();
const compactedRunIds = new Set<RunId>();
const pendingResumeCompactionAgeByRunId = new Map<RunId, string>();
const resumeCompactionAgeByEntryId = new Map<string, string>();
for (const entry of timelineEntries) {
if (
entry.kind === "message" &&
entry.message.runId !== null &&
isCompactionCommandMessage(entry.message)
) {
compactionRuns.set(entry.message.runId, idleCompactionOf(entry.message));
} else if (entry.kind === "work" && entry.entry.runId) {
if (timelineEntryIsCompaction(entry)) {
compactedRunIds.add(entry.entry.runId);
const age = pendingResumeCompactionAgeByRunId.get(entry.entry.runId);
if (age !== undefined) {
resumeCompactionAgeByEntryId.set(entry.id, age);
pendingResumeCompactionAgeByRunId.delete(entry.entry.runId);
}
}
const age = entry.entry.questionAnswer
? claudeResumeCompactionAge(entry.entry.questionAnswer)
: null;
if (age !== null) pendingResumeCompactionAgeByRunId.set(entry.entry.runId, age);
}
}
const compactionTitle = (runId: RunId | null | undefined, entryId: string) => {
if (runId == null) return undefined;
const reason = compactionRuns.get(runId);
if (reason !== undefined) return IDLE_COMPACTION_TITLES[reason];
const age = resumeCompactionAgeByEntryId.get(entryId);
return age ? `Context compacted after ${age} idle` : undefined;
};
const activeCompactionEntry = timelineEntries.find(
(entry): entry is Extract<TimelineEntry, { kind: "work" }> =>
timelineEntryIsCompaction(entry) &&
entry.kind === "work" &&
workEntryIsInActiveRun(entry.entry),
);
const activeRunIsCompaction =
input.isWorking && unsettledRunId !== null && compactionRuns.has(unsettledRunId);
// The item can finish before its run settles; only other work should keep activity visible.
const compactionRunFinished =
activeRunIsCompaction &&
compactedRunIds.has(unsettledRunId) &&
activeCompactionEntry === undefined;
const compactionOnlyRunFinished =
compactionRunFinished &&
!timelineEntries.some(
(entry) =>
timelineEntryRunId(entry) === unsettledRunId &&
!timelineEntryIsCompaction(entry) &&
!(entry.kind === "message" && isCompactionCommandMessage(entry.message)),
);
const runningCompactionRunId =
activeRunIsCompaction && !compactionRunFinished ? unsettledRunId : null;
// Compacting on return holds back the message the user just sent, so the working row says why
// it is waiting. Any other compaction shows only its live divider, never both.
const compactsOnReturn =
runningCompactionRunId !== null && compactionRuns.get(runningCompactionRunId) === "onReturn";
// The question is answered mid-turn, so the row times this compaction, not the turn.
const resumeCompactionEntry =
activeCompactionEntry?.entry.runId != null &&
resumeCompactionAgeByEntryId.has(activeCompactionEntry.id)
? activeCompactionEntry
: undefined;
const activeCompactionRunId = compactsOnReturn
? runningCompactionRunId
: (resumeCompactionEntry?.entry.runId ?? null);
const endedRunId = input.latestRun?.turnEnded === true ? input.latestRun.runId : null;
const zenAnswerLanded =
input.toolCallVisibility === "zen" &&
endedRunId !== null &&
timelineEntries.findLastIndex((entry) => timelineEntryRunId(entry) === endedRunId) >=
activeTurnHeaderIndex;
const appendWorkingRow = () => {
if (compactionOnlyRunFinished || zenAnswerLanded) return;
if (runningCompactionRunId !== null && activeCompactionRunId === null) return;
nextRows.push({
kind: "working",
id: "working-indicator-row",
createdAt:
(compactsOnReturn ? undefined : resumeCompactionEntry?.entry.createdAt) ??
input.activeTurnStartedAt ??
null,
...(activeCompactionRunId !== null ? { compacting: true as const } : {}),
});
};
let hasActivityRow = false;
const hasActiveCompaction =
activeCompactionEntry !== undefined || (activeRunIsCompaction && !compactionRunFinished);
const appendActiveWorkRows = () => {
if (activeWorkRow === null) return;
nextRows.push(activeWorkRow);
hasActivityRow ||= activeWorkRow.active;
if (!activeWorkRow.expanded) return;
nextRows.push(
expandedWorkGroupRow(
activeWorkRow.groupId,
activeWorkRow.createdAt,
activeWorkRow.groupedEntries,
),
);
};
for (let index = 0; index < timelineEntries.length; index += 1) {
const timelineEntry = timelineEntries[index];
if (!timelineEntry) {
continue;
}
if (input.isWorking && index === activeTurnHeaderIndex) {
appendWorkingRow();
}
if (timelineEntry.id === activeWorkPlacementEntryId) {