@hk_net/pi-timestamp 0.1.12 → 0.1.13

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.13 - 2026-08-29
+
+### Added
+
+- Split completion timing into total elapsed, active agent, and user-prompt waiting time when an extension UI prompt occurs during an agent run; retain the concise duration when none occurs.
+
+### Changed
+
+- Require Pi 0.84.4 or newer; this is the development, type-compatibility, and test baseline.
+
 ## 0.1.12 - 2026-08-27
 
 ### Changed

package/README.md

@@ -1,11 +1,11 @@
 # pi-timestamp
 
-Shows timestamps for user input and agent completion timing. Requires Pi 0.84.1 or newer (tested with the current Pi 0.84.3 release).
+Shows timestamps for user input and agent completion timing. Requires Pi 0.84.4 or newer.
 
 ## What it does
 
 - **User input**: Shows `Sent HH:MM:SS` as a dim status line in the chat display after each user message
-- **Agent completion**: Shows `Done at HH:MM:SS · duration` as a dim status line in the chat display after each agent turn (e.g., `Done at 14:32:05 · 3.2s`)
+- **Agent completion**: Shows `Done at HH:MM:SS · duration` as a dim status line in the chat display after each agent turn. If an extension UI prompt paused the run, it instead shows total, active-agent, and user-waiting time (e.g., `Done at 14:32:05 · total 8.2s · active 3.2s · waiting 5.0s`).
 - **Session/runtime summaries**: Shows accent-colored summaries when switching sessions and at final Pi exit, including start/end times and durations. The final summary includes the complete Pi process runtime and every session interval.
 
 All timestamps and summaries are **display-only** — session-switch summaries render in Pi's UI and the final runtime summary prints after Pi restores the terminal in TUI mode. They never enter the LLM context.
@@ -31,7 +31,7 @@ cp packages/pi-timestamp/timestamp.ts ~/.pi/agent/extensions/timestamp.ts
 
 ## Duration measurement
 
-Captured from the first `agent_start` to `agent_settled`, so automatic retries, compaction recovery, tool calls, and queued continuations are included in one complete task duration.
+Captured from the first `agent_start` to `agent_settled`, so automatic retries, compaction recovery, tool calls, and queued continuations are included in one complete task duration. When an extension opens a blocking UI prompt during that run, Pi 0.84.4's prompt events subtract that user-wait time from the reported active-agent duration while retaining it in the total.
 
 ## Issues and feedback
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hk_net/pi-timestamp",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Pi extension that shows timestamps for user input and agent completion timing",
   "type": "module",
   "private": false,

package/timestamp.ts

@@ -27,6 +27,19 @@ export interface TimestampRuntimeState {
     pendingSessionSummary: SessionInterval | undefined;
 }
 
+export interface TaskTimingState {
+    startedAt: number | undefined;
+    promptStartedAt: number | undefined;
+    promptDepth: number;
+    waitingForUserMs: number;
+}
+
+export interface CompletedTaskTiming {
+    totalMs: number;
+    activeMs: number;
+    waitingForUserMs: number;
+}
+
 const RUNTIME_STATE_KEY = Symbol.for("hknet.pi-timestamp.runtime-state");
 
 export function createRuntimeState(processStartedAt: number): TimestampRuntimeState {
@@ -67,6 +80,50 @@ export function takePendingSessionSummary(state: TimestampRuntimeState): Session
     return pending;
 }
 
+export function createTaskTimingState(): TaskTimingState {
+    return { startedAt: undefined, promptStartedAt: undefined, promptDepth: 0, waitingForUserMs: 0 };
+}
+
+export function beginTask(state: TaskTimingState, now: number): void {
+    if (state.startedAt !== undefined) return;
+    state.startedAt = now;
+    state.promptStartedAt = undefined;
+    state.promptDepth = 0;
+    state.waitingForUserMs = 0;
+}
+
+export function beginUserPromptWait(state: TaskTimingState, now: number): void {
+    if (state.startedAt === undefined) return;
+    if (state.promptDepth++ === 0) state.promptStartedAt = now;
+}
+
+export function endUserPromptWait(state: TaskTimingState, now: number): void {
+    if (state.promptDepth === 0) return;
+    if (--state.promptDepth !== 0 || state.promptStartedAt === undefined) return;
+    state.waitingForUserMs += Math.max(0, now - state.promptStartedAt);
+    state.promptStartedAt = undefined;
+}
+
+export function finishTask(state: TaskTimingState, now: number): CompletedTaskTiming | undefined {
+    if (state.startedAt === undefined) return undefined;
+    if (state.promptDepth > 0 && state.promptStartedAt !== undefined) {
+        state.waitingForUserMs += Math.max(0, now - state.promptStartedAt);
+        state.promptStartedAt = undefined;
+        state.promptDepth = 0;
+    }
+    const totalMs = Math.max(0, now - state.startedAt);
+    const completed = {
+        totalMs,
+        waitingForUserMs: Math.min(totalMs, state.waitingForUserMs),
+        activeMs: 0,
+    };
+    completed.activeMs = totalMs - completed.waitingForUserMs;
+    state.startedAt = undefined;
+    state.promptDepth = 0;
+    state.waitingForUserMs = 0;
+    return completed;
+}
+
 function formatTime(ts: number): string {
     const d = new Date(ts);
     const hh = String(d.getHours()).padStart(2, "0");
@@ -132,7 +189,7 @@ export function formatRuntimeDuration(ms: number): string {
 }
 
 export default function (pi: ExtensionAPI) {
-    let taskStartTime: number | undefined;
+    const taskTiming = createTaskTimingState();
 
     function notifyAccent(ctx: ExtensionContext, message: string): void {
         ctx.ui.notify(ctx.ui.theme.fg("accent", message), "info");
@@ -141,7 +198,17 @@ export default function (pi: ExtensionAPI) {
     // Track the complete run. Automatic retries and compaction recovery can emit
     // additional agent_start events before agent_settled, so retain the first start.
     pi.on("agent_start", async () => {
-        taskStartTime ??= Date.now();
+        beginTask(taskTiming, Date.now());
+    });
+
+    // Pi coalesces nested UI prompts. Track only prompt spans that overlap an
+    // active agent run, so configuration dialogs while idle do not affect timing.
+    pi.on("ui_prompt_start", async () => {
+        beginUserPromptWait(taskTiming, Date.now());
+    });
+
+    pi.on("ui_prompt_end", async () => {
+        endUserPromptWait(taskTiming, Date.now());
     });
 
     // Show "Sent HH:MM:SS" after each user message.
@@ -159,15 +226,15 @@ export default function (pi: ExtensionAPI) {
     // Show completion timing only after retries, compaction recovery, and queued
     // continuations have fully settled.
     pi.on("agent_settled", async (_event, ctx) => {
-        const startTime = taskStartTime;
-        taskStartTime = undefined;
-
-        if (startTime === undefined) return;
-
         const endTime = Date.now();
-        const duration = endTime - startTime;
-
-        ctx.ui.notify(`Done at ${formatTime(endTime)} · ${formatDuration(duration)}`, "info");
+        const timing = finishTask(taskTiming, endTime);
+        if (!timing) return;
+
+        const total = formatDuration(timing.totalMs);
+        const detail = timing.waitingForUserMs > 0
+            ? ` · active ${formatDuration(timing.activeMs)} · waiting ${formatDuration(timing.waitingForUserMs)}`
+            : "";
+        ctx.ui.notify(`Done at ${formatTime(endTime)} · ${timing.waitingForUserMs > 0 ? `total ${total}` : total}${detail}`, "info");
     });
 
     pi.on("session_start", (_event, ctx) => {