@opengeni/react 3.1.0 → 3.1.3-canary.38890816741001

package/src/timeline/projection.ts

@@ -1,20 +1,36 @@
 import {
+  parseCustomMcpSetupRequest,
   parseMediaGenerationResult,
+  parseToolDisplayMetadata,
+  EMPTY_FINAL_REPLY_NOTICE,
+  turnCompletedWithEmptyFinalReply,
   type HumanInputAnswer,
   type HumanInputQuestion,
   type HumanInputResponse,
+  type HumanInputSecretAnswerResult,
+  type HumanInputSecretSpec,
   type SessionEvent,
   type SessionStatus,
   type TimelineAnnotation,
 } from "@opengeni/sdk";
 import fleetDecisionItem from "./fleet-decision-projection";
+import {
+  allowanceExhaustedMessage,
+  parseAllowanceExhaustedRefusal,
+} from "@opengeni/sdk/allowance-refusal";
+import {
+  parseSessionUsageLimitReachedRefusal,
+  SESSION_USAGE_LIMIT_SEGMENT,
+  sessionUsageLimitReachedMessage,
+} from "@opengeni/sdk/session-usage-limits";
 import {
   CREDIT_EXHAUSTION_MESSAGE,
-  humanizeFailureReason,
+  presentFailure,
   isCreditExhaustion,
   tryParseJson,
 } from "../lib/format";
 import { mcpToolLeaf, toolMatchesLeaf } from "./tool-display-name";
+import { presentTurnFailureText } from "./compaction-copy";
 import type {
   AgentMessageItem,
   ActivityItem,
@@ -24,7 +40,9 @@ import type {
   HumanInputAnswerSummary,
   HumanInputItem,
   MachineInputBatchItem,
+  MachineInputMember,
   MemoryItem,
+  NoticeItem,
   SandboxItem,
   StartupPhase,
   StartupPhaseItem,
@@ -39,6 +57,14 @@ import type {
 
 export { toolDisplayName, mcpToolLeaf, toolMatchesLeaf } from "./tool-display-name";
 
+/** Message identity only: queue placement needs the surrounding turn history. */
+export function isTimelineUserQuestion(event: SessionEvent): boolean {
+  return (
+    event.type === "user.message" &&
+    workerCompletionPayload(asRecord(event.payload).childCompletion) === null
+  );
+}
+
 /* ----------------------------------------------------------------------------
    Timeline projection
 
@@ -53,11 +79,13 @@ export { toolDisplayName, mcpToolLeaf, toolMatchesLeaf } from "./tool-display-na
    memoized, unit-tested, and re-run incrementally as new events stream in.
    -------------------------------------------------------------------------- */
 
-/** Tool leaves on the first-party OpenGeni MCP server that operate on sessions. */
+/** Tool leaves on the first-party Opengeni MCP server that operate on sessions. */
 const WORKER_SPAWN_TOOL = "session_create";
 const WORKER_MESSAGE_TOOL = "session_send_message";
 const WORKER_FAILURE_CODE_MAX_LENGTH = 128;
 const WORKER_FAILURE_MESSAGE_MAX_UTF8_BYTES = 1_024;
+type PendingWaitOutcome = { id: string; reason: string; occurredAt: string };
+type TrackedAgentResponse = { item: AgentMessageItem; completed: boolean };
 
 /**
  * Tools whose durable side-effect events already own the timeline (MemoryRow).
@@ -127,16 +155,110 @@ function timelineAnnotationToolOutputText(output: unknown): string | null {
   return text.length > 0 ? text : null;
 }
 
-export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
+export function buildTimeline(
+  events: SessionEvent[],
+  options: { partialStart?: boolean } = {},
+): TimelineItem[] {
   const items: TimelineItem[] = [];
+  const allowanceNotices = new Set<string>();
+  const allowanceNotice = (event: SessionEvent, turnId: string | null) => {
+    const refusal = parseAllowanceExhaustedRefusal(event.payload);
+    if (!refusal) return null;
+    const text = allowanceExhaustedMessage(refusal);
+    const key = JSON.stringify([
+      turnId,
+      event.turnAttemptId,
+      startupRecoveryRevisionByTurn.get(turnId ?? "") ?? 0,
+      refusal.scope,
+      refusal.subjectId,
+      refusal.resetsAt,
+    ]);
+    if (!allowanceNotices.has(key)) {
+      allowanceNotices.add(key);
+      items.push({
+        kind: "notice",
+        id: `${event.id}-allowance`,
+        tone: "failed",
+        text,
+        // The canonical sentence replaces upstream prose, so a host renderer
+        // reading `message` never shows a wrapper's private wording.
+        allowance: { ...refusal, message: text },
+        occurredAt: event.occurredAt,
+      });
+    }
+    return text;
+  };
   const prescan = prescanTurnAnchors(events);
   const ordered = orderTimelineEvents(events, prescan);
+  // A bounded replay can begin halfway through a message (including inside an
+  // interactive fence). Never parse that suffix as a complete Markdown source.
+  // Keep the raw events available for pagination; a completed receipt restores
+  // the authoritative message without requiring an unbounded history fetch.
+  let completeHistoryPrefix = options.partialStart !== true;
+  const knownMessagePrefixTurns = new Set<string | null>();
+  const incompleteMessageKeys = new Set<string>();
+  const pendingWaitOutcomeByTurn = new Map<string | null, PendingWaitOutcome>();
+  const latestAgentResponseByTurn = new Map<string | null, TrackedAgentResponse>();
+  const identifiedMessages = new Map<string, AgentMessageItem>();
   const humanInputRequests = humanInputRequestsById(events);
   const humanInputToolCallIds = new Set(
     [...humanInputRequests.values()]
       .map((request) => stringValue(request.toolCallId))
       .filter(Boolean),
   );
+  // Delegated workers that have not reported back yet, so a recorded agent wait
+  // can say how many agents it is waiting for. Only a session's own workers
+  // report back, so a message to any other session is never awaited. Best
+  // effort: a bounded replay only knows the spawns and results inside its window.
+  const workerSessions = new Set<string>();
+  const pendingWorkerSessions = new Set<string>();
+  let openWaitNotice: NoticeItem | null = null;
+  // Tool results update the original tool row in place, and running lifecycle
+  // receipts have no row. Carry resume evidence on the attention landmarks so
+  // grouping cannot mistake historical approval for a live wait.
+  const presentationWaits = new Map<string | null, Array<NoticeItem | SessionStatusItem>>();
+  // Admission blocks hold the whole session, not one turn; any later status
+  // (a recheck, a new message, a pause) ends them.
+  let openAdmissionBlocks: SessionStatusItem[] = [];
+  const presentationFailures = new Map<string | null, SessionStatusItem[]>();
+  let presentationTurnId: string | null = null;
+  const rememberPresentationWait = (
+    item: NoticeItem | SessionStatusItem,
+    turnId: string | null,
+  ) => {
+    const key = turnId ?? presentationTurnId;
+    const waits = presentationWaits.get(key) ?? [];
+    waits.push(item);
+    presentationWaits.set(key, waits);
+    items.push(item);
+  };
+  const resolvePresentationWait = (event: SessionEvent, turnId: string | null) => {
+    if (event.duplicateOfEventId || (event.turnAssociation && event.turnAssociation !== "current"))
+      return;
+    const key = turnId ?? presentationTurnId;
+    for (const item of presentationWaits.get(key) ?? []) item.resolvedAt = event.occurredAt;
+    presentationWaits.delete(key);
+  };
+  // Live model-capacity waits. Later lifecycle evidence that the turn is no
+  // longer blocked (resume, a non-waiting status, its settlement) resolves
+  // them, so a recovered wait never lingers as a warning.
+  let openCapacityWaits: NoticeItem[] = [];
+  const resolveCapacityWaits = (event: SessionEvent, payload: Record<string, unknown>) => {
+    if (openCapacityWaits.length === 0 || !endsCapacityWait(event, payload)) return;
+    const eventTurnId = event.turnId ?? null;
+    openCapacityWaits = openCapacityWaits.filter((item) => {
+      const waitTurnId = item.capacityWait?.turnId ?? null;
+      // Status changes are session-wide; a turn settlement ends only its own wait
+      // (a queued follow-up being cancelled does not unblock the waiting turn).
+      const ends =
+        event.type === "session.status.changed" ||
+        eventTurnId === null ||
+        waitTurnId === null ||
+        eventTurnId === waitTurnId;
+      if (ends) item.resolvedAt = event.occurredAt;
+      return !ends;
+    });
+  };
   const queuedAtByTurn = new Map<string, string>();
   const startupRecoveryRevisionByTurn = new Map<string, number>();
   const startupPhases = new Map<string, readonly [StartupPhaseItem, string | null, number]>();
@@ -153,6 +275,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
     mode = 0,
     explicitStartedAt?: string,
     explicitId?: string,
+    blockedReason?: StartupPhaseItem["blockedReason"],
   ): void => {
     const key = `${startupTurnId}:${phase}`;
     const priorState = startupPhases.get(key);
@@ -179,6 +302,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           ? elapsedDurationMs(open.startedAt, startupEvent.occurredAt)
           : Math.max(0, duration);
       open.outcome = outcome ?? open.outcome;
+      open.blockedReason = blockedReason;
       return;
     }
     const running = status === "running";
@@ -197,6 +321,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         completedAt: running ? null : startupEvent.occurredAt,
         durationMs,
         outcome,
+        blockedReason,
         occurredAt: startedAt,
       } satisfies Partial<StartupPhaseItem>);
       startupPhases.set(key, [prior, startupAttemptId, startupRecoveryRevision]);
@@ -212,6 +337,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       completedAt: running ? null : startupEvent.occurredAt,
       durationMs,
       outcome,
+      blockedReason,
       occurredAt: startedAt,
     };
     items.push(item);
@@ -220,6 +346,31 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
 
   const last = (): TimelineItem | undefined => items[items.length - 1];
 
+  const rememberAgentResponse = (
+    turnId: string | null,
+    item: AgentMessageItem,
+    completed: boolean,
+  ): void => {
+    latestAgentResponseByTurn.set(turnId, { item, completed });
+  };
+
+  const takePendingWaitOutcome = (turnId: string | null): PendingWaitOutcome | undefined => {
+    const outcome = pendingWaitOutcomeByTurn.get(turnId);
+    pendingWaitOutcomeByTurn.delete(turnId);
+    return outcome;
+  };
+
+  const takeAgentResponse = (turnId: string | null): TrackedAgentResponse | undefined => {
+    const response = latestAgentResponseByTurn.get(turnId);
+    latestAgentResponseByTurn.delete(turnId);
+    return response;
+  };
+
+  const clearUnscopedTerminalTracking = (): void => {
+    latestAgentResponseByTurn.delete(null);
+    pendingWaitOutcomeByTurn.delete(null);
+  };
+
   /** A new item of a different kind ends whatever was streaming at the tail. */
   const closeStreamingTail = (): void => {
     const open = last();
@@ -265,6 +416,40 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
   for (const event of ordered) {
     const payload = asRecord(event.payload);
     const turnId = event.turnId ?? null;
+    resolveCapacityWaits(event, payload);
+    if (
+      turnId &&
+      (event.type === "turn.started" ||
+        (presentationTurnId === null && isAgentActivityEvent(event.type)))
+    ) {
+      presentationTurnId = turnId;
+    }
+    if (
+      openWaitNotice &&
+      (event.type === "user.message" ||
+        event.type === "system.update.delivered" ||
+        event.type === "turn.started" ||
+        event.type === "session.control.paused" ||
+        (event.type === "session.status.changed" &&
+          (payload.status === "cancelled" || payload.status === "failed")))
+    ) {
+      // New input, a pause, or the end of the session ends a recorded wait; the
+      // notice keeps its wait span.
+      openWaitNotice.waitEndedAt = event.occurredAt;
+      openWaitNotice = null;
+    }
+    if (event.type === "session.created") {
+      completeHistoryPrefix = true;
+    } else if (
+      event.type === "turn.started" ||
+      (event.type === "user.message" &&
+        payload.delivery !== "steer" &&
+        payload.routing !== "accepted_for_steering")
+    ) {
+      // Accepted Steer is visible before its replacement turn starts. It says
+      // nothing about the prefix of a still-streaming message from the old turn.
+      knownMessagePrefixTurns.add(turnId);
+    }
     startupEvent = event;
     startupTurnId = turnId;
     startupAttemptId =
@@ -285,11 +470,39 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           : null;
     if (setupPhase && setupStatus) {
       closeStreamingTail();
+      let blockedReason: StartupPhaseItem["blockedReason"];
+      if (setupPhase === "model_preparation" && setupStatus === "failed") {
+        blockedReason = startupLifecycleWaitReason(payload);
+        // Older preparation events omit the typed lifecycle fields. The
+        // sandbox span can supply them only inside the same turn attempt.
+        const sandbox = startupPhases.get(`${startupTurnId}:sandbox`);
+        const sameAttempt =
+          sandbox?.[1] || startupAttemptId
+            ? Boolean(startupAttemptId && sandbox?.[1] === startupAttemptId)
+            : sandbox?.[2] === startupRecoveryRevision;
+        if (
+          !blockedReason &&
+          payload.expectedTransition === undefined &&
+          payload.failureCode === undefined &&
+          payload.failureStage === undefined &&
+          payload.failureCategory === undefined &&
+          payload.error === undefined &&
+          startupTurnId &&
+          sameAttempt &&
+          sandbox?.[0].status === "cancelled"
+        ) {
+          blockedReason = sandbox[0].blockedReason;
+        }
+      }
       settleStartupPhase(
         setupPhase,
-        setupStatus,
+        blockedReason ? "cancelled" : setupStatus,
         numberOrNull(payload.durationMs),
         event.type === "rig.setup.skipped" ? "skipped" : null,
+        0,
+        undefined,
+        undefined,
+        blockedReason,
       );
       continue;
     }
@@ -298,9 +511,12 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       case "user.message": {
         // A steering message must not mark in-flight tools complete; it only
         // ends whatever text was streaming. Turn lifecycle events finalize.
+        clearUnscopedTerminalTracking();
         closeStreamingTail();
         const childCompletion = workerCompletionPayload(payload.childCompletion);
         if (childCompletion) {
+          workerSessions.add(childCompletion.childSessionId);
+          pendingWorkerSessions.delete(childCompletion.childSessionId);
           items.push({
             kind: "worker-completion",
             id: event.id,
@@ -317,6 +533,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           break;
         }
         const voiceMessage = realtimeVoiceMessage(payload);
+        const sender = messageSender(payload.initiator);
         items.push({
           kind: "user-message",
           id: event.id,
@@ -336,6 +553,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           ...(voiceMessage ? { presentation: voiceMessage.presentation } : {}),
           resources: resourceRefs(payload.resources),
           tools: toolRefs(payload.tools),
+          ...(sender ? { sender } : {}),
           occurredAt: event.occurredAt,
         });
         break;
@@ -353,13 +571,50 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         break;
       }
 
+      case "system.update.settled": {
+        // An operator retirement is a passive historical receipt, not a new
+        // prompt or model-input delivery. Reuse the existing agent-result row
+        // while ordinary turn-input settlement metadata remains quiet.
+        if (payload.notificationOnly !== true || payload.reason !== "operator_retirement") break;
+        const members = machineInputMembers(payload.members).filter(
+          (member) =>
+            member.kind === "child_terminal_result" && member.classification === "failure",
+        );
+        if (members.length === 0) break;
+        for (const member of members) {
+          workerSessions.add(member.sourceId);
+          pendingWorkerSessions.delete(member.sourceId);
+        }
+        items.push({
+          kind: "machine-input-batch",
+          id: event.id,
+          turnId: null,
+          members,
+          occurredAt: event.occurredAt,
+        });
+        break;
+      }
+
       case "system.update.delivered": {
         const inputs = machineInputMembers(payload.members);
+        for (const input of inputs) {
+          if (input.kind === "child_terminal_result") {
+            workerSessions.add(input.sourceId);
+            pendingWorkerSessions.delete(input.sourceId);
+          }
+        }
         if (inputs.length === 0) break;
-        // Goal continuations already land as `goal.continuation` GoalRows.
-        // A solo continuation batch would duplicate that landmark + dump the
-        // model-facing prompt — skip chrome for that case only.
-        if (inputs.every((member) => member.kind === "goal_continuation")) {
+        // Background command receipts are agent-facing inputs, not chat messages.
+        // The durable event remains available to the agent and audit history.
+        const visibleInputs = inputs.filter(
+          (member) => member.kind !== "background_command_result",
+        );
+        // Goal continuations already have GoalRows. A batch with no other
+        // visible update must not interrupt an in-flight streaming message.
+        if (
+          visibleInputs.length === 0 ||
+          visibleInputs.every((member) => member.kind === "goal_continuation")
+        ) {
           break;
         }
         closeStreamingTail();
@@ -367,7 +622,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           kind: "machine-input-batch",
           id: event.id,
           turnId,
-          members: inputs,
+          members: visibleInputs,
           occurredAt: event.occurredAt,
         });
         break;
@@ -378,31 +633,85 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         if (!text) {
           break;
         }
+        const messageId = stringValue(payload.messageId);
+        const messageKey = messageId ? JSON.stringify([turnId, messageId]) : null;
+        // Responses providers declare the phase when they announce the item, so
+        // a streaming progress note is known as commentary before it completes.
+        const phase = assistantMessagePhase(payload.phase);
+        if (
+          (!completeHistoryPrefix && !knownMessagePrefixTurns.has(turnId)) ||
+          (messageKey && incompleteMessageKeys.has(messageKey))
+        ) {
+          if (messageKey) incompleteMessageKeys.add(messageKey);
+          break;
+        }
+        const identified = messageKey ? identifiedMessages.get(messageKey) : undefined;
+        if (identified) {
+          if (identified.annotationSource?.eventType !== "agent.message.completed") {
+            identified.text += text;
+            if (phase && !identified.phase) identified.phase = phase;
+            rememberAgentResponse(turnId, identified, false);
+          }
+          break;
+        }
         const open = last();
-        if (open?.kind === "agent-message" && open.streaming && open.turnId === turnId) {
+        if (!messageKey && open?.kind === "tool-call" && open.status === "running") {
+          const previous = latestAgentResponseByTurn.get(turnId);
+          const previousIndex = previous ? items.indexOf(previous.item) : -1;
+          if (
+            previous &&
+            !previous.completed &&
+            previousIndex >= 0 &&
+            items
+              .slice(previousIndex + 1)
+              .every(
+                (item) =>
+                  item.kind === "tool-call" && item.turnId === turnId && item.status === "running",
+              )
+          ) {
+            // Legacy deltas have no provider message identity. Tool creation
+            // alone is not a text boundary; completed output still is.
+            previous.item.text += text;
+            break;
+          }
+        }
+        if (
+          !messageKey &&
+          open?.kind === "agent-message" &&
+          open.streaming &&
+          open.turnId === turnId
+        ) {
           open.text += text;
+          rememberAgentResponse(turnId, open, false);
           break;
         }
         closeStreamingTail();
-        items.push({
+        const item: AgentMessageItem = {
           kind: "agent-message",
           id: event.id,
           turnId,
           text,
+          ...(phase ? { phase } : {}),
           streaming: true,
           occurredAt: event.occurredAt,
-        });
+        };
+        items.push(item);
+        if (messageKey) identifiedMessages.set(messageKey, item);
+        rememberAgentResponse(turnId, item, false);
         break;
       }
 
       case "agent.message.completed": {
+        knownMessagePrefixTurns.add(turnId);
         const text = stringValue(payload.text);
+        const messageId = stringValue(payload.messageId);
+        const messageKey = messageId ? JSON.stringify([turnId, messageId]) : null;
         const phase = assistantMessagePhase(payload.phase);
         // Reconcile the most recent same-turn agent message — even when
         // activity (tool calls, reasoning) landed after its deltas — so the
         // completed text never duplicates the streamed one.
-        let openIndex = -1;
-        for (let index = items.length - 1; index >= 0; index -= 1) {
+        let openIndex = messageKey ? items.indexOf(identifiedMessages.get(messageKey)!) : -1;
+        for (let index = messageKey ? -1 : items.length - 1; index >= 0; index -= 1) {
           const candidate = items[index];
           if (candidate?.kind === "agent-message" && candidate.turnId === turnId) {
             openIndex = index;
@@ -414,18 +723,26 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           candidate?.kind === "agent-message" ? candidate : undefined;
         if (
           open &&
-          (open.streaming || !open.text || text === open.text || text.startsWith(open.text))
+          (messageKey ||
+            open.streaming ||
+            !open.text ||
+            text === open.text ||
+            text.startsWith(open.text))
         ) {
-          // The completed text is authoritative when it extends what streamed.
-          if (!open.text || (text && text.startsWith(open.text))) {
+          // Identity makes the final text authoritative even if it corrects the
+          // draft; legacy receipts still require an extension match.
+          if (!open.text || (text && (messageKey || text.startsWith(open.text)))) {
             open.text = text || open.text;
           }
-          open.streaming = false;
           // A phase-less settlement mirror (the worker's final-output receipt)
           // must not erase the provider-declared phase captured by the SDK item.
           if (phase) open.phase = phase;
-          // Completion time is what the footer shows ("finished at"); keep the
-          // first-delta stamp only until this event arrives.
+          // Completion time is what the footer shows ("finished at"); the
+          // first-delta stamp stays as the stream's start.
+          if (open.startedAt === undefined && open.occurredAt !== event.occurredAt) {
+            open.startedAt = open.occurredAt;
+          }
+          open.streaming = false;
           open.occurredAt = event.occurredAt;
           open.annotationSource =
             text && open.text === text
@@ -447,10 +764,11 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
             items.splice(openIndex, 1);
             items.push(open);
           }
+          rememberAgentResponse(turnId, open, true);
           break;
         }
         if (text) {
-          items.push({
+          const item: AgentMessageItem = {
             kind: "agent-message",
             id: event.id,
             turnId,
@@ -466,7 +784,10 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
               turnId,
               text,
             },
-          });
+          };
+          items.push(item);
+          if (messageKey) identifiedMessages.set(messageKey, item);
+          rememberAgentResponse(turnId, item, true);
         }
         break;
       }
@@ -478,7 +799,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         }
         const open = last();
         if (open?.kind === "reasoning" && open.streaming && open.turnId === turnId) {
-          open.text += text;
+          open.text += reasoningDeltaJoiner(open.text, text) + text;
           break;
         }
         closeStreamingTail();
@@ -495,6 +816,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
 
       case "agent.toolCall.created": {
         const name = typeof payload.name === "string" ? payload.name : "tool";
+        const display = parseToolDisplayMetadata(payload.display);
         const callId = typeof payload.id === "string" ? payload.id : null;
         const args = payload.arguments ?? null;
         closeStreamingTail();
@@ -508,13 +830,16 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           toolMatchesLeaf(name, WORKER_SPAWN_TOOL) ||
           toolMatchesLeaf(name, WORKER_MESSAGE_TOOL)
         ) {
+          const spawn = toolMatchesLeaf(name, WORKER_SPAWN_TOOL);
+          const title = spawn ? workerTitle(args) : null;
           items.push({
             kind: "worker",
             id: event.id,
             turnId,
             callId,
-            action: toolMatchesLeaf(name, WORKER_SPAWN_TOOL) ? "spawn" : "message",
+            action: spawn ? "spawn" : "message",
             prompt: workerPrompt(args),
+            ...(title ? { title } : {}),
             workerSessionId: extractSessionRef(args),
             failure: null,
             status: "running",
@@ -536,6 +861,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
               (item): item is ToolCallItem => item.kind === "tool-call" && item.callId === callId,
             );
           if (existing) {
+            if (display) existing.display = display;
             if (args != null) {
               existing.arguments = args;
             }
@@ -552,6 +878,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           turnId,
           callId,
           name,
+          ...(display ? { display } : {}),
           arguments: args,
           output: undefined,
           truncation: null,
@@ -570,12 +897,20 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         if (!target) {
           break;
         }
+        resolvePresentationWait(event, turnId ?? target.turnId);
         if (target.kind === "worker") {
           // A worker spawn/message that returns an error flag (or an MCP
           // isError result) settles to "failed" too, so WorkerRow surfaces it.
           target.status = isErrorOutput(payload) ? "failed" : "complete";
           target.workerSessionId = target.workerSessionId ?? extractSessionRef(payload.output);
           target.failure = target.status === "failed" ? workerFailure(payload.output) : null;
+          // A spawned or re-messaged worker owes this session a result.
+          if (target.status === "complete" && target.workerSessionId) {
+            if (target.action === "spawn") workerSessions.add(target.workerSessionId);
+            if (workerSessions.has(target.workerSessionId)) {
+              pendingWorkerSessions.add(target.workerSessionId);
+            }
+          }
           break;
         }
         // An output carrying an explicit error flag (or an MCP isError result)
@@ -616,6 +951,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       }
 
       case "turn.started": {
+        if (turnId) clearUnscopedTerminalTracking();
         if (!turnId) break;
         const queuedAt = queuedAtByTurn.get(turnId);
         if (!queuedAt) break;
@@ -631,7 +967,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           null,
           0,
           queuedAt,
-          `${event.id}-queue`,
+          `${turnId}-queue`,
         );
         break;
       }
@@ -656,7 +992,21 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         const startupPhase = startupPhaseForSandboxOperation(name);
         if (startupPhase) {
           closeStreamingTail();
-          settleStartupPhase(startupPhase, status, numberOrNull(payload.durationMs), origin);
+          settleStartupPhase(
+            startupPhase,
+            status,
+            numberOrNull(payload.durationMs),
+            origin,
+            0,
+            undefined,
+            undefined,
+            status === "cancelled"
+              ? (startupLifecycleWaitReason(payload) ??
+                  (payload.failureCode === "rotation_in_progress"
+                    ? "rotation_in_progress"
+                    : undefined))
+              : undefined,
+          );
           break;
         }
         // Routine per-turn platform plumbing that runs before EVERY turn to
@@ -669,8 +1019,13 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         // Rendering either every turn reads as churn. Only FAILURES surface, and
         // they surface loudly — the failed event below creates its own item even
         // without a started row.
+        //   - optional-repository-access: the worker's per-turn report of an
+        //     automatically attached repository that sat the turn out, reported
+        //     like a skipped optional clone (event payload + log, no row).
         if (
-          (name === "repository-clone" || name === "file-resource-download") &&
+          (name === "repository-clone" ||
+            name === "file-resource-download" ||
+            name === "optional-repository-access") &&
           status !== "failed"
         ) {
           break;
@@ -758,6 +1113,12 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         if (!isSessionStatus(status)) {
           break;
         }
+        const blocked = status === "requires_action" && payload.code === "admission_blocked";
+        if (!blocked && openAdmissionBlocks.length > 0) {
+          for (const open of openAdmissionBlocks) open.resolvedAt = event.occurredAt;
+          openAdmissionBlocks = [];
+        }
+        if (status === "running") resolvePresentationWait(event, turnId);
         // Only attention-worthy statuses earn a timeline divider. queued /
         // running / idle are machinery telemetry: the header pill carries the
         // live status, the shimmer says "running", and the turn chip's duration
@@ -769,27 +1130,93 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         const previous = [...items]
           .reverse()
           .find((item): item is SessionStatusItem => item.kind === "session-status");
-        if (previous?.status === status) {
+        if (
+          previous?.status === status &&
+          !previous.resolvedAt &&
+          Boolean(previous.blocked) === blocked
+        ) {
           break;
         }
-        items.push({
+        const item: SessionStatusItem = {
           kind: "session-status",
           id: event.id,
           status,
           occurredAt: event.occurredAt,
-        });
+          ...(blocked ? { blocked: true as const } : {}),
+        };
+        if (blocked) {
+          openAdmissionBlocks.push(item);
+          items.push(item);
+        } else if (status === "requires_action") rememberPresentationWait(item, turnId);
+        else {
+          items.push(item);
+          if (status === "failed") {
+            const key = turnId ?? presentationTurnId;
+            const failures = presentationFailures.get(key) ?? [];
+            failures.push(item);
+            presentationFailures.set(key, failures);
+          }
+        }
         break;
       }
 
-      case "session.requiresAction": {
-        finalizeOpen(turnId, "complete", event.occurredAt);
+      case "subscription.account.switched": {
+        // One neutral receipt, not its provider-specific compatibility alias.
+        // Never expose connection ids, personal labels, or provider error text.
+        const text =
+          payload.reason === "return_to_preferred"
+            ? "Returned to your preferred model."
+            : payload.reason === "failover_cross_provider"
+              ? "Switched to a fallback model."
+              : "Switched to another subscription account.";
         items.push({
+          kind: "notice",
+          id: event.id,
+          tone: "input",
+          text,
+          occurredAt: event.occurredAt,
+        });
+        break;
+      }
+
+      case "codex.capacity.waiting":
+      case "turn.capacity_waiting": {
+        const capacityWait = capacityWaitPresentation(event.type, payload, turnId);
+        const item: NoticeItem = {
           kind: "notice",
           id: event.id,
           tone: "waiting",
-          text: "Approval needed — the turn is paused until someone decides.",
+          text: capacityWait.text,
+          capacityWait: {
+            turnId: capacityWait.turnId,
+            label: capacityWait.label,
+            detail: capacityWait.detail,
+          },
           occurredAt: event.occurredAt,
+        };
+        // A re-armed wait continues the same blocked span; one live wait per turn.
+        openCapacityWaits = openCapacityWaits.filter((open) => {
+          if ((open.capacityWait?.turnId ?? null) !== turnId) return true;
+          open.resolvedAt = event.occurredAt;
+          return false;
         });
+        items.push(item);
+        openCapacityWaits.push(item);
+        break;
+      }
+
+      case "session.requiresAction": {
+        finalizeOpen(turnId, "complete", event.occurredAt);
+        rememberPresentationWait(
+          {
+            kind: "notice",
+            id: event.id,
+            tone: "waiting",
+            text: "Approval needed — the turn is paused until someone decides.",
+            occurredAt: event.occurredAt,
+          },
+          turnId,
+        );
         break;
       }
 
@@ -804,6 +1231,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           estimatedTokensBefore: numberOrNull(payload.estimatedTokensBefore),
           estimatedTokensAfter: null,
           skipReason: null,
+          providerRejection: null,
           implementation:
             typeof payload.implementation === "string" ? payload.implementation : null,
           occurredAt: event.occurredAt,
@@ -821,6 +1249,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           estimatedTokensBefore: numberOrNull(payload.estimatedTokensBefore),
           estimatedTokensAfter: numberOrNull(payload.estimatedTokensAfter),
           skipReason: null,
+          providerRejection: null,
           implementation:
             typeof payload.implementation === "string" ? payload.implementation : null,
           occurredAt: event.occurredAt,
@@ -838,6 +1267,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           estimatedTokensBefore: numberOrNull(payload.estimatedTokensBefore),
           estimatedTokensAfter: null,
           skipReason: typeof payload.reason === "string" ? payload.reason : null,
+          providerRejection: compactionProviderRejection(payload),
           implementation:
             typeof payload.implementation === "string" ? payload.implementation : null,
           occurredAt: event.occurredAt,
@@ -854,6 +1284,23 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
             turnId,
             (startupRecoveryRevisionByTurn.get(turnId) ?? 0) + 1,
           );
+          if (
+            !event.duplicateOfEventId &&
+            (!event.turnAssociation || event.turnAssociation === "current")
+          ) {
+            // Human Retry reopens the existing logical turn, unlike a new
+            // prompt. Keep failure evidence, but do not let its old settlement
+            // close the recovered turn's work surface.
+            for (const item of items) {
+              if (item.kind === "turn-end" && item.turnId === turnId && item.outcome === "failed") {
+                item.resumedAt ??= event.occurredAt;
+              }
+            }
+            for (const item of presentationFailures.get(turnId) ?? []) {
+              item.resolvedAt = event.occurredAt;
+            }
+            presentationFailures.delete(turnId);
+          }
         }
         break;
       }
@@ -868,6 +1315,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       case "tool.auth_needed":
       case "credential.auth_needed": {
         const capability = capabilityAuthorizationRequest(payload.capability);
+        const setupRequest = customMcpSetupRequest(payload.setupRequest);
         if (
           event.type === "tool.auth_needed" &&
           !stringValue(payload.toolName) &&
@@ -890,25 +1338,44 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           id: event.id,
           turnId,
           serverId: typeof payload.serverId === "string" ? payload.serverId : null,
-          source: capability
-            ? "capability"
-            : event.type === "tool.auth_needed"
-              ? "tool"
-              : "credential",
+          canonicalServerId:
+            typeof payload.canonicalServerId === "string" ? payload.canonicalServerId : null,
+          connectionSubjectScope:
+            payload.connectionSubjectScope === "subject" ||
+            payload.connectionSubjectScope === "workspace"
+              ? payload.connectionSubjectScope
+              : null,
+          source:
+            capability || setupRequest
+              ? "capability"
+              : event.type === "tool.auth_needed"
+                ? "tool"
+                : "credential",
           providerDomain: stringValue(payload.providerDomain),
           connectionId: typeof payload.connectionId === "string" ? payload.connectionId : null,
-          reason: authNeededReason(payload.reason),
+          authoritySource: payload.authoritySource === "host" ? "host" : null,
+          reason: authNeededReason(
+            payload.authoritySource === "host" && typeof payload.authorizationUrl === "string"
+              ? (payload.hostReason ?? payload.reason)
+              : payload.reason,
+          ),
           scopes: stringList(payload.scopes),
           resource: typeof payload.resource === "string" ? payload.resource : null,
           toolName: typeof payload.toolName === "string" ? payload.toolName : null,
           authorizationUrl:
             typeof payload.authorizationUrl === "string" ? payload.authorizationUrl : null,
           capability,
+          setupRequest,
           occurredAt: event.occurredAt,
         });
         break;
       }
 
+      case "usage.exhausted": {
+        allowanceNotice(event, turnId);
+        break;
+      }
+
       case "turn.completed": {
         // A standalone manual compaction uses the turn ledger for fencing and
         // recovery, but it is maintenance rather than a conversational turn.
@@ -917,16 +1384,40 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         // extra agent response.
         if (payload.maintenance === "context_compaction") {
           finalizeOpen(turnId, "complete", event.occurredAt);
+          takeAgentResponse(turnId);
+          takePendingWaitOutcome(turnId);
           break;
         }
         // Credit exhaustion arrives as a NOMINALLY completed turn (`detail:
-        // "insufficient OpenGeni credits"`, `segmentLimit: "budget_exhausted"`)
+        // "insufficient Opengeni credits"`, `segmentLimit: "budget_exhausted"`)
         // — the engine ended the segment early, it did not finish the work.
         // Rendering it as a clean "complete" turn is a lie that leaves the
         // session looking healthy while every future turn silently dies, so it
         // projects exactly like a failed turn plus an explicit notice.
+        const allowance = parseAllowanceExhaustedRefusal(payload);
+        // The task's own usage limit refused the next model request. That is a
+        // person's setting doing its job, not a failure or a billing problem:
+        // the turn settles complete and one calm row says what stopped it.
+        if (payload.segmentLimit === SESSION_USAGE_LIMIT_SEGMENT) {
+          finalizeOpen(turnId, "complete", event.occurredAt);
+          takeAgentResponse(turnId);
+          takePendingWaitOutcome(turnId);
+          items.push(turnEndItem(event, "complete", null));
+          items.push(sessionUsageLimitNotice(event, payload));
+          break;
+        }
+        if (allowance) {
+          finalizeOpen(turnId, "complete", event.occurredAt);
+          takeAgentResponse(turnId);
+          takePendingWaitOutcome(turnId);
+          items.push(turnEndItem(event, "failed", ALLOWANCE_TURN_END_TEXT));
+          allowanceNotice(event, turnId);
+          break;
+        }
         if (isCreditExhaustionPayload(payload)) {
           finalizeOpen(turnId, "complete", event.occurredAt);
+          takeAgentResponse(turnId);
+          takePendingWaitOutcome(turnId);
           items.push(turnEndItem(event, "failed", CREDIT_EXHAUSTION_MESSAGE));
           items.push({
             kind: "notice",
@@ -937,44 +1428,166 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           });
           break;
         }
+        const latestAgentResponse = takeAgentResponse(turnId);
+        const finalOutput = stringValue(payload.output);
+        const visibleFinalOutput = stripOpaqueCitationTokens(finalOutput).trim();
+        const visibleTrackedResponse = stripOpaqueCitationTokens(
+          latestAgentResponse?.item.text ?? "",
+        ).trim();
+        const finalOutputMirrorsCommentary =
+          latestAgentResponse?.item.phase === "commentary" &&
+          visibleTrackedResponse === visibleFinalOutput;
+        const hasAuthoritativeFinalOutput =
+          Boolean(visibleFinalOutput) && !finalOutputMirrorsCommentary;
+        const pendingWaitOutcome = takePendingWaitOutcome(turnId);
+        if (hasAuthoritativeFinalOutput) {
+          // The final message normally lands as its own completion before
+          // `turn.completed` (older workers commit a copy with it), but legacy or
+          // partially compacted ledgers may retain only the terminal output
+          // receipt. Keep that authoritative response visible instead of
+          // leaving it trapped in raw audit data.
+          if (
+            latestAgentResponse &&
+            !latestAgentResponse.completed &&
+            finalOutput.startsWith(latestAgentResponse.item.text)
+          ) {
+            latestAgentResponse.item.text = finalOutput;
+            latestAgentResponse.item.streaming = false;
+            if (
+              latestAgentResponse.item.startedAt === undefined &&
+              latestAgentResponse.item.occurredAt !== event.occurredAt
+            ) {
+              latestAgentResponse.item.startedAt = latestAgentResponse.item.occurredAt;
+            }
+            latestAgentResponse.item.occurredAt = event.occurredAt;
+            const responseIndex = items.indexOf(latestAgentResponse.item);
+            if (responseIndex >= 0 && responseIndex < items.length - 1) {
+              items.splice(responseIndex, 1);
+              items.push(latestAgentResponse.item);
+            }
+          } else if (visibleTrackedResponse !== visibleFinalOutput) {
+            items.push({
+              kind: "agent-message",
+              id: `${event.id}-output-message`,
+              turnId,
+              text: finalOutput,
+              streaming: false,
+              occurredAt: event.occurredAt,
+            });
+          }
+        }
         finalizeOpen(turnId, "complete", event.occurredAt);
-        items.push(turnEndItem(event, "complete", null));
+        const completedTurn = turnEndItem(event, "complete", null);
+        items.push(completedTurn);
+        if (turnCompletedWithEmptyFinalReply(payload)) {
+          items.push({
+            kind: "notice",
+            id: `${event.id}-empty-final-reply`,
+            tone: "input",
+            text: EMPTY_FINAL_REPLY_NOTICE,
+            recordedOutcome: true,
+            occurredAt: event.occurredAt,
+          });
+        }
+        const hasCompletedFinalResponse =
+          latestAgentResponse?.completed === true &&
+          latestAgentResponse.item.phase !== "commentary" &&
+          Boolean(visibleTrackedResponse);
+        if (!hasAuthoritativeFinalOutput && pendingWaitOutcome) {
+          // Preserve existing prose, including delta-only streams, when a
+          // trailing wait yields without a terminal output receipt.
+          completedTurn.preserveWaitResponse = true;
+        }
+        if (!hasAuthoritativeFinalOutput && !hasCompletedFinalResponse && pendingWaitOutcome) {
+          const notice: NoticeItem = {
+            kind: "notice",
+            id: `${pendingWaitOutcome.id}-visible-outcome`,
+            tone: "waiting",
+            text: waitingOutcomeText(pendingWaitOutcome.reason),
+            recordedOutcome: true,
+            ...(pendingWorkerSessions.size > 0
+              ? { waitingAgents: pendingWorkerSessions.size }
+              : {}),
+            occurredAt: pendingWaitOutcome.occurredAt,
+          };
+          items.push(notice);
+          openWaitNotice = notice;
+        }
         break;
       }
 
       case "turn.failed": {
+        takeAgentResponse(turnId);
+        takePendingWaitOutcome(turnId);
         const hadActivity = hasTurnActivity(items, turnId);
         // Credit death can hide behind fields `failureMessage` doesn't read
         // (detail/segmentLimit), so classify the whole payload before falling
         // back to the generic error/message extraction.
-        const failureText = isCreditExhaustionPayload(payload)
-          ? CREDIT_EXHAUSTION_MESSAGE
-          : failureMessage(payload);
+        const allowance = parseAllowanceExhaustedRefusal(payload);
+        const failureText = allowance
+          ? ALLOWANCE_TURN_END_TEXT
+          : isCreditExhaustionPayload(payload)
+            ? CREDIT_EXHAUSTION_MESSAGE
+            : failureMessage(payload);
         // The TURN failed — the in-flight items did not. Chip doctrine: red is
         // spent once, on the turn-level outcome. Items caught mid-flight read
         // as calm "interrupted" (same as turn.cancelled); an item that itself
         // failed keeps its own failed status from its output event.
         finalizeOpen(turnId, "cancelled", event.occurredAt);
         items.push(turnEndItem(event, "failed", failureText));
-        if (!hadActivity) {
+        // A compaction failure names its outcome and keeps the recorded
+        // provider text behind Details. The turn's own failed compaction
+        // landmark is the one place that shows it: it receives the recorded
+        // text, and no separate notice repeats it.
+        // Retry reopens the same logical turn, so only a landmark from this
+        // attempt (after the turn's previous settlement) can own this failure.
+        const failure = allowance ? null : presentTurnFailureText(failureText);
+        let landmarkIndex = -1;
+        if (failure?.detail !== undefined && turnId !== null) {
+          // Skip the turn-end just pushed for this failure.
+          for (let index = items.length - 2; index >= 0; index -= 1) {
+            const item = items[index];
+            if (item?.kind === "turn-end" && item.turnId === turnId) break;
+            if (
+              item?.kind === "context-compaction" &&
+              item.turnId === turnId &&
+              item.phase === "skipped" &&
+              item.skipReason === "summarization_failed"
+            ) {
+              landmarkIndex = index;
+              break;
+            }
+          }
+        }
+        const landmark = landmarkIndex >= 0 ? items[landmarkIndex] : undefined;
+        if (landmark?.kind === "context-compaction" && failure?.detail !== undefined) {
+          items[landmarkIndex] = { ...landmark, failureDetail: failure.detail };
+        }
+        if (allowance) {
+          allowanceNotice(event, turnId);
+        } else if (!hadActivity && !landmark) {
           items.push({
             kind: "notice",
             id: event.id,
             tone: "failed",
-            text: failureText ?? "The turn failed.",
+            text: failure?.summary ?? "The turn failed.",
+            ...(failure?.detail ? { details: { label: "Details", value: failure.detail } } : {}),
             occurredAt: event.occurredAt,
           });
         }
         break;
       }
 
+      case "turn.superseded":
       case "turn.cancelled": {
         // A retraction of a never-started queued turn is not a turn ending —
         // the message was withdrawn before any work happened; show nothing.
         // A null turnId proves nothing, so it keeps the legacy finalize path.
-        if (turnId && !prescan.startedTurnIds.has(turnId)) {
+        if (event.type === "turn.cancelled" && turnId && !prescan.startedTurnIds.has(turnId)) {
           break;
         }
+        takeAgentResponse(turnId);
+        takePendingWaitOutcome(turnId);
         const hadActivity = hasTurnActivity(items, turnId);
         finalizeOpen(turnId, "cancelled", event.occurredAt);
         items.push(turnEndItem(event, "cancelled", null));
@@ -990,6 +1603,45 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         break;
       }
 
+      case "instruction.confirmation.recovered": {
+        const receipt = asRecord(payload.receipt);
+        if (receipt.outcome !== "published") break;
+        closeStreamingTail();
+        items.push({
+          kind: "notice",
+          id: event.id,
+          tone: "input",
+          text: "Your previously approved workspace instruction was saved.",
+          occurredAt: event.occurredAt,
+        });
+        break;
+      }
+      case "knowledge.confirmation.recovered":
+      case "knowledge.source.prepared":
+      case "knowledge.source.failed": {
+        const receipt = asRecord(payload.receipt);
+        const outcome = event.type === "knowledge.source.failed" ? "failed" : receipt.outcome;
+        if (
+          (event.type !== "knowledge.confirmation.recovered" &&
+            typeof payload.fileId !== "string") ||
+          !["published", "pending", "rejected", "archived", "failed"].includes(String(outcome))
+        )
+          break;
+        closeStreamingTail();
+        items.push({
+          kind: "knowledge",
+          id: event.id,
+          turnId,
+          fileId: typeof payload.fileId === "string" ? payload.fileId : undefined,
+          filename: typeof payload.filename === "string" ? payload.filename : undefined,
+          entryId: typeof receipt.entryId === "string" ? receipt.entryId : undefined,
+          status: outcome === "failed" ? "failed" : "complete",
+          outcome: outcome as "published" | "pending" | "rejected" | "archived" | "failed",
+          occurredAt: event.occurredAt,
+        });
+        break;
+      }
+
       case "memory.saved":
       case "memory.corrected": {
         // A first-party memory write is a discrete step, not streamed text, so it
@@ -1020,6 +1672,9 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       case "goal.cleared":
       case "goal.held":
       case "goal.continuation": {
+        if (event.type === "goal.held" && payload.actor === "agent") {
+          rememberPendingWaitOutcome(pendingWaitOutcomeByTurn, event, payload, turnId);
+        }
         // Agent tool mutations already appear as tool-call rows in the activity
         // cluster. Re-emitting them as GoalRow landmarks splits "N steps" mid-turn.
         if (shouldSuppressAgentGoalLandmark(event.type, payload)) {
@@ -1038,12 +1693,28 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         break;
       }
 
+      case "session.wait.started": {
+        if (payload.actor === "agent") {
+          rememberPendingWaitOutcome(pendingWaitOutcomeByTurn, event, payload, turnId);
+        }
+        break;
+      }
+
       default:
         break;
     }
   }
 
+  const sourceEventsById = new Map(events.map((event) => [event.id, event]));
   for (const item of items) {
+    const source = sourceEventsById.get(item.id);
+    const canonical = "annotationSource" in item ? item.annotationSource : undefined;
+    item.sourceEvents = [
+      ...(source ? [{ eventId: source.id, sequence: source.sequence }] : []),
+      ...(canonical && canonical.eventId !== source?.id
+        ? [{ eventId: canonical.eventId, sequence: canonical.sequence }]
+        : []),
+    ];
     if (item.kind === "agent-message") {
       item.text = stripOpaqueCitationTokens(item.text);
     }
@@ -1139,10 +1810,13 @@ function humanInputQuestions(value: unknown): HumanInputQuestion[] {
     if (
       !id ||
       !prompt ||
-      (kind !== "text" && kind !== "single_select" && kind !== "multi_select")
+      (kind !== "text" && kind !== "single_select" && kind !== "multi_select" && kind !== "secret")
     ) {
       return [];
     }
+    // Secret questions keep their spec (names and hints only; never a value).
+    const secret = kind === "secret" ? humanInputSecretSpec(question.secret) : null;
+    if (kind === "secret" && !secret) return [];
     const options = Array.isArray(question.options)
       ? question.options.map(asRecord).flatMap((option) => {
           const optionId = stringValue(option.id);
@@ -1162,20 +1836,54 @@ function humanInputQuestions(value: unknown): HumanInputQuestion[] {
         options,
         required: question.required === true,
         allowOther: question.allowOther === true,
+        ...(secret ? { secret } : {}),
       },
     ];
   });
 }
 
+function humanInputSecretSpec(value: unknown): HumanInputSecretSpec | null {
+  const spec = asRecord(value);
+  const item = stringValue(spec.item);
+  if (!item) return null;
+  return spec as unknown as HumanInputSecretSpec;
+}
+
+function humanInputSecretResult(value: unknown): HumanInputSecretAnswerResult | null {
+  if (value === undefined || value === null) return null;
+  const result = asRecord(value);
+  const reference = stringValue(result.reference);
+  const vaultName = stringValue(result.vaultName);
+  const itemName = stringValue(result.itemName);
+  const saveTo = result.saveTo;
+  if (
+    !reference ||
+    !vaultName ||
+    !itemName ||
+    (saveTo !== "user" && saveTo !== "task" && saveTo !== "workspace")
+  ) {
+    return null;
+  }
+  return {
+    reference,
+    username: stringValue(result.username) || null,
+    vaultName,
+    itemName,
+    saveTo,
+  };
+}
+
 function humanInputAnswer(value: Record<string, unknown>): HumanInputAnswer | null {
   const questionId = stringValue(value.questionId);
   if (!questionId) return null;
+  const secret = humanInputSecretResult(value.secret);
   return {
     questionId,
     values: Array.isArray(value.values)
       ? value.values.filter((answer): answer is string => typeof answer === "string")
       : [],
     ...(typeof value.other === "string" && value.other ? { other: value.other } : {}),
+    ...(secret ? { secret } : {}),
   };
 }
 
@@ -1194,6 +1902,7 @@ function humanInputAnswerSummary(
     label: question?.label || question?.prompt || fallbackLabel,
     prompt: question?.prompt || fallbackLabel,
     values,
+    ...(answer.secret ? { secret: answer.secret } : {}),
   };
 }
 
@@ -1257,8 +1966,16 @@ export function stripOpaqueCitationTokens(text: string): string {
   return text.replace(/\s*cite(?:[^]+)+/gu, "");
 }
 
+/**
+ * The turn summary's short outcome for a usage ceiling. The adjacent notice row
+ * carries who can raise it and when it resets (and is host-customizable), so
+ * the summary line stays a neutral fact instead of repeating remedy prose.
+ */
+const ALLOWANCE_TURN_END_TEXT = "Usage limit reached";
+
 /** The turn-end payload shape, as `isCreditExhaustion` wants it. */
 function isCreditExhaustionPayload(payload: Record<string, unknown>): boolean {
+  if (payload.code === "allowance_exhausted") return false;
   return isCreditExhaustion({
     error: typeof payload.error === "string" ? payload.error : null,
     detail: typeof payload.detail === "string" ? payload.detail : null,
@@ -1309,12 +2026,16 @@ export function sessionStatusFromEvents(events: SessionEvent[]): SessionStatus |
    non-user span folds behind a turn group, with activity blocks nested inside.
    -------------------------------------------------------------------------- */
 
+/** Work items: every activity kind except assistant commentary. */
+type WorkActivityItem = Exclude<ActivityItem, AgentMessageItem>;
+
 /**
  * Whether an item clusters into an activity block. A `switch` (not a stringly-
  * typed set) so adding an {@link ActivityItem} kind is a compile-time prompt to
- * decide its grouping — and it narrows `item` to `ActivityItem` with no cast.
+ * decide its grouping, and it narrows `item` to a work item with no cast.
+ * Assistant prose stays outside activity clusters.
  */
-function isActivityItem(item: TimelineItem): item is ActivityItem {
+function isActivityItem(item: TimelineItem): item is WorkActivityItem {
   switch (item.kind) {
     case "reasoning":
     case "tool-call":
@@ -1322,6 +2043,7 @@ function isActivityItem(item: TimelineItem): item is ActivityItem {
     case "sandbox":
     case "startup-phase":
     case "memory":
+    case "knowledge":
     case "fleet-decision":
       return true;
     default:
@@ -1329,9 +2051,22 @@ function isActivityItem(item: TimelineItem): item is ActivityItem {
   }
 }
 
-export function groupTimeline(items: TimelineItem[]): TimelineGroup[] {
+export type GroupTimelineOptions = {
+  /** Readable assistant prose with an independent work summary for each turn. */
+  readableTurns?: boolean;
+  /** @deprecated Use readableTurns. Cross-turn exchange folding has been removed. */
+  foldExchanges?: boolean;
+};
+
+export function groupTimeline(
+  items: TimelineItem[],
+  options: GroupTimelineOptions = {},
+): TimelineGroup[] {
+  if (options.readableTurns || options.foldExchanges) return groupReadableTurns(items);
   const groups: TimelineGroup[] = [];
   for (const item of items) {
+    // A recovered capacity wait is over; it leaves no warning behind.
+    if (item.kind === "notice" && item.capacityWait && item.resolvedAt) continue;
     if (isActivityItem(item)) {
       const open = groups[groups.length - 1];
       if (open?.kind === "activity" && open.outcome === undefined) {
@@ -1355,6 +2090,641 @@ export function groupTimeline(items: TimelineItem[]): TimelineGroup[] {
   return groups;
 }
 
+/** Live prose stays primary; settled progress joins its own turn's work history. */
+function groupReadableTurns(items: TimelineItem[]): TimelineGroup[] {
+  type Work = Extract<TimelineGroup, { kind: "activity" }>;
+  let groups: TimelineGroup[] = [];
+  const turns = new Map<string, Work>();
+  // Turn identity and settlement exist even when a final-only turn has no
+  // disclosure. A late receipt must not become a new turn or revive its clock.
+  const seenTurns = new Set<string>();
+  const settlements = new Map<
+    string,
+    { endedAt: string; outcome?: Work["outcome"]; failureText?: string }
+  >();
+  const compactionTurns = new Map<ContextCompactionItem, string>();
+  const messages = new Map<string, AgentMessageItem[]>();
+  // Capacity waits per turn: their spans are not work, and a live one is
+  // carried by the turn's work row instead of a separate warning.
+  const capacityPauses = new Map<string, Array<{ startedAt: string; endedAt?: string }>>();
+  const liveCapacityWaits = new Map<string, NoticeItem>();
+  const inputs = new Map<string, Extract<TimelineItem, { kind: "machine-input-batch" }>>();
+  const itemOrder = new Map(items.map((item, index) => [item.id, index]));
+  // Turns that answer a person's message: the first turn after it, and a live
+  // turn it steered. Their replies are never folded as mere progress.
+  const answersPerson = new Set<string>();
+  let personAwaitingTurn = false;
+  // A live turn a person's message may have steered. If it keeps working after
+  // the message, the steer was absorbed and no later turn inherits it; if it is
+  // superseded instead, the next turn answers the person.
+  let steeredTurn: string | undefined;
+  let legacyTurn = "start";
+  let currentTurn = legacyTurn;
+  for (const item of items) {
+    if (item.kind === "user-message") {
+      legacyTurn = item.id;
+      personAwaitingTurn = true;
+      steeredTurn = undefined;
+      if (seenTurns.has(currentTurn) && !settlements.has(currentTurn)) {
+        answersPerson.add(currentTurn);
+        steeredTurn = currentTurn;
+      }
+    }
+    // A capacity wait belongs to the turn it blocks, even before that turn's
+    // first step.
+    const itemTurnId =
+      item.kind === "notice" && item.capacityWait
+        ? item.capacityWait.turnId
+        : "turnId" in item
+          ? item.turnId
+          : null;
+    const key = itemTurnId || legacyTurn;
+    if (
+      steeredTurn !== undefined &&
+      key === steeredTurn &&
+      (isActivityItem(item) || (item.kind === "agent-message" && item.text.trim()))
+    ) {
+      personAwaitingTurn = false;
+      steeredTurn = undefined;
+    }
+    // Legacy work still establishes a boundary using its prompt key.
+    // A human message alone does not: it may be steering the existing turn.
+    if (itemTurnId || isActivityItem(item) || (item.kind === "agent-message" && item.text.trim())) {
+      if (key !== currentTurn && !seenTurns.has(key)) {
+        const previous = turns.get(currentTurn);
+        if (!settlements.has(currentTurn)) {
+          settlements.set(currentTurn, { endedAt: item.occurredAt });
+        }
+        if (previous?.work && !previous.work.endedAt) previous.work.endedAt = item.occurredAt;
+        currentTurn = key;
+        if (personAwaitingTurn) answersPerson.add(key);
+        personAwaitingTurn = false;
+        steeredTurn = undefined;
+      }
+      seenTurns.add(key);
+    }
+    const workForTurn = () => {
+      let group = turns.get(key);
+      const firstMessage = messages.get(key)?.[0];
+      const messageStart = firstMessage?.startedAt ?? firstMessage?.occurredAt;
+      const activityStart =
+        item.kind === "startup-phase"
+          ? (item.loadingStartedAt ?? item.occurredAt)
+          : item.occurredAt;
+      const startedAt =
+        messageStart && Date.parse(messageStart) < Date.parse(activityStart)
+          ? messageStart
+          : activityStart;
+      if (!group) {
+        const settlement = settlements.get(key);
+        group = {
+          kind: "activity",
+          id: `work-${key}`,
+          items: [],
+          work: { startedAt, details: [] },
+        };
+        if (settlement) {
+          group.work!.endedAt = settlement.endedAt;
+          if (settlement.outcome) group.outcome = settlement.outcome;
+          if (settlement.failureText) group.failureText = settlement.failureText;
+        }
+        turns.set(key, group);
+        const firstMessageIndex =
+          settlement && firstMessage
+            ? groups.findIndex((entry) => entry.kind === "item" && entry.item === firstMessage)
+            : -1;
+        if (firstMessageIndex >= 0) groups.splice(firstMessageIndex, 0, group);
+        else groups.push(group);
+      } else if (Date.parse(startedAt) < Date.parse(group.work!.startedAt)) {
+        // Completion-only startup receipts can reveal an earlier phase start
+        // after another activity has already established the work row.
+        group.work!.startedAt = startedAt;
+      }
+      return group;
+    };
+    if (isActivityItem(item)) {
+      const group = workForTurn();
+      group.items.push(item);
+      const previous = group.work!.details.at(-1);
+      const preparing = (entry: ActivityItem) =>
+        entry.kind === "startup-phase" || (entry.kind === "reasoning" && !entry.text.trim());
+      if (
+        preparing(item) &&
+        previous?.kind === "activity" &&
+        previous.items.every(preparing) &&
+        previous.items.at(-1) === items[(itemOrder.get(item.id) ?? 0) - 1]
+      )
+        previous.items.push(item);
+      else
+        group.work!.details.push({ kind: "activity", id: `work-item-${item.id}`, items: [item] });
+      delete group.work!.waiting;
+    } else if (item.kind === "notice" && item.capacityWait) {
+      const pauses = capacityPauses.get(key) ?? [];
+      pauses.push({
+        startedAt: item.occurredAt,
+        ...(item.resolvedAt ? { endedAt: item.resolvedAt } : {}),
+      });
+      capacityPauses.set(key, pauses);
+      if (!item.resolvedAt) {
+        if (settlements.has(key)) groups.push({ kind: "item", item });
+        else {
+          workForTurn();
+          liveCapacityWaits.set(key, item);
+        }
+      }
+    } else if (item.kind === "turn-end") {
+      if (!item.resumedAt) {
+        settlements.set(key, {
+          endedAt: item.occurredAt,
+          outcome: item.outcome,
+          ...(item.failureText ? { failureText: item.failureText } : {}),
+        });
+      }
+      const group = turns.get(key);
+      if (group?.work) {
+        if (item.resumedAt) {
+          group.work.details.push({
+            kind: "item",
+            item: {
+              kind: "notice",
+              id: item.id,
+              tone: "failed",
+              text: item.failureText ?? "The turn failed before retrying.",
+              occurredAt: item.occurredAt,
+            },
+          });
+          continue;
+        }
+        group.outcome = item.outcome;
+        if (item.failureText) group.failureText = item.failureText;
+        group.work.endedAt = item.occurredAt;
+      }
+    } else if (item.kind === "context-compaction" && item.phase === "compacted") {
+      // A maintenance checkpoint alone is not conversational work. Resolve its
+      // attachment after real activity has established this turn's work row.
+      compactionTurns.set(item, key);
+      groups.push({ kind: "item", item });
+    } else if (
+      item.kind === "machine-input-batch" &&
+      item.members.every((member) => ROUTINE_MACHINE_INPUT_KINDS.has(member.kind))
+    ) {
+      const previous = inputs.get(key);
+      if (previous) {
+        previous.members.push(
+          ...item.members.filter((member) => !previous.members.some((old) => old.id === member.id)),
+        );
+        previous.sourceEvents = [...(previous.sourceEvents ?? []), ...(item.sourceEvents ?? [])];
+      } else {
+        const batch = { ...item, compact: true, members: [...item.members] };
+        inputs.set(key, batch);
+        groups.push({ kind: "item", item: batch });
+      }
+    } else if (
+      item.kind === "worker-completion" ||
+      (item.kind === "goal" && item.action === "continuation")
+    ) {
+      const group = turns.get(currentTurn);
+      if (group?.work) group.work.details.push({ kind: "item", item });
+      else groups.push({ kind: "item", item });
+    } else {
+      const current = turns.get(currentTurn)?.work;
+      // A live approval wait is carried by the turn header ("Waiting for you")
+      // and decided in the host's approval surface; a second in-timeline banner
+      // only repeats it. Once resolved it returns as the quiet recorded marker.
+      const liveApprovalWait =
+        item.kind === "notice" &&
+        item.tone === "waiting" &&
+        !item.recordedOutcome &&
+        !item.resolvedAt &&
+        item.text.startsWith("Approval needed") &&
+        current !== undefined &&
+        !current.endedAt;
+      // Likewise the live "waiting on you" divider: the open turn's header
+      // already reads "Waiting for you · <elapsed>". It returns, resolved, as
+      // the "work resumed" divider once the session runs again.
+      const liveStatusWait =
+        item.kind === "session-status" &&
+        item.status === "requires_action" &&
+        !item.blocked &&
+        !item.resolvedAt &&
+        current !== undefined &&
+        !current.endedAt;
+      if (!liveApprovalWait && !liveStatusWait) groups.push({ kind: "item", item });
+      if (current && !current.endedAt) {
+        if (
+          item.kind === "notice" &&
+          item.tone === "waiting" &&
+          !item.recordedOutcome &&
+          !item.resolvedAt
+        ) {
+          current.waiting = {
+            label: item.text.startsWith("Approval needed") ? "Waiting for you" : "Waiting",
+            since: item.occurredAt,
+          };
+        } else if (
+          item.kind === "session-status" &&
+          item.status === "requires_action" &&
+          !item.blocked &&
+          !item.resolvedAt
+        ) {
+          current.waiting = { label: "Waiting for you", since: item.occurredAt };
+        } else if (
+          item.kind === "session-status" &&
+          ["paused", "cancelled", "failed"].includes(item.status) &&
+          !item.resolvedAt
+        ) {
+          current.endedAt = item.occurredAt;
+          delete current.waiting;
+        }
+      }
+      if (item.kind === "agent-message" && item.text.trim()) {
+        const prose = messages.get(key) ?? [];
+        prose.push(item);
+        messages.set(key, prose);
+        // A text-only turn still has one overall activity surface. An explicit
+        // final-only response does not manufacture an empty work disclosure.
+        if (
+          (item.phase !== "final_answer" || prose.length > 1) &&
+          (turns.has(key) || !settlements.has(key))
+        )
+          workForTurn();
+      }
+    }
+  }
+  for (const [key, group] of turns) {
+    const work = group.work!;
+    const live = liveCapacityWaits.get(key);
+    // Re-assert after the loop: a late receipt for the blocked turn must not
+    // turn "Limit reached" back into "Working" while the wait is still open.
+    if (live?.capacityWait && !work.endedAt) {
+      work.waiting = {
+        label: live.capacityWait.label,
+        since: live.occurredAt,
+        detail: live.capacityWait.detail,
+        // Its span is not work and may last until a quota resets: no clock.
+        untimed: true,
+      };
+    }
+    const pausedMs = (capacityPauses.get(key) ?? []).reduce((total, pause) => {
+      if (!pause.endedAt) return total;
+      const start = Math.max(Date.parse(work.startedAt), Date.parse(pause.startedAt));
+      const end = Math.min(
+        work.endedAt ? Date.parse(work.endedAt) : Number.POSITIVE_INFINITY,
+        Date.parse(pause.endedAt),
+      );
+      return Number.isFinite(start) && Number.isFinite(end) && end > start
+        ? total + end - start
+        : total;
+    }, 0);
+    if (pausedMs > 0) work.pausedMs = pausedMs;
+  }
+  groups = groups.filter((entry) => {
+    if (entry.kind !== "item" || entry.item.kind !== "context-compaction") return true;
+    const key = compactionTurns.get(entry.item);
+    const work = key === undefined ? undefined : turns.get(key)?.work;
+    if (!work) return true;
+    work.details.push(entry);
+    return false;
+  });
+  // A declared answer starts the response clock immediately. Without a phase,
+  // only settlement identifies the last response; text length never does.
+  const beforeRows = new Map<TimelineGroup, Work>();
+  const afterRows = new Map<TimelineGroup, Work>();
+  const movedRows = new Set<Work>();
+  const foldedProse = new Set<AgentMessageItem>();
+  const positions = new Map<TimelineGroup | TimelineItem, number>();
+  const nextBoundary = new Map<Work, number>();
+  let boundary = groups.length;
+  for (let index = groups.length - 1; index >= 0; index -= 1) {
+    const entry = groups[index]!;
+    positions.set(entry.kind === "item" ? entry.item : entry, index);
+    if (entry.kind === "activity" && entry.work) {
+      nextBoundary.set(entry, boundary);
+      boundary = index;
+    } else if (
+      entry.kind === "item" &&
+      (entry.item.kind === "user-message" || entry.item.kind === "machine-input-batch")
+    ) {
+      boundary = index;
+    }
+  }
+  for (const [key, group] of turns) {
+    const prose = messages.get(key) ?? [];
+    const settledAt = group.work!.endedAt;
+    const responseCandidates = settledAt
+      ? prose.filter(
+          (message) => Date.parse(message.startedAt ?? message.occurredAt) <= Date.parse(settledAt),
+        )
+      : prose;
+    const response =
+      responseCandidates.filter((message) => message.phase === "final_answer").at(-1) ??
+      (settledAt
+        ? (responseCandidates.at(-1) ??
+          prose.filter((message) => message.phase === "final_answer").at(-1))
+        : undefined);
+    const responses = new Set<AgentMessageItem>(response ? [response] : []);
+    // A turn that answers a person but ends with only commentary (typically by
+    // yielding to a wait) has no single authoritative reply. Its first message
+    // is the immediate answer and its last is the latest word; only the
+    // progress narration between them folds.
+    const firstCandidate = responseCandidates[0];
+    if (
+      settledAt &&
+      firstCandidate &&
+      answersPerson.has(key) &&
+      responseCandidates.every((message) => message.phase === "commentary")
+    ) {
+      responses.add(firstCandidate);
+    }
+    if (settledAt) {
+      for (const message of responseCandidates) {
+        // Markdown image syntax also carries retained video/audio previews.
+        // Keep potential primary media visible rather than guessing whether a
+        // partial/reference-style embed can safely disappear into history.
+        if (responses.has(message) || message.text.includes("![")) continue;
+        foldedProse.add(message);
+        group.work!.details.push({ kind: "item", item: message });
+      }
+    } else {
+      // Live progress stays primary above the work row, and is also listed in
+      // the work history so an expanded disclosure reads like the settled one.
+      // The timeline folds the outside copies only while that disclosure is open.
+      for (const message of prose) {
+        if (message.phase === "final_answer" || message.text.includes("![")) continue;
+        group.work!.details.push({ kind: "item", item: message });
+        (group.work!.liveNoteIds ??= []).push(message.id);
+      }
+    }
+    // Preserve event chronology, not completion timestamps or activity kinds.
+    group.work!.details.sort((a, b) => {
+      const first = (entry: TimelineGroup) =>
+        entry.kind === "item"
+          ? entry.item.id
+          : entry.kind === "activity"
+            ? entry.items[0]?.id
+            : undefined;
+      return (itemOrder.get(first(a) ?? "") ?? 0) - (itemOrder.get(first(b) ?? "") ?? 0);
+    });
+    if (response) {
+      const responseAt = response.startedAt ?? response.occurredAt;
+      // A delayed completion-only receipt cannot extend a settled work clock.
+      group.work!.responseStartedAt =
+        settledAt && Date.parse(responseAt) > Date.parse(settledAt) ? settledAt : responseAt;
+      // A late completion may belong to an older turn. Keep its work at its
+      // original boundary rather than moving it across a newer turn's input.
+      // The work row leads the first visible reply of the turn.
+      const anchor = Math.min(
+        ...[...responses].map((message) => positions.get(message) ?? groups.length),
+      );
+      if (settledAt && anchor < (nextBoundary.get(group) ?? groups.length)) {
+        beforeRows.set(groups[anchor]!, group);
+        movedRows.add(group);
+      }
+    }
+    if (!settledAt) {
+      // Keep the same row at the tail of this turn, after every live progress
+      // message and attention surface, without crossing a newer input/turn.
+      // A visible steer is not a turn boundary when later prose still belongs
+      // to this turn. New input without that evidence remains a hard boundary.
+      const lastProseIndex = Math.max(...prose.map((message) => positions.get(message) ?? -1));
+      let tailIndex = groups.length - 1;
+      for (let index = (positions.get(group) ?? 0) + 1; index <= tailIndex; index += 1) {
+        const entry = groups[index]!;
+        if (
+          (entry.kind === "activity" && entry.work) ||
+          (entry.kind === "item" &&
+            (("turnId" in entry.item && entry.item.turnId && entry.item.turnId !== key) ||
+              (index > lastProseIndex &&
+                (entry.item.kind === "user-message" || entry.item.kind === "machine-input-batch"))))
+        ) {
+          tailIndex = index - 1;
+          break;
+        }
+      }
+      const tail = groups[tailIndex];
+      if (tail && tail !== group) {
+        afterRows.set(tail, group);
+        movedRows.add(group);
+      }
+    }
+  }
+  // The work of every turn that answers a person stays visible even when it
+  // said nothing; quiet-cycle folding must never take it.
+  const personWork = new Set<TimelineGroup>(
+    [...answersPerson].flatMap((key) => {
+      const work = turns.get(key);
+      return work ? [work] : [];
+    }),
+  );
+  return compactQuietCycles(
+    groups.flatMap((group) => {
+      if (group.kind === "activity" && movedRows.has(group)) return [];
+      const hidden =
+        group.kind === "item" && group.item.kind === "agent-message" && foldedProse.has(group.item);
+      const before = beforeRows.get(group);
+      const after = afterRows.get(group);
+      return [...(before ? [before] : []), ...(hidden ? [] : [group]), ...(after ? [after] : [])];
+    }),
+    personWork,
+  );
+}
+
+type WorkGroup = Extract<TimelineGroup, { kind: "activity" }> & {
+  work: NonNullable<Extract<TimelineGroup, { kind: "activity" }>["work"]>;
+};
+
+/**
+ * Settled, successful work whose turn left no visible reply, image or blocker.
+ * A failure it recovered from, a failed startup phase or a context compaction
+ * is something to see, so that work is not quiet either.
+ */
+function isQuietWork(group: TimelineGroup): group is WorkGroup {
+  if (group.kind !== "activity" || !group.work?.endedAt || group.work.waiting) return false;
+  if (group.work.cycles || (group.outcome && group.outcome !== "complete")) return false;
+  if (
+    group.items.some(
+      (item) =>
+        item.kind === "startup-phase" && (item.status === "failed" || item.status === "cancelled"),
+    )
+  ) {
+    return false;
+  }
+  const quiet = (entry: TimelineGroup): boolean =>
+    entry.kind === "item"
+      ? entry.item.kind !== "auth-needed" &&
+        entry.item.kind !== "context-compaction" &&
+        entry.item.kind !== "human-input" &&
+        !(entry.item.kind === "notice" && entry.item.tone !== "waiting") &&
+        !(entry.item.kind === "agent-message" && entry.item.text.includes("!["))
+      : entry.kind === "activity"
+        ? isQuietDetail(entry, quiet)
+        : false;
+  return !publishesOutput(group) && group.work.details.every(quiet);
+}
+
+function isQuietDetail(
+  group: Extract<TimelineGroup, { kind: "activity" }>,
+  quiet: (entry: TimelineGroup) => boolean,
+): boolean {
+  return (
+    (!group.outcome || group.outcome === "complete") && (group.work?.details ?? []).every(quiet)
+  );
+}
+
+/**
+ * Work that generated an image or published a file produced output worth
+ * seeing. Checked by tool name only, so the projection stays free of the
+ * renderer's image presentation rules.
+ */
+function publishesOutput(group: TimelineGroup): boolean {
+  if (group.kind !== "activity") return false;
+  return (
+    group.items.some((item) => {
+      if (item.kind !== "tool-call") return false;
+      const name = mcpToolLeaf(item.name);
+      return (
+        name === "generate_image" ||
+        name === "image_generation_call" ||
+        name === "sandbox_file_publish"
+      );
+    }) || (group.work?.details ?? []).some(publishesOutput)
+  );
+}
+
+/**
+ * Whether the work at `index` follows a person's message or answer with only
+ * routine input in between. Complements the turn bookkeeping for legacy rows.
+ */
+function answersPersonAt(groups: TimelineGroup[], index: number): boolean {
+  for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+    const group = groups[cursor]!;
+    if (
+      group.kind === "item" &&
+      (group.item.kind === "user-message" || group.item.kind === "human-input")
+    ) {
+      return true;
+    }
+    if (!isRoutineInput(group)) return false;
+  }
+  return false;
+}
+
+/**
+ * A routine machine input (agent update, child result, wait timeout, ...). An
+ * agent that failed, paused or needs action is news, not routine.
+ */
+function isRoutineInput(group: TimelineGroup): boolean {
+  return (
+    group.kind === "item" &&
+    group.item.kind === "machine-input-batch" &&
+    !!group.item.compact &&
+    group.item.members.every(
+      (member) =>
+        member.kind !== "child_paused" &&
+        member.classification !== "failure" &&
+        // A parent's direction is always recorded as action_required for the
+        // agent; it is routine orchestration, not something a person must do.
+        (member.classification !== "action_required" || member.kind === "agent_steer_instruction"),
+    )
+  );
+}
+
+/** A recorded wait that later input already ended. */
+function isFinishedWait(group: TimelineGroup): group is Extract<TimelineGroup, { kind: "item" }> & {
+  item: NoticeItem;
+} {
+  return (
+    group.kind === "item" &&
+    group.item.kind === "notice" &&
+    group.item.tone === "waiting" &&
+    !!group.item.recordedOutcome &&
+    !!group.item.waitEndedAt
+  );
+}
+
+/**
+ * Long orchestration runs repeat "agent update / worked / waited" many times
+ * without saying anything. Fold two or more such consecutive quiet cycles into
+ * one work row: "7 updates over 6h 12m", with the latest wait reason under it.
+ * Expanding it shows the original rows unchanged. Visible replies, people's
+ * messages, failures, approvals, live work and the current wait are never folded
+ * and end a run.
+ */
+function compactQuietCycles(
+  groups: TimelineGroup[],
+  personWork: ReadonlySet<TimelineGroup>,
+): TimelineGroup[] {
+  const result: TimelineGroup[] = [];
+  let index = 0;
+  while (index < groups.length) {
+    // A run starts at routine input, never at a leading wait (it belongs to
+    // the reply before it) or at bare work (it belongs to the visible row
+    // before it, such as an agent's failure). Later cycles may lack input,
+    // for example after a wait timeout.
+    let end = index;
+    let lastCycleEnd = index;
+    let cycles = 0;
+    while (end < groups.length) {
+      const input = isRoutineInput(groups[end]!) ? end : -1;
+      if (input < 0 && cycles === 0) break;
+      const workIndex = input >= 0 ? end + 1 : end;
+      const work = groups[workIndex];
+      if (!work || !isQuietWork(work)) break;
+      // Work that follows a person's message is that message's turn, even
+      // when it said nothing; it stays visible.
+      if (personWork.has(work) || answersPersonAt(groups, workIndex)) break;
+      const next = groups[workIndex + 1];
+      // Work directly followed by its reply is not quiet.
+      if (next?.kind === "item" && next.item.kind === "agent-message") break;
+      if (!next || !isFinishedWait(next)) break;
+      cycles += 1;
+      end = workIndex + 2;
+      lastCycleEnd = end;
+    }
+    if (cycles < 2) {
+      result.push(groups[index]!);
+      index += 1;
+      continue;
+    }
+    const run = groups.slice(index, lastCycleEnd);
+    const works = run.filter((group): group is WorkGroup => isQuietWork(group));
+    const waits = run.filter(isFinishedWait);
+    const first = works[0]!;
+    const lastWait = waits.at(-1)!;
+    result.push({
+      kind: "activity",
+      id: `cycles-${first.id}`,
+      items: works.flatMap((group) => group.items),
+      outcome: "complete",
+      work: {
+        startedAt: first.work.startedAt,
+        endedAt: lastWait.item.waitEndedAt!,
+        details: run,
+        cycles: {
+          count: cycles,
+          ...(lastWait.item.text.trim() ? { summary: lastWait.item.text.trim() } : {}),
+        },
+      },
+    });
+    index = lastCycleEnd;
+  }
+  return result;
+}
+
+/** Machine inputs that continue the current exchange rather than start one. */
+const ROUTINE_MACHINE_INPUT_KINDS: ReadonlySet<MachineInputMember["kind"]> = new Set([
+  "goal_continuation",
+  "background_command_result",
+  "session_wait_timeout",
+  "agent_message",
+  "agent_steer_instruction",
+  "child_terminal_result",
+  "child_requires_action_resolved",
+  "child_paused",
+  "child_waiting_capacity",
+  "child_progress",
+]);
+
 /* --- helpers ---------------------------------------------------------------- */
 
 type TurnAnchorPrescan = {
@@ -1366,6 +2736,22 @@ type TurnAnchorPrescan = {
   startedTurnIds: Set<string>;
 };
 
+/** Navigation uses the same queue/start/withdrawal rules as transcript ordering. */
+export function timelineQuestionPlacement(question: SessionEvent, evidence: SessionEvent[]) {
+  const anchors = prescanTurnAnchors([question, ...evidence]);
+  const direct = anchors.directChatSequenceByTrigger.get(question.id);
+  if (direct !== undefined) return { kind: "visible" as const, sequence: direct };
+  if (anchors.cancelledBeforeStartTriggers.has(question.id)) return { kind: "withdrawn" as const };
+  const start = anchors.startSeqByTrigger.get(question.id);
+  if (start !== undefined) return { kind: "visible" as const, sequence: start };
+  if (
+    anchors.queuedTurnByTrigger.has(question.id) ||
+    anchors.explicitQueuedTriggers.has(question.id)
+  )
+    return { kind: "pending" as const };
+  return { kind: "visible" as const, sequence: question.sequence };
+}
+
 function prescanTurnAnchors(events: SessionEvent[]): TurnAnchorPrescan {
   const ordered = [...events].sort((a, b) => a.sequence - b.sequence);
   const queuedTurnByTrigger = new Map<string, string>();
@@ -1554,7 +2940,12 @@ function pushInsertion(
 }
 
 function isAgentActivityEvent(type: string): boolean {
-  return type.startsWith("agent.") || type.startsWith("sandbox.");
+  return (
+    type.startsWith("agent.") ||
+    type.startsWith("sandbox.") ||
+    type === "subscription.account.selected" ||
+    type === "subscription.account.switched"
+  );
 }
 
 /**
@@ -1564,11 +2955,15 @@ function isAgentActivityEvent(type: string): boolean {
  * steering, or deleting a waiting row must never make its prompt appear in the
  * transcript as though inference had begun.
  */
-function isTurnExecutionEvidence(type: string): boolean {
+export function isTurnExecutionEvidence(type: string): boolean {
   return (
     isAgentActivityEvent(type) ||
     type === "turn.completed" ||
     type === "turn.failed" ||
+    // An admission refusal can settle a queued turn before it ever starts:
+    // its prompt still belongs above the "usage limit reached" row.
+    type === "usage.exhausted" ||
+    type === "turn.superseded" ||
     type === "turn.recovery.requested" ||
     type === "turn.capacity_waiting" ||
     type === "session.requiresAction" ||
@@ -1597,6 +2992,35 @@ function turnEndItem(
   };
 }
 
+/** Plain text for a usage-limit stop whose marker carried no readable amounts. */
+const SESSION_USAGE_LIMIT_STOP_TEXT =
+  "This task's usage limit is reached. A person can raise or remove the limit to continue.";
+
+/**
+ * The stop row for a `segmentLimit: "session_usage_limit"` completion. Only the
+ * typed amounts are kept (never upstream prose), and a malformed marker still
+ * reads as the same neutral stop instead of a credit or failure notice.
+ */
+function sessionUsageLimitNotice(
+  event: SessionEvent,
+  payload: Record<string, unknown>,
+): NoticeItem {
+  const refusal = parseSessionUsageLimitReachedRefusal(payload);
+  return {
+    kind: "notice",
+    id: `${event.id}-session-usage-limit`,
+    // Neutral: not a failure, and not an open wait the turn header should claim.
+    tone: "cancelled",
+    text: refusal ? sessionUsageLimitReachedMessage(refusal) : SESSION_USAGE_LIMIT_STOP_TEXT,
+    sessionUsageLimit: {
+      rootSessionId: refusal?.rootSessionId ?? null,
+      limitMicros: refusal?.limitMicros ?? null,
+      usedMicros: refusal?.usedMicros ?? null,
+    },
+    occurredAt: event.occurredAt,
+  };
+}
+
 function hasTurnActivity(items: TimelineItem[], turnId: string | null): boolean {
   if (turnId) {
     return items.some((item) => isActivityItem(item) && item.turnId === turnId);
@@ -1678,14 +3102,58 @@ function foldSettledTurn(groups: TimelineGroup[], turnEnd: TurnEndItem): void {
   if (collected.length === 0) {
     return;
   }
-
-  const finalMessage = extractFinalAgentMessage(collected, turnEnd);
+  const collectedLength = collected.length;
+
+  // Resolve only inside this turn's collected suffix. A user/machine-input
+  // boundary or an interleaved foreign turn must never donate its answer.
+  const waitMessages = turnEnd.preserveWaitResponse
+    ? collected.filter(
+        (group): group is Extract<TimelineGroup, { kind: "item" }> =>
+          group.kind === "item" &&
+          group.item.kind === "agent-message" &&
+          !group.item.streaming &&
+          group.item.text.trim().length > 0 &&
+          belongsToTurn(group.item, turnEnd.turnId),
+      )
+    : [];
+  // A completed answer outranks later commentary. Otherwise use the latest
+  // visible existing prose, ignoring whitespace and opaque-only stream tails.
+  const waitResponse =
+    waitMessages
+      .slice()
+      .reverse()
+      .find(
+        (group) =>
+          group.item.kind === "agent-message" &&
+          group.item.phase !== "commentary" &&
+          group.item.annotationSource?.eventType === "agent.message.completed",
+      ) ?? waitMessages.at(-1);
+  const finalMessage = waitResponse ?? extractFinalAgentMessage(collected, turnEnd);
   const fallbackMessage =
     finalMessage || hasOrdinaryFinalAgentMessage(collected, turnEnd)
       ? null
       : extractLatestCompletedCommentary(collected, turnEnd);
   const visibleMessage = finalMessage ?? fallbackMessage;
-  const body = visibleMessage ? collected.filter((group) => group !== visibleMessage) : collected;
+  const visibleMessages = visibleMessage ? [visibleMessage] : [];
+  // A turn that answers a person but declares no final answer (typically one
+  // that yields to a wait) keeps its first message visible beside the latest:
+  // that is the immediate answer, not progress narration.
+  if (
+    visibleMessage &&
+    !hasOrdinaryFinalAgentMessage(collected, turnEnd) &&
+    turnAnswersPerson(groups, startIndex)
+  ) {
+    const first = collected.find(
+      (group): group is Extract<TimelineGroup, { kind: "item" }> =>
+        group.kind === "item" &&
+        group.item.kind === "agent-message" &&
+        !group.item.streaming &&
+        group.item.text.trim().length > 0 &&
+        belongsToTurn(group.item, turnEnd.turnId),
+    );
+    if (first && first !== visibleMessage) visibleMessages.unshift(first);
+  }
+  const body = collected.filter((group) => !visibleMessages.includes(group as never));
   if (body.length === 0) {
     return;
   }
@@ -1711,11 +3179,25 @@ function foldSettledTurn(groups: TimelineGroup[], turnEnd: TurnEndItem): void {
     turnGroup.failureText = turnEnd.failureText;
   }
 
-  groups.splice(
-    startIndex,
-    collected.length,
-    ...(visibleMessage ? [turnGroup, visibleMessage] : [turnGroup]),
-  );
+  groups.splice(startIndex, collectedLength, turnGroup, ...visibleMessages);
+}
+
+/** Whether the input boundary before a turn includes a person's message. */
+function turnAnswersPerson(groups: TimelineGroup[], startIndex: number): boolean {
+  for (let index = startIndex - 1; index >= 0; index -= 1) {
+    const group = groups[index];
+    if (group?.kind !== "item") return false;
+    if (group.item.kind === "user-message") return true;
+    if (
+      group.item.kind !== "machine-input-batch" &&
+      group.item.kind !== "session-status" &&
+      group.item.kind !== "context-compaction" &&
+      !(group.item.kind === "notice" && group.item.tone === "input")
+    ) {
+      return false;
+    }
+  }
+  return false;
 }
 
 function isTurnBoundary(group: TimelineGroup | undefined): boolean {
@@ -1725,8 +3207,7 @@ function isTurnBoundary(group: TimelineGroup | undefined): boolean {
       (group.item.kind === "user-message" ||
         group.item.kind === "human-input" ||
         group.item.kind === "context-compaction" ||
-        (group.item.kind === "machine-input-batch" &&
-          group.item.members.some((member) => member.kind === "media_generation_result")) ||
+        group.item.kind === "machine-input-batch" ||
         (group.item.kind === "notice" && group.item.tone === "input")))
   );
 }
@@ -1838,6 +3319,29 @@ function numberOrNull(value: unknown): number | null {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
+/**
+ * Read the closed provider-rejection record a `summarization_failed` skip
+ * carries. Only bounded identifiers are accepted; a provider message is never
+ * part of the payload and would be ignored here anyway.
+ */
+function compactionProviderRejection(
+  payload: Record<string, unknown>,
+): ContextCompactionItem["providerRejection"] {
+  const record = asRecord(payload.providerRejection);
+  if (typeof record.httpStatus !== "number" || !Number.isFinite(record.httpStatus)) {
+    return null;
+  }
+  const text = (value: unknown): string | null =>
+    typeof value === "string" && value.trim() ? value : null;
+  return {
+    httpStatus: record.httpStatus,
+    type: text(record.type),
+    code: text(record.code),
+    param: text(record.param),
+    requestId: text(record.requestId),
+  };
+}
+
 function compactionTrigger(payload: Record<string, unknown>): ContextCompactionItem["trigger"] {
   const trigger = payload.trigger;
   return trigger === "auto" ||
@@ -1893,6 +3397,8 @@ function machineInputMembers(value: unknown): MachineInputBatchItem["members"] {
   const kinds = new Set<MachineInputBatchItem["members"][number]["kind"]>([
     "scheduled_occurrence",
     "goal_continuation",
+    "background_command_result",
+    "session_wait_timeout",
     "agent_message",
     "agent_steer_instruction",
     "child_terminal_result",
@@ -1948,6 +3454,8 @@ const SESSION_STATUSES: readonly SessionStatus[] = [
   "running",
   "idle",
   "requires_action",
+  "recovering",
+  "waiting_capacity",
   "failed",
   "cancelled",
 ];
@@ -1973,6 +3481,15 @@ function resourceRefs(value: unknown): import("@opengeni/sdk").ResourceRef[] {
   });
 }
 
+/** The person behind a message, when its initiator is a signed-in subject. */
+function messageSender(value: unknown): import("./types").MessageSender | undefined {
+  const record = asRecord(value);
+  if (record.kind !== "subject" || typeof record.subjectId !== "string" || !record.subjectId)
+    return undefined;
+  const label = typeof record.label === "string" && record.label.trim() ? record.label : null;
+  return { subjectId: record.subjectId, label };
+}
+
 function timelineAnnotations(value: unknown): TimelineAnnotation[] {
   if (!Array.isArray(value)) return [];
   return value.filter((candidate): candidate is TimelineAnnotation => {
@@ -2091,6 +3608,10 @@ function findOpenCall(
     if (byId) {
       return byId as ToolCallItem | WorkerItem;
     }
+    // An explicit provider correlation id is authoritative. Falling back to
+    // an unrelated running call corrupts its status/output when compact pages
+    // or interleaved providers deliver an unmatched historical result.
+    return undefined;
   }
   return reversed.find(
     (item): item is ToolCallItem | WorkerItem => isCall(item) && item.status === "running",
@@ -2116,6 +3637,34 @@ function startupPhaseFromPayload(value: unknown): StartupPhase | null {
     : null;
 }
 
+function startupLifecycleWaitReason(
+  payload: Record<string, unknown>,
+): StartupPhaseItem["blockedReason"] {
+  // The first model request waited for context compaction: an expected step
+  // of preparation that reopens after compacting, never a failure.
+  if (
+    payload.expectedTransition === true &&
+    payload.failureStage === "context_compaction" &&
+    payload.failureCategory === "context_compaction" &&
+    payload.failureCode === "compaction_required"
+  ) {
+    return "compaction_required";
+  }
+  if (
+    payload.expectedTransition !== true ||
+    payload.failureStage !== "lifecycle_wait" ||
+    payload.failureCategory !== "drain_capture_wait"
+  ) {
+    return undefined;
+  }
+  const code = payload.failureCode;
+  return code === "capture_in_progress" ||
+    code === "rotation_in_progress" ||
+    code === "provider_recovery_in_progress"
+    ? code
+    : undefined;
+}
+
 const SANDBOX_STARTUP_PHASES: Record<string, StartupPhase> = {
   "sandbox.provision": "sandbox",
   "repository-clone": "repository",
@@ -2139,15 +3688,7 @@ function elapsedDurationMs(startedAt: string, completedAt: string): number | nul
 }
 
 function failureMessage(payload: Record<string, unknown>): string | null {
-  for (const key of ["error", "message"] as const) {
-    const value = payload[key];
-    if (typeof value === "string" && value.trim().length > 0) {
-      // Auth/quota provider errors are rewritten for the right audience
-      // (raw text remains in the event payload for debug surfaces).
-      return humanizeFailureReason(value);
-    }
-  }
-  return null;
+  return presentFailure(payload).reason;
 }
 
 function goalText(payload: Record<string, unknown>): string | null {
@@ -2164,11 +3705,108 @@ function goalText(payload: Record<string, unknown>): string | null {
   return null;
 }
 
+function rememberPendingWaitOutcome(
+  pending: Map<string | null, PendingWaitOutcome>,
+  event: SessionEvent,
+  payload: Record<string, unknown>,
+  eventTurnId: string | null,
+): void {
+  const reason = stringValue(payload.reason).trim();
+  if (!reason) return;
+  const turnId =
+    eventTurnId || stringValue(payload.waitTurnId) || stringValue(payload.turnId) || null;
+  pending.set(turnId, { id: event.id, reason, occurredAt: event.occurredAt });
+}
+
+/** Wait reasons that need a person or a policy change, not only time. */
+const ACTION_CAPACITY_WAIT_REASONS: ReadonlySet<string> = new Set([
+  "pinned_account_disabled",
+  "pinned_account_ineligible",
+  "model_not_allowed",
+  // Only sending the work again ends it (design 5.3 decision 4).
+  "accepted_authority_unavailable",
+]);
+
+/**
+ * Recorded wait codes, for any subscription provider, that a person must
+ * resolve: every account disabled for allocation, or the serving account
+ * needing reconnection or refusing the request. None of them is a limit.
+ */
+const ACTION_CAPACITY_WAIT_CODE = /_(?:allocator_disabled|relogin_required|account_forbidden)$/;
+
+/**
+ * A quota or capacity wait reads as "Usage limit reached" with one plain line
+ * of guidance. It never promises that the work continues by itself: the
+ * reader decides whether to wait for the quota to reset or to switch. Only a
+ * wait that a person must resolve (reconnect, re-enable, choose another
+ * account) keeps its recorded, actionable reason and is not labelled a limit.
+ */
+function capacityWaitPresentation(
+  type: string,
+  payload: Record<string, unknown>,
+  turnId: string | null,
+): { turnId: string | null; label: string; detail: string; text: string } {
+  if (
+    ACTION_CAPACITY_WAIT_REASONS.has(stringValue(payload.waitReason)) ||
+    ACTION_CAPACITY_WAIT_CODE.test(stringValue(payload.code))
+  ) {
+    // Claude/SuperGrok waits record the readable sentence as `error` and an
+    // internal note as `detail`; Codex waits keep their recorded order.
+    const [first, second] =
+      type === "turn.capacity_waiting"
+        ? [payload.error, payload.detail]
+        : [payload.detail, payload.error];
+    const detail = stringValue(first) || stringValue(second) || "Waiting for an account.";
+    return {
+      turnId,
+      label:
+        stringValue(payload.waitReason) === "pinned_account_disabled" ? "Needs you" : "Waiting",
+      detail,
+      text: detail,
+    };
+  }
+  return {
+    turnId,
+    label: CAPACITY_LIMIT_LABEL,
+    detail: CAPACITY_LIMIT_DETAIL,
+    text: `${CAPACITY_LIMIT_LABEL}. ${CAPACITY_LIMIT_DETAIL}`,
+  };
+}
+
+const CAPACITY_LIMIT_LABEL = "Usage limit reached";
+const CAPACITY_LIMIT_DETAIL =
+  "Try again after your quota resets, or switch to another model or provider.";
+
+/** Lifecycle evidence that a capacity wait is over. */
+function endsCapacityWait(event: SessionEvent, payload: Record<string, unknown>): boolean {
+  if (event.duplicateOfEventId || (event.turnAssociation && event.turnAssociation !== "current"))
+    return false;
+  switch (event.type) {
+    case "codex.capacity.resumed":
+    case "codex.capacity.superseded":
+    case "turn.completed":
+    case "turn.failed":
+    case "turn.cancelled":
+    case "turn.superseded":
+      return true;
+    case "session.status.changed":
+      return isSessionStatus(payload.status) && payload.status !== "waiting_capacity";
+    default:
+      return false;
+  }
+}
+
+function waitingOutcomeText(reason: string): string {
+  return /^waiting\b/i.test(reason) ? reason : `Waiting: ${reason}`;
+}
+
 /**
  * Agent-owned goal mutations already have an in-cluster tool row. Suppress the
- * breakaway landmark for those only. `goal.completed` has no actor field today
- * and is only emitted by the agent tool, so it is always suppressed. API /
- * system / create-session / continuation landmarks stay visible.
+ * breakaway landmark for those only. Empty wait turns retain the durable hold
+ * reason and surface it after the folded steps. `goal.completed` has no actor
+ * field today and is only emitted by the agent tool, so it is always
+ * suppressed. API / system / create-session / continuation landmarks stay
+ * visible.
  */
 function shouldSuppressAgentGoalLandmark(type: string, payload: Record<string, unknown>): boolean {
   if (type === "goal.completed") {
@@ -2231,6 +3869,7 @@ const AUTH_NEEDED_REASONS: ReadonlySet<string> = new Set([
   "personal_authority_unavailable",
   "unsupported_auth",
   "resource_scope_unavailable",
+  "designated_credential_unavailable",
 ]);
 
 function authNeededReason(value: unknown): AuthNeededItem["reason"] {
@@ -2250,7 +3889,7 @@ function capabilityAuthorizationRequest(
   if (
     typeof record.id !== "string" ||
     typeof record.name !== "string" ||
-    !["pack", "mcp", "api", "skill", "plugin"].includes(String(kind)) ||
+    !["mcp", "api", "skill", "plugin"].includes(String(kind)) ||
     !["built_in", "library", "configured", "public_registry", "registry", "manual"].includes(
       String(source),
     ) ||
@@ -2270,12 +3909,30 @@ function capabilityAuthorizationRequest(
   };
 }
 
+function customMcpSetupRequest(value: unknown): NonNullable<AuthNeededItem["setupRequest"]> | null {
+  return parseCustomMcpSetupRequest(value);
+}
+
 function stringList(value: unknown): string[] {
   return Array.isArray(value)
     ? value.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0)
     : [];
 }
 
+/**
+ * Some providers stream each reasoning summary part as its own delta
+ * ("**Checking the workspace**", then "**Inspecting guidance**"). Joined
+ * as-is the parts run together and their bold markers collide ("****"), so a
+ * new part that opens bold right after one that closed bold starts a new
+ * paragraph. Ordinary token deltas are joined unchanged. The worker's
+ * write-time merge and the read-side coalescer apply the same rule
+ * (`reasoningDeltaSeparator` in @opengeni/events), so stored, coalesced and
+ * live fragments render identically.
+ */
+function reasoningDeltaJoiner(previous: string, next: string): string {
+  return previous.endsWith("**") && next.startsWith("**") ? "\n\n" : "";
+}
+
 function reasoningText(payload: unknown): string {
   const record = asRecord(payload);
   if (typeof record.text === "string") {
@@ -2305,6 +3962,19 @@ function workerPrompt(args: unknown): string | null {
   return null;
 }
 
+const WORKER_TITLE_MAX_LENGTH = 120;
+
+/** The optional `session_create` title, as one bounded display line. */
+function workerTitle(args: unknown): string | null {
+  const record = asRecord(typeof args === "string" ? tryParseJson(args) : args);
+  if (typeof record.title !== "string") return null;
+  const title = record.title.replace(/\s+/g, " ").trim();
+  if (!title) return null;
+  return title.length > WORKER_TITLE_MAX_LENGTH
+    ? `${title.slice(0, WORKER_TITLE_MAX_LENGTH - 1).trimEnd()}…`
+    : title;
+}
+
 function boundedWorkerFailureMessage(value: string): string | null {
   const normalized = value.replace(/[\u0000-\u001f\u007f]+/g, " ").trim();
   if (!normalized) return null;