@pi-archimedes/ui 2.10.4 → 2.11.0

package/README.md

@@ -5,6 +5,7 @@ TUI enhancements for the Pi Archimedes monorepo.
 ## Features
 
 ### Bash Tool Styling
+- **Pi's tool, our row**: `bash` stays pi's own built-in tool — this package never registers it. It installs one `pi.registerToolRenderer()` resolver that decides how calls to `bash` are drawn, so pi keeps the executor, description, reachability and activation of that tool.
 - **Collapsed/Expanded Views**: Toggleable tool execution details.
 - **Live Timer**: Track tool execution duration.
 - **Status Indicators**:
@@ -14,12 +15,12 @@ TUI enhancements for the Pi Archimedes monorepo.
 
 ### Codemode Tool Styling
 - **Styling follows the `toolStyle` master switch**:
-  - **Minimal** (default): the override is registered — the collapsed row is the `codemode` header plus the nested tool calls the script made (last five, with an expand hint when there are more) — no script dump, no summary line. A script that made no calls shows a single `<glyph> <duration>` line instead.
-  - **Native**: the override is not registered at all — pi's native codemode rendering stands (and no built-in-takeover startup notice).
+  - **Minimal** (default): the resolver answers with our row — the collapsed row is the `codemode` header plus the nested tool calls the script made (last five, with an expand hint when there are more) — no script dump, no summary line. A script that made no calls shows a single `<glyph> <duration>` line instead.
+  - **Native**: the resolver answers `next()` — pi's own codemode rendering stands.
 - **Expanded View**: The syntax-highlighted script, every nested call (status glyph, args, duration, and cost for `models.*` calls, with a `Model calls: $total` line when several were priced), the script output without the executor's `Script completed/failed` header (image blocks show a `[Image: …]` indicator — the renderer is text-only), the full-output path when truncated, and the timing + final status.
 - **Live Timer**: In-flight calls show the `…` running glyph and update every second.
-- **Native Behaviour Preserved**: The override re-registers pi's own `codemode` tool (executor, dynamic description, activation semantics all intact) and replaces only the presentation — so it takes over pi's replaceable built-in `codemode` extension (pi prints a one-line startup notice, as it does for any extension that replaces a built-in).
-- **Graceful Fallback**: On pi versions without the `codemode` extension the override is a no-op and pi's native rendering stands in.
+- **Native Behaviour Preserved**: `codemode` is pi's own built-in extension and stays that way — nothing in this package registers it, so pi keeps the QuickJS executor, the dynamic description, the per-tool prompt guidelines and `defaultActive: false`, and no "built-in extension was not loaded" startup notice appears because nothing was replaced. Only the presentation is ours (ADR 0029).
+- **Graceful Fallback**: The styling is installed behind `typeof pi.registerToolRenderer === "function"` (pi 1.0.1+), so a host without that API gets pi's own rendering for `bash` and `codemode` alike; a session with no `codemode` tool is simply never asked about it.
 
 ### Editor
 - **HephaestusEditor**: Advanced text editing capabilities.
@@ -32,7 +33,9 @@ TUI enhancements for the Pi Archimedes monorepo.
 - **Theme**: Unified styling for thinking blocks.
 
 ### Startup
-- **Splash Logo Reveal**: Engaging animations during initialization.
+- **The splash is opt-in, and off by default.** Out of the box you get **pi's own startup screen** — its header, its key hints, its loaded-resource listing. `startupSplash: true` installs the Archimedes splash in pi's header slot instead; with it off nothing is installed, so pi's `quietStartup` keeps working exactly as it does with no Archimedes loaded.
+- **Splash Logo Reveal** (`startupSplash: true`): An animated logo reveal with the running Pi version and the session's model scope (`ctx.scopedModels` — the set `/scoped-models` shows), drawn in pi's own row style so it reads as one document with the listing below it.
+- **Honours Pi's `quietStartup`** (when the splash is on): `false` = splash with its details, `"header"` = splash alone, `true` = Pi's own quiet startup (the splash hands the header back). With the splash off, that setting is pi's alone to act on. Nothing is scraped from Pi's output to decide any of this, and the splash makes no network request — Pi's own update check is the only one.
 
 ## Settings (`archimedes.ui`)
 
@@ -47,8 +50,9 @@ TUI enhancements for the Pi Archimedes monorepo.
 | `codeUnindent` | boolean | `true` | Strip common indentation from code blocks |
 | `labelText` | string | `"Thinking..."` | Text shown before thinking blocks |
 | `labelColor` | string | `"255,215,0"` | RGB color for the thinking label (e.g. `255,215,0`) |
-| `animationStyle` | "diagonal" \| "top-right" \| "bottom-left" \| "bottom-right" \| "center-out" \| "wave" \| "horizontal" \| "vertical" \| "vertical-up" | `"vertical-up"` | Startup logo animation |
-| `colorfulLogo` | boolean | `false` | Use pi's brand colors for the splash logo |
+| `startupSplash` | boolean | `false` | Install the Archimedes startup splash (off = pi's own startup screen) |
+| `animationStyle` | "diagonal" \| "top-right" \| "bottom-left" \| "bottom-right" \| "center-out" \| "wave" \| "horizontal" \| "vertical" \| "vertical-up" | `"vertical-up"` | Startup logo animation (applies when `startupSplash` is true) |
+| `colorfulLogo` | boolean | `false` | Use pi's brand colors for the splash logo (applies when `startupSplash` is true) |
 | `editorSpinBorder` | boolean | `true` | Animated spinner border on editor |
 | `editorSpinSpeed` | "slow" \| "normal" \| "fast" | `"normal"` | Editor border spinner speed |
 | `editorSpinStyle` | "typing" \| "pulse" \| "rain" \| "cascade" \| "columns" \| "wave-rows" \| "diagonal-swipe" \| "sparkle" \| "pendulum" \| "marquee" | `"pendulum"` | Editor spinner style |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/ui",
-  "version": "2.10.4",
+  "version": "2.11.0",
   "description": "Terminal UI enhancements, styled bash tool rendering, and visual presentation components for Pi",
   "type": "module",
   "main": "./src/index.ts",
@@ -28,17 +28,17 @@
     "./config": "./src/config.ts"
   },
   "dependencies": {
-    "@pi-archimedes/core": "2.10.4"
+    "@pi-archimedes/core": "2.11.0"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.87.0",
-    "@earendil-works/pi-coding-agent": "^0.87.0",
-    "@earendil-works/pi-tui": "^0.87.0",
+    "@earendil-works/pi-ai": "1.2.0",
+    "@earendil-works/pi-coding-agent": "1.2.0",
+    "@earendil-works/pi-tui": "1.2.0",
     "typescript": "^6.0.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.1.0",
-    "@earendil-works/pi-coding-agent": ">=0.1.0",
-    "@earendil-works/pi-tui": ">=0.1.0"
+    "@earendil-works/pi-ai": ">=1.2.0",
+    "@earendil-works/pi-coding-agent": ">=1.2.0",
+    "@earendil-works/pi-tui": ">=1.2.0"
   }
 }

package/src/bash/index.ts

@@ -3,8 +3,6 @@ export {
   renderBashResult,
   formatBashCommand,
   formatDuration,
-  clearActiveBashIntervals,
   TruncatedTextComponent,
   type BashRendererState,
 } from "./renderer.js";
-export { registerBashToolOverride } from "./tool.js";

package/src/bash/renderer.test.ts

@@ -7,7 +7,6 @@ import {
   formatBashCommand,
   renderBashCall,
   renderBashResult,
-  clearActiveBashIntervals,
   TruncatedTextComponent,
 } from "./renderer.js";
 
@@ -316,7 +315,7 @@ describe("renderBashResult - Live timer lifecycle", () => {
     expect(context.state.endedAt).toBeDefined();
   });
 
-  it("clears active bash intervals when clearActiveBashIntervals is called", () => {
+  it("stops the once-a-second repaint as soon as the result settles", () => {
     const context = {
       executionStarted: true,
       invalidate: vi.fn(),
@@ -326,14 +325,60 @@ describe("renderBashResult - Live timer lifecycle", () => {
     renderBashResult({}, { isPartial: true }, theme, context);
     expect(context.state.interval).toBeDefined();
 
-    clearActiveBashIntervals();
+    renderBashResult({}, { isPartial: false }, theme, context);
     expect(context.state.interval).toBeUndefined();
-    // Verify if the interval still triggers
-    vi.advanceTimersByTime(1000);
+
+    vi.advanceTimersByTime(3000);
     expect(context.invalidate).not.toHaveBeenCalled();
   });
 });
 
+describe("renderBashResult timing comes from the result", () => {
+  it("says how long the command took after a session reload, with no row state", () => {
+    // A row rebuilt from a stored session has never run in this process: all it
+    // has is the duration the result recorded.
+    const text = renderBashResult(
+      { content: [{ type: "text", text: "ok" }] },
+      { expanded: true, isPartial: false },
+      theme,
+      { durationMs: 4200, executionStarted: true, state: {} },
+    );
+    expect(content(text)).toContain("Took 4.2s");
+  });
+
+  it("shows the recorded duration, not the wall clock the row happened to span", () => {
+    const text = renderBashResult(
+      { content: [{ type: "text", text: "ok" }] },
+      { expanded: true, isPartial: false },
+      theme,
+      { durationMs: 1500, executionStarted: true, state: { startedAt: Date.now() - 90_000 } },
+    );
+    const out = content(text);
+    expect(out).toContain("Took 1.5s");
+    expect(out).not.toContain("1m 30s");
+  });
+
+  it("collapses to the recorded duration too", () => {
+    const text = renderBashResult(
+      { content: [{ type: "text", text: "ok" }] },
+      { expanded: false, isPartial: false },
+      theme,
+      { durationMs: 4200, state: {} },
+    );
+    expect(content(text)).toContain("[muted:4.2s]");
+  });
+
+  it("still counts up while the command runs", () => {
+    const text = renderBashResult(
+      { content: [{ type: "text", text: "" }] },
+      { expanded: true, isPartial: true },
+      theme,
+      { state: { startedAt: Date.now() - 2500 }, executionStarted: true },
+    );
+    expect(content(text)).toContain("Elapsed");
+  });
+});
+
 describe("renderBashResult - Expanded view", () => {
   it("renders full command with $ prefix, output lines, duration, and ✓ Done on success", () => {
     const context = {

package/src/bash/renderer.ts

@@ -1,6 +1,6 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Text, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
-import { renderToolHeader } from "@pi-archimedes/core/tool-render";
+import { renderToolHeader, toolRowDuration } from "@pi-archimedes/core/tool-render";
 
 export interface BashRendererState {
   startedAt?: number | undefined;
@@ -10,18 +10,6 @@ export interface BashRendererState {
   command?: string | undefined;
 }
 
-const activeStates = new Set<BashRendererState>();
-
-export function clearActiveBashIntervals(): void {
-  for (const state of activeStates) {
-    if (state.interval) {
-      clearInterval(state.interval);
-      state.interval = undefined;
-    }
-  }
-  activeStates.clear();
-}
-
 /**
  * Format duration in milliseconds as:
  * - <X.X>s for under 10 seconds (e.g. "1.5s")
@@ -171,6 +159,7 @@ export function renderBashResult(
   const ctx = context as {
     executionStarted?: boolean;
     isError?: boolean;
+    durationMs?: number | undefined;
     state?: BashRendererState;
     args?: { command?: string; timeout?: number };
     invalidate?: () => void;
@@ -185,22 +174,22 @@ export function renderBashResult(
     state.startedAt = Date.now();
   }
 
-  if (options.isPartial && !state.interval) {
-    if (ctx?.invalidate) {
-      state.interval = setInterval(() => {
-        ctx.invalidate?.();
-      }, 1000);
-      activeStates.add(state);
-    }
+  // While the result is partial the row repaints once a second so `Elapsed`
+  // moves. The interval lives on the row's own state and is cleared when the
+  // result settles — the same arrangement pi's rows use, and the reason there
+  // is no module-level registry of live rows to sweep on shutdown.
+  const settled = !options.isPartial || Boolean(ctx?.isError);
+  if (options.isPartial && !state.interval && ctx?.invalidate) {
+    state.interval = setInterval(() => {
+      ctx.invalidate?.();
+    }, 1000);
   }
-
-  if (!options.isPartial || ctx?.isError) {
+  if (settled) {
     state.endedAt ??= Date.now();
     if (state.interval) {
       clearInterval(state.interval);
       state.interval = undefined;
     }
-    activeStates.delete(state);
   }
 
   const res = result as {
@@ -219,10 +208,17 @@ export function renderBashResult(
   } | undefined;
 
   const isError = Boolean(ctx?.isError || res?.isError || result instanceof Error);
-  const now = Date.now();
-  const startTime = state.startedAt ?? (state.endedAt ?? now);
-  const endTime = state.endedAt ?? now;
-  const elapsed = Math.max(0, endTime - startTime);
+  // The duration the tool recorded wins over the row's own clock, so a
+  // reloaded session still says how long the command took.
+  const timing = toolRowDuration(
+    {
+      durationMs: ctx?.durationMs,
+      startedAt: state.startedAt,
+      endedAt: state.endedAt,
+    },
+    { isPartial: Boolean(options.isPartial), isError },
+  );
+  const elapsed = timing?.ms;
 
   const textComponent = getTextComponent(context);
 
@@ -241,7 +237,8 @@ export function renderBashResult(
         ? theme.fg("dim", ` (timeout: ${timeout}s)`)
         : "";
 
-    const styledDuration = theme.fg("muted", formatDuration(elapsed));
+    const styledDuration =
+      elapsed === undefined ? "" : theme.fg("muted", formatDuration(elapsed));
 
     textComponent.setText(`${statusGlyph} ${styledDuration}${timeoutSuffix}`);
     return textComponent;
@@ -277,8 +274,9 @@ export function renderBashResult(
     );
   }
 
-  const durationLabel = options.isPartial ? "Elapsed" : "Took";
-  parts.push(theme.fg("muted", `${durationLabel} ${formatDuration(elapsed)}`));
+  if (elapsed !== undefined) {
+    parts.push(theme.fg("muted", `${timing!.label} ${formatDuration(elapsed)}`));
+  }
 
   if (!options.isPartial) {
     if (isError) {

package/src/codemode/index.ts

@@ -1,9 +1,3 @@
-export {
-  loadCodemodeModule,
-  resolveCodemodeModuleFiles,
-  findAgentPackageRoot,
-  type CodemodeToolModule,
-} from "./loader.js";
 export {
   renderCodemodeCall,
   renderCodemodeResult,
@@ -11,10 +5,7 @@ export {
   formatCost,
   formatNestedCall,
   getCodemodeOutput,
-  parseWallTimeMs,
-  clearActiveCodemodeIntervals,
   type CodemodeNestedCall,
   type CodemodeToolDetails,
   type CodemodeRendererState,
 } from "./renderer.js";
-export { registerCodemodeToolOverride } from "./tool.js";

package/src/codemode/renderer.test.ts

@@ -5,10 +5,8 @@ import {
   formatCost,
   formatNestedCall,
   getCodemodeOutput,
-  parseWallTimeMs,
   renderCodemodeCall,
   renderCodemodeResult,
-  clearActiveCodemodeIntervals,
 } from "./renderer.js";
 
 // Mock Text from @earendil-works/pi-tui while preserving real utility
@@ -170,29 +168,31 @@ describe("formatNestedCall", () => {
   });
 });
 
-describe("parseWallTimeMs", () => {
-  it("parses the wall time from the result header", () => {
-    expect(
-      parseWallTimeMs([
-        { type: "text", text: "Script completed\nWall time 0.4 seconds\nOutput:\n" },
-      ]),
-    ).toBe(400);
-  });
-
-  it("parses failed-script headers too", () => {
-    expect(
-      parseWallTimeMs([
-        { type: "text", text: "Script failed\nWall time 12.5 seconds\nOutput:\n" },
-      ]),
-    ).toBe(12500);
+describe("renderCodemodeResult timing comes from the result", () => {
+  it("says how long the script took after a session reload, with no row state", () => {
+    // A row rebuilt from a stored session has never run in this process, and the
+    // executor's wall-time header is stripped from the output anyway: the
+    // duration the result recorded is what the row has.
+    const out = renderCodemodeResult(
+      { content: [{ type: "text", text: "Script completed\nWall time 3.2 seconds\nOutput:\n" }] },
+      { expanded: true },
+      theme,
+      { durationMs: 3200, executionStarted: true, state: {} },
+    );
+    expect(text(out)).toContain("Took 3.2s");
   });
 
-  it("returns undefined without a header or for non-text first blocks", () => {
-    expect(parseWallTimeMs([{ type: "text", text: "plain output" }])).toBe(
-      undefined,
+  it("shows the recorded duration, not the wall clock the row happened to span", () => {
+    const out = renderCodemodeResult(
+      { content: [] },
+      { expanded: true },
+      theme,
+      { durationMs: 250, executionStarted: true, state: { startedAt: Date.now() - 90_000 } },
     );
-    expect(parseWallTimeMs([{ type: "image" }])).toBe(undefined);
-    expect(parseWallTimeMs([])).toBe(undefined);
+    const outText = text(out);
+    expect(outText).toContain("Took 250ms");
+    expect(outText).not.toContain("1.5m");
+    expect(outText).not.toContain("90.0s");
   });
 });
 
@@ -286,7 +286,7 @@ describe("renderCodemodeCall", () => {
 });
 
 describe("renderCodemodeResult - Collapsed view (Minimal)", () => {
-  it("renders the success glyph and the wall time from the header", () => {
+  it("renders the success glyph and the duration the script recorded", () => {
     const out = renderCodemodeResult(
       {
         content: [
@@ -299,7 +299,7 @@ describe("renderCodemodeResult - Collapsed view (Minimal)", () => {
       },
       { expanded: false },
       theme,
-      {},
+      { durationMs: 400 },
     );
     expect(text(out)).toBe("[success:✓] [muted:400ms]");
   });
@@ -375,7 +375,7 @@ describe("renderCodemodeResult - Collapsed view (Minimal)", () => {
       },
       { expanded: false },
       theme,
-      {},
+      { durationMs: 1000 },
     );
     expect(text(out)).toBe("[success:✓] [muted:1.0s]");
   });
@@ -406,7 +406,7 @@ describe("renderCodemodeResult - Collapsed view (Minimal)", () => {
       },
       { expanded: false },
       theme,
-      { isError: true },
+      { isError: true, durationMs: 200 },
     );
     expect(text(out)).toBe("[error:✗] [muted:200ms]");
   });
@@ -521,7 +521,7 @@ describe("renderCodemodeResult - Live timer lifecycle", () => {
     expect(context.state.endedAt).toBeDefined();
   });
 
-  it("clears active codemode intervals when clearActiveCodemodeIntervals is called", () => {
+  it("stops the once-a-second repaint as soon as the script settles", () => {
     const context = {
       executionStarted: true,
       invalidate: vi.fn(),
@@ -531,9 +531,10 @@ describe("renderCodemodeResult - Live timer lifecycle", () => {
     renderCodemodeResult({}, { isPartial: true }, theme, context);
     expect(context.state.interval).toBeDefined();
 
-    clearActiveCodemodeIntervals();
+    renderCodemodeResult({}, { isPartial: false }, theme, context);
     expect(context.state.interval).toBeUndefined();
-    vi.advanceTimersByTime(1000);
+
+    vi.advanceTimersByTime(3000);
     expect(context.invalidate).not.toHaveBeenCalled();
   });
 
@@ -616,7 +617,7 @@ describe("renderCodemodeResult - Expanded view", () => {
       },
       { expanded: true },
       theme,
-      {},
+      { durationMs: 300 },
     );
     const outText = text(out);
 
@@ -645,7 +646,7 @@ describe("renderCodemodeResult - Expanded view", () => {
       },
       { expanded: true },
       theme,
-      { isError: true },
+      { isError: true, durationMs: 100 },
     );
     const outText = text(out);
 

package/src/codemode/renderer.ts

@@ -7,7 +7,7 @@ import {
   Text,
   type Component,
 } from "@earendil-works/pi-tui";
-import { renderToolHeader } from "@pi-archimedes/core/tool-render";
+import { renderToolHeader, toolRowDuration } from "@pi-archimedes/core/tool-render";
 
 /** Nested-call args preview budget, collapsed (the native renderer uses 80). */
 const COLLAPSED_CALL_ARGS_CHARS = 80;
@@ -42,23 +42,6 @@ export interface CodemodeRendererState {
   interval?: NodeJS.Timeout | undefined;
 }
 
-const activeStates = new Set<CodemodeRendererState>();
-
-/**
- * Clear live-timer intervals of in-flight codemode rows. Called on
- * session_shutdown so a cancelled script does not keep invalidating a
- * component that no longer exists.
- */
-export function clearActiveCodemodeIntervals(): void {
-  for (const state of activeStates) {
-    if (state.interval) {
-      clearInterval(state.interval);
-      state.interval = undefined;
-    }
-  }
-  activeStates.clear();
-}
-
 /**
  * Format a duration in milliseconds: `<X>ms` under a second, `<X.X>s`
  * otherwise (the native codemode renderer's format).
@@ -157,16 +140,17 @@ export function getCodemodeOutput(
 }
 
 /**
- * Track the script's wall clock for the collapsed row: start on the first
- * render after execution began, end when the result settles (or errors).
- * Mirrors the bash renderer's timer lifecycle.
+ * Keep the row's own clock for the live `Elapsed` count: start on the first
+ * render after execution began, stop the repaint when the result settles (or
+ * errors). The interval lives on the row's own state — pi's rows do the same —
+ * and there is no module-level registry of live rows to sweep on shutdown.
  *
  * `isPartial` means "still in flight": the CALL renderer passes `true`
  * (a call is in flight until its result settles) — passing `false` there
- * would record `endedAt` at call-render time and freeze the elapsed timer
- * for the rest of the script. The interval is (re)created only while the
- * result has not settled yet (`endedAt === undefined`), so a re-render of a
- * settled call never spawns a permanent interval.
+ * would record `endedAt` at call-render time and freeze the count for the rest
+ * of the script. The interval is (re)created only while the result has not
+ * settled yet (`endedAt === undefined`), so a re-render of a settled call never
+ * spawns a permanent interval.
  */
 function updateTiming(
   ctx: {
@@ -183,41 +167,22 @@ function updateTiming(
   if ((ctx?.executionStarted || isPartial) && state.startedAt === undefined) {
     state.startedAt = Date.now();
   }
-  if (isPartial && !state.interval && state.endedAt === undefined) {
-    if (ctx?.invalidate) {
-      state.interval = setInterval(() => {
-        ctx.invalidate?.();
-      }, 1000);
-      activeStates.add(state);
-    }
+
+  const settled = !isPartial || ctx?.isError === true;
+  if (isPartial && !state.interval && state.endedAt === undefined && ctx?.invalidate) {
+    state.interval = setInterval(() => {
+      ctx.invalidate?.();
+    }, 1000);
   }
-  if (!isPartial || ctx?.isError) {
+  if (settled) {
     state.endedAt ??= Date.now();
     if (state.interval) {
       clearInterval(state.interval);
       state.interval = undefined;
     }
-    activeStates.delete(state);
   }
 }
 
-/**
- * The script's wall time in ms, parsed from the result header when present
- * (more accurate than the renderer's timer, which spans TUI updates).
- */
-export function parseWallTimeMs(
-  content: Array<{ type: string; text?: string }>,
-): number | undefined {
-  const first = content[0];
-  if (first?.type !== "text" || typeof first.text !== "string") return undefined;
-  const match = first.text.match(
-    /^Script (completed|failed)\nWall time ([\d.]+) seconds/,
-  );
-  if (!match) return undefined;
-  const seconds = Number.parseFloat(match[2]!);
-  return Number.isFinite(seconds) ? seconds * 1000 : undefined;
-}
-
 /**
  * Render the codemode tool call: the bold `codemode` header. Collapsed, the
  * header stands alone — the script (syntax-highlighted) shows when expanded.
@@ -294,6 +259,7 @@ export function renderCodemodeResult(
   const ctx = context as {
     executionStarted?: boolean;
     isError?: boolean;
+    durationMs?: number | undefined;
     state?: CodemodeRendererState;
     invalidate?: () => void;
   } | undefined;
@@ -308,14 +274,17 @@ export function renderCodemodeResult(
   const calls = res?.details?.calls ?? [];
   const isError = Boolean(ctx?.isError);
 
-  const state: CodemodeRendererState = ctx?.state ?? {};
-  const now = Date.now();
-  const wallTime = parseWallTimeMs(content);
-  const timerMs =
-    state.startedAt !== undefined
-      ? Math.max(0, (state.endedAt ?? now) - state.startedAt)
-      : undefined;
-  const durationMs = wallTime ?? timerMs;
+  // The duration the script recorded wins over the row's own clock, so a
+  // reloaded session still says how long the script took.
+  const timing = toolRowDuration(
+    {
+      durationMs: ctx?.durationMs,
+      startedAt: ctx?.state?.startedAt,
+      endedAt: ctx?.state?.endedAt,
+    },
+    { isPartial: Boolean(options.isPartial), isError },
+  );
+  const durationMs = timing?.ms;
 
   const container = new Container();
 
@@ -378,9 +347,8 @@ export function renderCodemodeResult(
   }
 
   if (durationMs !== undefined) {
-    const label = options.isPartial ? "Elapsed" : "Took";
     parts.push(
-      theme.fg("muted", `${label} ${formatCodemodeDuration(durationMs)}`),
+      theme.fg("muted", `${timing!.label} ${formatCodemodeDuration(durationMs)}`),
     );
   }