pi-tool-duration 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.2.2] - 2026-09-18
+
+### Fixed
+
+- Keep duration markers out of terminal tool output after reload, resume, and branch navigation by storing timing in hidden session entries and annotating only model-request copies.
+- Preserve model-visible timings across restoration, compaction summaries, and retained compaction history without changing tool content or details.
+
+### Changed
+
+- Verify recorded output, reload, restored timing, branch isolation, and repeated model requests in regression tests.
+- Run clean-install checks on Node 22.19 and Node 24 in GitHub Actions.
+
 ## [0.2.1] - 2026-08-09
 
 ### Fixed

package/README.md

@@ -13,13 +13,17 @@ Pi already shows tool timing in the TUI (`Took Xs`), but that timing is UI-only.
 
 ## How it works
 
-The extension measures from Pi's `tool_execution_start` through `tool_execution_end`. When elapsed time is at or above the configured threshold, or Pi marks the result as failed, it appends one text block to the finalized model-visible tool message:
+The extension measures from Pi's `tool_execution_start` through `tool_execution_end`. When elapsed time is at or above the configured threshold, or Pi marks the result as failed, it saves the timing in a hidden session entry. Before each model request, it appends one text block to that request's copy of the tool result:
 
 ```text
 [duration: 5.0s]
 ```
 
-This leaves Pi's TUI output unchanged, so built-in timing such as `Took 5.0s` is not duplicated. Scope: Pi tools that emit tool execution events, including built-ins and extension tools. Direct `!` / `!!` shell commands and RPC `bash` command messages are not tool results and are not annotated.
+Compaction summaries also receive annotated copies of tool results. Recorded tool output stays unchanged, including after reload, resume, and branch navigation. Timings remain available to the model across those transitions without duplicating Pi's native TUI timing such as `Took 5.0s`.
+
+Markers already saved as tool text by versions through 0.2.1 remain unchanged. They cannot be safely distinguished from genuine tool output with the same text.
+
+Scope: Pi tools that emit tool execution events, including built-ins and extension tools. Direct `!` / `!!` shell commands and RPC `bash` command messages are not tool results and are not annotated.
 
 Pi starts these timers during sequential tool-call preflight. In a parallel batch, a call's elapsed time can therefore include time spent preparing later siblings. This mirrors Pi's TUI timing.
 
@@ -30,7 +34,7 @@ Requires Pi 0.84.0 or later.
 ```bash
 pi install .                         # local, global settings
 pi install -l --approve .            # local, project settings
-pi install npm:pi-tool-duration      # after npm publish
+pi install npm:pi-tool-duration      # published package
 ```
 
 ## Try without installing

package/extensions/tool-duration/index.ts

@@ -5,9 +5,12 @@
  * how long a call actually took. pi already measures this for the TUI
  * ("Took Xs") but the model does not see that timing.
  */
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ContextEvent, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 const DEFAULT_THRESHOLD_MS = 1000;
+const TIMING_ENTRY = "pi-tool-duration";
+
+type SavedTiming = { toolCallId: string; timestamp: number; duration: string };
 
 function parseThreshold(value: unknown): number | undefined {
   if (typeof value !== "string" && typeof value !== "number") return undefined;
@@ -24,6 +27,30 @@ function thresholdMs(pi: ExtensionAPI): number {
   );
 }
 
+function withDurations(messages: ContextEvent["messages"], ctx: ExtensionContext) {
+  const saved = new Map<string, string>();
+  for (const entry of ctx.sessionManager.getBranch()) {
+    if (entry.type !== "custom" || entry.customType !== TIMING_ENTRY) continue;
+    const timing = entry.data as SavedTiming | undefined;
+    if (
+      typeof timing?.toolCallId !== "string" ||
+      typeof timing.timestamp !== "number" ||
+      typeof timing.duration !== "string"
+    ) continue;
+    saved.set(`${timing.timestamp}:${timing.toolCallId}`, timing.duration);
+  }
+
+  return messages.map((message) => {
+    if (message.role !== "toolResult") return message;
+    const duration = saved.get(`${message.timestamp}:${message.toolCallId}`);
+    if (!duration) return message;
+    return {
+      ...message,
+      content: [...message.content, { type: "text" as const, text: duration }],
+    };
+  });
+}
+
 export default function (pi: ExtensionAPI) {
   const starts = new Map<string, number>();
   const durations = new Map<string, string>();
@@ -54,12 +81,20 @@ export default function (pi: ExtensionAPI) {
     durations.delete(event.message.toolCallId);
     if (!duration) return;
 
-    return {
-      message: {
-        ...event.message,
-        content: [...event.message.content, { type: "text" as const, text: duration }],
-      },
-    };
+    // Keep timing out of recorded tool content: Pi also uses it to rebuild the TUI.
+    pi.appendEntry<SavedTiming>(TIMING_ENTRY, {
+      toolCallId: event.message.toolCallId,
+      timestamp: event.message.timestamp,
+      duration,
+    });
+  });
+
+  pi.on("context", (event, ctx) => ({ messages: withDurations(event.messages, ctx) }));
+
+  pi.on("session_before_compact", ({ preparation }, ctx) => {
+    // Native summarization bypasses context hooks. Replace its inputs, never the saved messages.
+    preparation.messagesToSummarize = withDurations(preparation.messagesToSummarize, ctx);
+    preparation.turnPrefixMessages = withDurations(preparation.turnPrefixMessages, ctx);
   });
 
   const clearTimings = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tool-duration",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Append model-visible durations to slow Pi tool results",
   "type": "module",
   "author": "Mitch Fultz (https://github.com/fitchmultz)",