@mystilleef/pi-subagent 0.8.0 → 0.10.1

package/src/progress/progress-state.ts

@@ -6,7 +6,6 @@ import {
   normalizeAndTruncate,
   normalizeSummaryValue,
   normalizeTerminalSentence,
-  truncateText,
 } from "../output/normalize.js";
 import type {
   SingleResult,
@@ -14,8 +13,6 @@ import type {
   ToolActivity,
 } from "../shared/types.js";
 
-export const SENSITIVE_PATTERN = /secret|token|password/i;
-
 export type ThemeBg = "toolPendingBg" | "toolSuccessBg" | "toolErrorBg";
 
 export type ProgressStatus = "running" | "success" | "error" | "cancelled";
@@ -44,21 +41,22 @@ export const STATUS_BG: Record<ProgressStatus, ThemeBg> = {
 export interface SubagentProgressState {
   requestId: string;
   agent: string;
-  instanceName?: string;
+  instanceName?: string | undefined;
   taskPreview: string;
   status: ProgressStatus;
   startTime: number;
-  durationMs?: number;
-  activeToolActivity?: ToolActivity;
-  lastToolPreview?: string;
-  toolResultCompleted?: boolean;
+  durationMs?: number | undefined;
+  activeToolActivity?: ToolActivity | undefined;
+  lastToolPreview?: string | undefined;
+  toolResultCompleted?: boolean | undefined;
   toolCount: number;
-  inputTokens?: number;
-  outputTokens?: number;
-  contextTokens?: number;
-  contextWindowTokens?: number;
-  finalOutput?: string;
-  errorText?: string;
+  inputTokens?: number | undefined;
+  outputTokens?: number | undefined;
+  contextTokens?: number | undefined;
+  contextWindowTokens?: number | undefined;
+  modelDisplay?: string | undefined;
+  finalOutput?: string | undefined;
+  errorText?: string | undefined;
 }
 
 const store = new Map<string, SubagentProgressState>();
@@ -89,23 +87,34 @@ export function getAllProgressStates(): SubagentProgressState[] {
   return [...store.values()].sort((a, b) => b.startTime - a.startTime);
 }
 
+type ProgressTransientFields = Pick<
+  SubagentProgressState,
+  "activeToolActivity" | "lastToolPreview" | "toolResultCompleted"
+>;
+
+function stripTransientFields(
+  merged: SubagentProgressState,
+): Omit<SubagentProgressState, keyof ProgressTransientFields> {
+  const { activeToolActivity, lastToolPreview, toolResultCompleted, ...base } =
+    merged;
+  return base;
+}
+
 export function patchProgressState(
   requestId: string,
   patch: Partial<SubagentProgressState>,
 ): void {
   const state = store.get(requestId);
   if (!state) return;
+  const merged: SubagentProgressState = { ...state, ...patch };
+  if (merged.modelDisplay === undefined || merged.modelDisplay === "") {
+    delete merged.modelDisplay;
+  }
   if (state.status !== "running") {
-    store.set(requestId, {
-      ...state,
-      ...patch,
-      activeToolActivity: undefined,
-      lastToolPreview: undefined,
-      toolResultCompleted: undefined,
-    });
+    store.set(requestId, stripTransientFields(merged));
     return;
   }
-  store.set(requestId, { ...state, ...patch });
+  store.set(requestId, merged);
 }
 
 function storeTerminalProgressState(
@@ -115,7 +124,10 @@ function storeTerminalProgressState(
   const state = store.get(requestId);
   if (!state) return;
   const durationMs = state.durationMs ?? Date.now() - state.startTime;
-  store.set(requestId, { ...state, ...patch, durationMs });
+  store.set(requestId, {
+    ...stripTransientFields({ ...state, ...patch }),
+    durationMs,
+  });
 }
 
 export function finalizeProgressState(
@@ -125,9 +137,6 @@ export function finalizeProgressState(
   storeTerminalProgressState(requestId, {
     status: "success",
     finalOutput: makeProgressFinalOutput(finalOutput),
-    activeToolActivity: undefined,
-    lastToolPreview: undefined,
-    toolResultCompleted: undefined,
   });
 }
 
@@ -136,21 +145,13 @@ export function failProgressState(requestId: string, errorText: string): void {
   storeTerminalProgressState(requestId, {
     status: "error",
     errorText: sentence,
-    activeToolActivity: undefined,
-    lastToolPreview: undefined,
-    toolResultCompleted: undefined,
   });
 }
 
 export function cancelProgressState(requestId: string, reason?: string): void {
   storeTerminalProgressState(requestId, {
     status: "cancelled",
-    activeToolActivity: undefined,
-    lastToolPreview: undefined,
-    toolResultCompleted: undefined,
-    ...(reason !== undefined
-      ? { errorText: normalizeTerminalSentence(reason) }
-      : {}),
+    errorText: reason ? normalizeTerminalSentence(reason) : undefined,
   });
 }
 
@@ -235,11 +236,11 @@ function trackNewToolCall(
 
 function extractProgressFromExistingProgress(
   progress: {
-    activityText?: string;
-    activeToolActivity?: ToolActivity;
-    lastToolPreview?: string;
+    activityText?: string | undefined;
+    activeToolActivity?: ToolActivity | undefined;
+    lastToolPreview?: string | undefined;
     toolCalls: { id: string; preview: string }[];
-    toolResultCompleted?: boolean;
+    toolResultCompleted?: boolean | undefined;
   },
   seenToolCallIds: Set<string>,
   state: DetailsProgress,
@@ -253,22 +254,26 @@ function extractProgressFromExistingProgress(
   if (progress.activeToolActivity) {
     state.activeToolActivity = progress.activeToolActivity;
   }
-  if (
-    typeof progress.lastToolPreview === "string" &&
-    progress.lastToolPreview.trim()
-  ) {
-    state.progressLastToolPreview = normalizeAndTruncate(
-      progress.lastToolPreview,
-    );
+  const previewValue = progress.lastToolPreview;
+  const truncatedPreview =
+    typeof previewValue === "string" && previewValue.trim()
+      ? normalizeAndTruncate(previewValue)
+      : undefined;
+  if (truncatedPreview) {
+    state.progressLastToolPreview = truncatedPreview;
   }
   if (progress.toolResultCompleted) {
     state.toolResultCompleted = true;
   }
+  const hasToolCalls = progress.toolCalls.some(isDerivedToolCall);
   for (const toolCall of progress.toolCalls) {
     if (!isDerivedToolCall(toolCall)) continue;
     const preview = normalizeAndTruncate(toolCall.preview);
     trackNewToolCall(toolCall.id, preview, seenToolCallIds, state);
   }
+  if (truncatedPreview && !hasToolCalls) {
+    state.lastToolPreview = truncatedPreview;
+  }
 }
 
 function extractProgressFromMessages(
@@ -317,7 +322,7 @@ function isDerivedToolCall(part: unknown): part is {
   preview: string;
 } {
   if (!isObjectWith(part)) return false;
-  return typeof part.id === "string" && typeof part.preview === "string";
+  return typeof part["id"] === "string" && typeof part["preview"] === "string";
 }
 
 export function isToolCallPart(part: unknown): part is {
@@ -328,98 +333,8 @@ export function isToolCallPart(part: unknown): part is {
 } {
   if (!isObjectWith(part)) return false;
   return (
-    part.type === "toolCall" &&
-    typeof part.id === "string" &&
-    typeof part.name === "string"
+    part["type"] === "toolCall" &&
+    typeof part["id"] === "string" &&
+    typeof part["name"] === "string"
   );
 }
-
-/**
- * Format a millisecond duration for compact display.
- * Renders sub-minute durations as decimal seconds (`45.2s`),
- * longer durations as minutes and whole seconds (`2m 15s`).
- */
-export function formatElapsed(ms: number): string {
-  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
-  const mins = Math.floor(ms / 60000);
-  const secs = Math.floor((ms % 60000) / 1000);
-  return `${mins}m ${secs}s`;
-}
-
-export function formatContextPercent(state: SubagentProgressState): string {
-  const d = state.contextWindowTokens;
-  if (!d || d <= 0 || !Number.isFinite(d)) return "--%";
-  const n = state.contextTokens;
-  if (!n || n <= 0 || !Number.isFinite(n)) return "0%";
-  return `${Math.round((n / d) * 100)}%`;
-}
-
-/**
- * Format the one-line statistics header for a subagent progress display.
- * Includes tool count, context window usage, and elapsed time.
- * When the subagent is still running (`durationMs` unset), elapsed is
- * computed live from `startTime`.
- *
- * @returns Single line ending in `\n`, e.g. `"3 tools · 45% ctx · 12.3s\n"`
- */
-export function formatHeaderStats(state: SubagentProgressState): string {
-  const elapsedMs = state.durationMs ?? Date.now() - state.startTime;
-  const toolLabel = state.toolCount === 1 ? "tool" : "tools";
-  return `${state.toolCount} ${toolLabel} · ${formatContextPercent(state)} ctx · ${formatElapsed(elapsedMs)}\n`;
-}
-
-const REDACTED_PLACEHOLDER = "(running...)";
-const REDACTED_PLACEHOLDER_LENGTH = REDACTED_PLACEHOLDER.length;
-
-function redactOrTruncate(text: string, maxChars: number): string {
-  if (SENSITIVE_PATTERN.test(text))
-    return maxChars >= REDACTED_PLACEHOLDER_LENGTH ? REDACTED_PLACEHOLDER : "";
-  return truncateText(text, maxChars);
-}
-
-function walkActivityTree(activity: ToolActivity): string[] {
-  const parts: string[] = [];
-  let current: ToolActivity | undefined = activity;
-  while (current) {
-    if (current.inputSummary) {
-      const annotated = current.instanceName
-        ? `${current.inputSummary} [${current.instanceName}]`
-        : current.inputSummary;
-      parts.push(annotated);
-    }
-    current = current.child;
-  }
-  return parts;
-}
-
-/**
- * Renders a ToolActivity tree for storage. Each segment is
- * independently normalized and truncated to TOOL_PREVIEW_MAX_CHARS (120).
- */
-export function renderToolActivity(
-  activity: ToolActivity | undefined,
-): string | undefined {
-  if (!activity) return undefined;
-  const parts = walkActivityTree(activity);
-  if (parts.length === 0) return activity.toolName;
-  const result = parts.map((p) => normalizeAndTruncate(p)).join(" - ");
-  if (SENSITIVE_PATTERN.test(result)) return REDACTED_PLACEHOLDER;
-  return result;
-}
-
-/**
- * Renders a ToolActivity tree for display with a caller-provided truncation
- * budget. Segments are normalized without individual truncation so the
- * joined result shares one post-join display budget.
- */
-export function renderToolActivityForDisplay(
-  activity: ToolActivity | undefined,
-  maxChars: number,
-): string | undefined {
-  if (!activity) return undefined;
-  if (maxChars <= 0) return "";
-  const parts = walkActivityTree(activity);
-  if (parts.length === 0) return redactOrTruncate(activity.toolName, maxChars);
-  const joined = parts.map((p) => normalizeSummaryValue(p)).join(" - ");
-  return redactOrTruncate(joined, maxChars);
-}

package/src/progress/progress.ts

@@ -21,17 +21,22 @@ import { Box, Text } from "@earendil-works/pi-tui";
 import { formatSubagentTitle, type SubagentTheme } from "../output/ui.js";
 import {
   formatHeaderStats,
-  getProgressState,
-  type ProgressStatus,
   renderToolActivityForDisplay,
+} from "./progress-format.js";
+import {
+  getProgressState,
   STATUS_BG,
   STATUS_COLOR,
   STATUS_ICON,
   type SubagentProgressState,
-  type ThemeBg,
 } from "./progress-state.js";
 
 export { makeToolPreview } from "../output/normalize.js";
+export {
+  formatElapsed,
+  formatHeaderStats,
+  renderToolActivity,
+} from "./progress-format.js";
 export {
   cancelProgressState,
   clearProgressState,
@@ -39,20 +44,11 @@ export {
   extractProgressFromDetails,
   failProgressState,
   finalizeProgressState,
-  formatContextPercent,
-  formatElapsed,
-  formatHeaderStats,
   getProgressState,
   makeTaskPreview,
-  type ProgressStatus,
   patchProgressState,
-  renderToolActivity,
-  renderToolActivityForDisplay,
   resetProgressStore,
-  STATUS_COLOR,
-  STATUS_ICON,
   type SubagentProgressState,
-  type ThemeBg,
 } from "./progress-state.js";
 
 /**
@@ -89,11 +85,18 @@ export function renderSubagentProgress(
 }
 
 class DynamicSubagentProgressText implements Component {
+  private readonly requestId: string;
+  private readonly options: { expanded: boolean };
+  private readonly theme: SubagentTheme;
   constructor(
-    private readonly requestId: string,
-    private readonly options: { expanded: boolean },
-    private readonly theme: SubagentTheme,
-  ) {}
+    requestId: string,
+    options: { expanded: boolean },
+    theme: SubagentTheme,
+  ) {
+    this.requestId = requestId;
+    this.options = options;
+    this.theme = theme;
+  }
   invalidate(): void {}
   render(width: number): string[] {
     const state = getProgressState(this.requestId);
@@ -104,10 +107,6 @@ class DynamicSubagentProgressText implements Component {
   }
 }
 
-function getProgressBackground(status: ProgressStatus): ThemeBg {
-  return STATUS_BG[status];
-}
-
 function renderProgressBox(
   state: SubagentProgressState,
   options: { expanded: boolean },
@@ -117,12 +116,12 @@ function renderProgressBox(
   const status = state.status;
   const title = formatSubagentTitle(state.agent, state.instanceName, theme);
   const header = `${theme.fg(STATUS_COLOR[status], STATUS_ICON[status])} ${title} ${theme.fg("dim", `[${status}]`)} ${theme.fg("muted", formatHeaderStats(state))}`;
-  const box = new Box(1, 1, (line) =>
-    theme.bg(getProgressBackground(status), line),
-  );
+  const box = new Box(1, 1, (line) => theme.bg(STATUS_BG[status], line));
   box.addChild(new Text(header, 0, 0));
   const body = makeProgressBody(state, options, theme, width);
   for (const line of body) box.addChild(line);
+  if (state.modelDisplay)
+    box.addChild(new Text(theme.fg("dim", state.modelDisplay), 0, 0));
   return box;
 }
 
@@ -142,6 +141,10 @@ function makeProgressBody(
   return [];
 }
 
+function bodyMargin(hasFooter: boolean, expanded: boolean): number {
+  return expanded || !hasFooter ? 0 : 1;
+}
+
 function makeRunningProgressBody(
   state: SubagentProgressState,
   options: { expanded: boolean },
@@ -154,11 +157,14 @@ function makeRunningProgressBody(
     state.activeToolActivity,
     activityBudget,
   );
+  const margin = bodyMargin(!!state.modelDisplay, options.expanded);
   if (activityPreview) {
-    body.push(new Text(formatRunningToolPreview(activityPreview, theme), 2, 0));
+    body.push(
+      new Text(formatRunningToolPreview(activityPreview, theme), 2, margin),
+    );
   }
   if (options.expanded)
-    body.push(new Text(theme.fg("dim", state.taskPreview), 2, 0));
+    body.push(new Text(theme.fg("dim", state.taskPreview), 2, margin));
   return body;
 }
 
@@ -168,10 +174,12 @@ function makeStoppedProgressBody(
   theme: SubagentTheme,
 ): Text[] {
   const body: Text[] = [];
-  if (state.errorText)
-    body.push(new Text(theme.fg("error", state.errorText), 2, 0));
+  const margin = bodyMargin(!!state.modelDisplay, options.expanded);
+  if (state.errorText) {
+    body.push(new Text(theme.fg("error", state.errorText), 2, margin));
+  }
   if (options.expanded)
-    body.push(new Text(theme.fg("dim", state.taskPreview), 2, 0));
+    body.push(new Text(theme.fg("dim", state.taskPreview), 2, margin));
   return body;
 }
 
@@ -181,8 +189,9 @@ function makeSuccessProgressBody(
   theme: SubagentTheme,
 ): Text[] {
   const output = state.finalOutput?.trim().split("\n")[0] ?? "";
+  const margin = bodyMargin(!!state.modelDisplay, options.expanded);
   if (!options.expanded) {
-    return output ? [new Text(theme.fg("toolOutput", output), 2, 0)] : [];
+    return output ? [new Text(theme.fg("toolOutput", output), 2, margin)] : [];
   }
   const body = [new Text(theme.fg("dim", state.taskPreview), 2, 0)];
   body.push(
@@ -190,9 +199,9 @@ function makeSuccessProgressBody(
       ? new Text(
           `${theme.fg("muted", "─── Output ───")}\n${theme.fg("toolOutput", output)}`,
           0,
-          0,
+          margin,
         )
-      : new Text(theme.fg("muted", "(no output)"), 0, 0),
+      : new Text(theme.fg("muted", "(no output)"), 0, margin),
   );
   return body;
 }

package/src/progress/result-details.ts

@@ -1,31 +1,29 @@
-import { TOOL_RESULT_FAILED_MESSAGE } from "../child/process.js";
+import type { Message } from "@earendil-works/pi-ai";
+import type { TerminationMetadata } from "../child/termination.js";
 import {
   formatSubagentResultForParent,
   summarizeFeedbackUiFinalOutput,
 } from "../output/summary.js";
-import type {
-  SingleResult,
-  SubagentDetails,
-  SubagentToolResult,
-  ToolActivity,
+import {
+  type SingleResult,
+  type StreamingProgress,
+  type SubagentDetails,
+  type SubagentToolResult,
+  TOOL_RESULT_FAILED_MESSAGE,
+  type ToolActivity,
 } from "../shared/types.js";
-import { detectMessageError } from "../shared/utils.js";
 import {
   extractProgressFromDetails,
   getProgressState,
   patchProgressState,
-  renderToolActivity,
+  type SubagentProgressState,
 } from "./progress.js";
+import { renderToolActivity, SENSITIVE_PATTERN } from "./progress-format.js";
 
-export function hasSubagentFailed(result: SingleResult): boolean {
-  return (
-    result.exitCode !== 0 ||
-    result.stopReason === "error" ||
-    result.stopReason === "aborted" ||
-    Boolean(result.errorMessage?.trim()) ||
-    detectMessageError(result.messages ?? [])
-  );
-}
+export type DetailsOptions = {
+  includeMessages?: boolean;
+  recentMessages?: Message[];
+};
 
 export function createSubagentError(result: SingleResult): Error {
   const formatted = formatSubagentResultForParent(result);
@@ -41,18 +39,127 @@ export function createSubagentError(result: SingleResult): Error {
   return new Error(`Agent ${result.stopReason || "failed"}: ${msg}`);
 }
 
+const DEBUG_REDACTED_PLACEHOLDER = "[redacted]";
+const SENSITIVE_ASSIGNMENT_PATTERN =
+  /\b(?:secret|password|[A-Za-z0-9_-]*token)(?:\s*[:=]\s*)(?:"[^"]*"|'[^']*'|[^\s,;]+)/gi;
+const SENSITIVE_TERM_PATTERN = new RegExp(SENSITIVE_PATTERN.source, "gi");
+const TOKEN_COUNT_KEY_PATTERN = /tokens$/i;
+
+function redactSensitiveDebugString(text: string): string {
+  return text
+    .replace(SENSITIVE_ASSIGNMENT_PATTERN, DEBUG_REDACTED_PLACEHOLDER)
+    .replace(SENSITIVE_TERM_PATTERN, DEBUG_REDACTED_PLACEHOLDER);
+}
+
+function isSensitiveDebugKey(key: string): boolean {
+  const lowerKey = key.toLowerCase();
+  if (TOKEN_COUNT_KEY_PATTERN.test(lowerKey)) return false;
+  return (
+    lowerKey.includes("secret") ||
+    lowerKey.includes("password") ||
+    lowerKey.endsWith("token")
+  );
+}
+
+function redactSensitiveDebugValue(value: unknown): unknown {
+  if (typeof value === "string") return redactSensitiveDebugString(value);
+  if (Array.isArray(value)) return value.map(redactSensitiveDebugValue);
+  if (typeof value !== "object" || value === null) return value;
+  const redacted: Record<string, unknown> = {};
+  for (const [key, child] of Object.entries(value)) {
+    redacted[key] = isSensitiveDebugKey(key)
+      ? DEBUG_REDACTED_PLACEHOLDER
+      : redactSensitiveDebugValue(child);
+  }
+  return redacted;
+}
+
+function redactSensitiveDebugMessages(messages: unknown): unknown {
+  if (!Array.isArray(messages)) return messages;
+  return messages.map(redactSensitiveDebugValue);
+}
+
+export function sanitizeResultDetails(
+  result: SingleResult,
+  includeDebugMessages: boolean,
+  options: DetailsOptions | undefined,
+): SingleResult {
+  const includeMessages =
+    includeDebugMessages && (options?.includeMessages ?? true);
+  const { messages, termination, progress, stderr, usage, ...core } = result;
+  const { contextWindowTokens, ...usageBase } = usage;
+  let progressValue: StreamingProgress | undefined;
+  if (progress) {
+    const {
+      activityText,
+      activeToolActivity,
+      lastToolPreview,
+      toolResultCompleted,
+      ...progBase
+    } = progress;
+    progressValue = {
+      toolCalls: progBase.toolCalls.map((tc) => ({
+        id: tc.id,
+        preview: tc.preview,
+      })),
+      ...(activityText !== undefined && { activityText }),
+      ...(activeToolActivity !== undefined && { activeToolActivity }),
+      ...(lastToolPreview !== undefined && { lastToolPreview }),
+      ...(toolResultCompleted !== undefined && { toolResultCompleted }),
+    };
+  }
+  let terminationValue: TerminationMetadata | undefined;
+  if (includeMessages && includeDebugMessages && termination) {
+    const { cancelReason, terminationSignal, fallbackCause, ...termBase } =
+      termination;
+    terminationValue = {
+      ...termBase,
+      ...(cancelReason !== undefined && { cancelReason }),
+      ...(terminationSignal !== undefined && { terminationSignal }),
+      ...(fallbackCause !== undefined && { fallbackCause }),
+    };
+  }
+  const sanitized: SingleResult = {
+    ...core,
+    stderr: includeDebugMessages ? stderr : "",
+    usage: {
+      ...usageBase,
+      ...(contextWindowTokens !== undefined && { contextWindowTokens }),
+    },
+  };
+  if (progressValue !== undefined) sanitized.progress = progressValue;
+  if (includeMessages) {
+    sanitized.messages = options?.recentMessages
+      ? [...options.recentMessages]
+      : messages !== undefined
+        ? [...messages]
+        : undefined;
+  }
+  if (terminationValue !== undefined) sanitized.termination = terminationValue;
+  return sanitized;
+}
+
 export function sanitizeDetailsForDisplay(
   details: SubagentDetails,
   includeMessages = false,
 ): SubagentDetails {
   return {
     ...details,
-    results: details.results.map(({ messages, termination, ...result }) => ({
-      ...result,
-      stderr: includeMessages ? result.stderr : "",
-      ...(includeMessages ? { messages, termination } : {}),
-    })),
-  };
+    results: details.results.map((result) => {
+      const sanitized = sanitizeResultDetails(
+        result,
+        includeMessages,
+        undefined,
+      );
+      if (includeMessages && sanitized.messages) {
+        return {
+          ...sanitized,
+          messages: redactSensitiveDebugMessages(sanitized.messages),
+        };
+      }
+      return sanitized;
+    }),
+  } as SubagentDetails;
 }
 
 export function getLatestResult(
@@ -76,7 +183,7 @@ export function patchProgressFromDetails(
   } = extractProgressFromDetails(details, seenToolCallIds);
   const current = getProgressState(requestId);
   if (!current) return;
-  const patch: Record<string, unknown> = {
+  const patch: Partial<SubagentProgressState> = {
     toolCount: current.toolCount + newToolCallIds.length,
   };
   let nextActivity: ToolActivity | undefined;
@@ -90,34 +197,34 @@ export function patchProgressFromDetails(
     nextActivity = current.activeToolActivity;
   }
   if (toolResultCompleted && nextActivity?.child) {
-    nextActivity = { ...nextActivity, child: undefined };
+    const { child, ...rest } = nextActivity;
+    nextActivity = rest;
   } else if (toolResultCompleted) {
     nextActivity = undefined;
   }
-  patch.activeToolActivity = nextActivity;
+  patch["activeToolActivity"] = nextActivity;
   const renderedPreview = renderToolActivity(nextActivity);
   if (renderedPreview) {
-    patch.lastToolPreview = renderedPreview;
+    patch["lastToolPreview"] = renderedPreview;
   } else if (toolResultCompleted && !nextActivity) {
-    patch.lastToolPreview = undefined;
+    patch["lastToolPreview"] = undefined;
   }
   if (toolResultCompleted) {
-    patch.toolResultCompleted = true;
+    patch["toolResultCompleted"] = true;
   }
-  // Token accounting always applies when usage data is available
   if (latestResult?.usage) {
-    patch.inputTokens = latestResult.usage.input;
-    patch.outputTokens = latestResult.usage.output;
-    patch.contextTokens = latestResult.usage.contextTokens;
-    patch.contextWindowTokens = latestResult.usage.contextWindowTokens;
+    patch["inputTokens"] = latestResult.usage.input;
+    patch["outputTokens"] = latestResult.usage.output;
+    patch["contextTokens"] = latestResult.usage.contextTokens;
+    patch["contextWindowTokens"] = latestResult.usage.contextWindowTokens;
   }
-  patchProgressState(
-    requestId,
-    patch as Parameters<typeof patchProgressState>[1],
-  );
+  if (latestResult?.model?.trim()) {
+    patch["modelDisplay"] = latestResult.model;
+  }
+  patchProgressState(requestId, patch);
 }
 
-export function getSubagentText(result: SubagentToolResult): string {
+function getSubagentText(result: SubagentToolResult): string {
   return (result.content[0] as { text?: string })?.text ?? "";
 }