pi-tool-duration 0.1.4 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [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
+
+- Requires Pi 0.84.0 or later and refreshes the development lock against the released Pi 0.84.0 packages.
+- Verified the tool timing hooks and lifecycle cleanup against Pi 0.84.0's extension events, emitted types, and runtime implementation.
+
 ## [0.1.4] - 2026-07-16
 
 - Refreshed the local Pi development lock and validation baseline to Pi 0.80.9; the unified model runtime/provider changes do not affect tool timing.

package/README.md

@@ -13,16 +13,20 @@ 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 appends one text block to the finalized model-visible tool message:
 
 ```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.
+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.
+
+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
 
+Requires Pi 0.84.0 or later.
+
 ```bash
 pi install .                         # local, global settings
 pi install -l --approve .            # local, project settings
@@ -34,21 +38,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
 
@@ -65,7 +71,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,13 @@
 /**
  * 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";
 
 const DEFAULT_THRESHOLD_MS = 1000;
-const DURATION_RE = /^\[duration: \d+(?:\.\d+)?s\]$/;
 
 function parseThreshold(value: unknown): number | undefined {
   if (typeof value !== "string" && typeof value !== "number") return undefined;
@@ -25,56 +24,50 @@ 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;
-
-  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),
-  );
-}
-
 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]`);
+  });
+
+  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;
 
     return {
-      content: [
-        ...event.content,
-        { type: "text" as const, text: `[duration: ${(ms / 1000).toFixed(1)}s]` },
-      ],
+      message: {
+        ...event.message,
+        content: [...event.message.content, { type: "text" as const, text: duration }],
+      },
     };
   });
 
-  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.1.4",
+  "version": "0.2.1",
   "description": "Append model-visible durations to slow Pi tool results",
   "type": "module",
   "author": "Mitch Fultz (https://github.com/fitchmultz)",
@@ -40,11 +40,12 @@
     ]
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.80.9",
+    "@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": {