pi-tool-duration 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # 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
+
+- Use Pi's error status instead of guessing from arbitrary result text or metadata, eliminating false duration markers on successful tools.
+- Append duration markers to finalized model-visible messages so the TUI keeps its single native timer, missing-content tools stay safe, blocked preflight failures are covered, and marker-like tool output is still measured.
+- Keep the long threshold flag readable in `pi --help` and declare the documented Pi 0.84.0 host floor in package metadata.
+- Keep the integration-test dependency lockfile installable from the public npm registry.
+
+### Changed
+
+- Added real Pi CLI integration coverage over a local HTTP model transport for timing, flags, failures, parallel calls, lifecycle cleanup, and result preservation.
+
 ## [0.2.0] - 2026-08-06
 
 ### Changed

package/README.md

@@ -13,13 +13,19 @@ Pi already shows tool timing in the TUI (`Took Xs`), but that timing is UI-only.
 
 ## How it works
 
-The extension matches Pi `tool_execution_start` and `tool_result` events by `toolCallId`. When elapsed time is at or above the configured threshold, or a result reports a non-zero exit code, it appends one text block:
+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]
 ```
 
-Scope: Pi tools that emit `tool_result` 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.
 
 ## Install
 
@@ -28,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
@@ -36,21 +42,23 @@ pi install npm:pi-tool-duration      # after npm publish
 From this repo:
 
 ```bash
-pi -e .
+pi --no-extensions -e .
 # or
-pi -e ./extensions/tool-duration/index.ts
+pi --no-extensions -e ./extensions/tool-duration/index.ts
 ```
 
+`--no-extensions` prevents a duplicate flag conflict when another copy is already installed.
+
 ## Configure
 
 Default threshold: `1000` ms.
 
 ```bash
-PI_TOOL_DURATION_THRESHOLD_MS=0 pi -e .        # annotate every tool result
-pi -e . --tool-duration-threshold-ms 500       # annotate tools taking >= 500ms
+PI_TOOL_DURATION_THRESHOLD_MS=0 pi --no-extensions -e .   # annotate every tool result
+pi --no-extensions -e . --tool-duration-threshold-ms 500  # annotate tools taking >= 500ms
 ```
 
-Invalid threshold values fall back to the default.
+Invalid values are ignored. An invalid CLI value falls through to the environment value; an invalid environment value falls back to the default.
 
 ## Verify
 
@@ -67,7 +75,7 @@ hi
 [duration: 5.0s]
 ```
 
-A fast successful command below the threshold stays unchanged. A non-zero exit code is always annotated, even below the threshold.
+A fast successful tool below the threshold stays unchanged. A failed tool result delivered to the model is always annotated, even below the threshold.
 
 ## License
 

package/extensions/tool-duration/index.ts

@@ -1,14 +1,16 @@
 /**
  * pi-tool-duration
  *
- * Appends `[duration: Xs]` to slow tool results so the model sees how long a
- * call actually took. pi already measures this for the TUI ("Took Xs") but the
- * model does not see that timing.
+ * Appends `[duration: Xs]` to slow or failed tool messages so the model sees
+ * 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 DURATION_RE = /^\[duration: \d+(?:\.\d+)?s\]$/;
+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;
@@ -25,56 +27,82 @@ function thresholdMs(pi: ExtensionAPI): number {
   );
 }
 
-function alreadyAnnotated(content: Array<{ type: string; text?: string }>): boolean {
-  const last = content.at(-1);
-  return last?.type === "text" && typeof last.text === "string" && DURATION_RE.test(last.text);
-}
-
-function nonZeroExitCode(event: { content: Array<{ type: string; text?: string }>; details?: unknown }): boolean {
-  const details = event.details as Record<string, unknown> | null;
-  const code = details && Number(details.exitCode ?? details.code ?? details.status);
-  if (code !== null && Number.isFinite(code)) return code !== 0;
+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 event.content.some(
-    (item) =>
-      item.type === "text" &&
-      typeof item.text === "string" &&
-      /(?:exited with code|exit code)\s+(-?[1-9]\d*)\b/i.test(item.text),
-  );
+  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>();
 
   pi.registerFlag("tool-duration-threshold-ms", {
-    description: "Minimum tool duration in milliseconds before appending [duration: Xs] to the model-visible result",
+    // Pi's help formatter adds no separator once this long flag exceeds its 30-column width.
+    description: " Minimum elapsed milliseconds before appending a model-visible duration",
     type: "string",
   });
 
-  pi.on("tool_execution_start", async (event) => {
+  pi.on("tool_execution_start", (event) => {
     starts.set(event.toolCallId, performance.now());
   });
 
-  pi.on("tool_result", async (event) => {
+  pi.on("tool_execution_end", (event) => {
     const startedAt = starts.get(event.toolCallId);
     starts.delete(event.toolCallId);
     if (startedAt === undefined) return;
 
     const ms = performance.now() - startedAt;
-    if (!nonZeroExitCode(event) && ms < thresholdMs(pi)) return;
-    if (alreadyAnnotated(event.content)) return;
+    if (!event.isError && ms < thresholdMs(pi)) return;
+    durations.set(event.toolCallId, `[duration: ${(ms / 1000).toFixed(1)}s]`);
+  });
 
-    return {
-      content: [
-        ...event.content,
-        { type: "text" as const, text: `[duration: ${(ms / 1000).toFixed(1)}s]` },
-      ],
-    };
+  pi.on("message_end", (event) => {
+    if (event.message.role !== "toolResult") return;
+    const duration = durations.get(event.message.toolCallId);
+    durations.delete(event.message.toolCallId);
+    if (!duration) return;
+
+    // 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 clearStarts = () => starts.clear();
-  pi.on("session_start", clearStarts);
-  pi.on("session_shutdown", clearStarts);
-  pi.on("agent_end", clearStarts);
-  pi.on("agent_settled", clearStarts);
+  const clearTimings = () => {
+    starts.clear();
+    durations.clear();
+  };
+  pi.on("session_start", clearTimings);
+  pi.on("session_shutdown", clearTimings);
+  pi.on("agent_end", clearTimings);
+  pi.on("agent_settled", clearTimings);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tool-duration",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Append model-visible durations to slow Pi tool results",
   "type": "module",
   "author": "Mitch Fultz (https://github.com/fitchmultz)",
@@ -41,10 +41,11 @@
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "0.84.0",
+    "typebox": "1.3.7",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": ">=0.84.0"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {