@pi-unipi/footer 2.12.0 → 2.13.0

package/README.md

@@ -18,6 +18,7 @@ An experimental input surface, on by default and toggleable in `/unipi:footer-se
 - **Top border:** animated lolcat-gradient UNIPI brand + git branch (turns rainbow-frame animated while thinking is max/xhigh)
 - **Bottom border:** workspace · context %/window · model · thinking level
 - **Session strip:** turns/steps, wall + tool wall time, average TTFT, tok/s, cache hit % — colored per stat, honest across restarts (derived from persisted session timestamps when live hooks are unavailable; provider-reported `usage.output` anchors token counts whenever present)
+- **Process line (new in 2.13):** centered one-liner directly above the frame while background work is in flight — `● 3 running  ● 1 stopped  ● 1 failed  ● 2 done` — green ● running, yellow ● stopped (killed), red ● failed, gray ● done. Covers every task type (shell jobs, delegates, fusion workflows) via direct registry reads; zero-count buckets are omitted and the line hides when idle. Counts reset per session.
 - The classic segment status line is suppressed while glance mode is on; toggle it back for the classic footer
 
 ## Commands

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/footer",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "description": "Persistent status bar for Unipi — subscribes to UNIPI_EVENTS and renders key stats from all unipi packages",
   "type": "module",
   "main": "index.ts",
@@ -32,7 +32,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.12.0"
+    "@pi-unipi/core": "2.12.0",
+    "@pi-unipi/background-tasks": "2.13.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/src/index.ts

@@ -29,6 +29,7 @@ import { STATUS_EXT_SEGMENTS } from "./segments/status-ext.js";
 
 import type { FooterGroup, FooterSegment } from "./types.js";
 import { tpsTracker } from "./tps-tracker.js";
+import { renderProcessLine } from "./process-line.js";
 
 /** All segment groups */
 const ALL_GROUPS: FooterGroup[] = [
@@ -235,12 +236,6 @@ function setupFooterUI(pi: ExtensionAPI, ctx: ExtensionContext, state: FooterSta
             // Branch-derived tool time: pending callId → assistant msg ts.
             const pendingToolCalls = new Map<string, number>();
             let branchToolMs = 0;
-            // Per-assistant-message duration (this assistant ts → next entry
-            // ts): the honest generation+tool window, replaces first-scan
-            // reconstruction for restart tok/s.
-            const recordDurations = new Map<number, number>();
-            let prevEntryTs = 0;
-            let prevAssistantIdx = -1;
             for (const e of events) {
               if (!e || typeof e !== "object") continue;
               if (e.type !== "message") continue;
@@ -249,12 +244,6 @@ function setupFooterUI(pi: ExtensionAPI, ctx: ExtensionContext, state: FooterSta
               // Branch-derived turn/wall accounting: user messages delimit
               // turns; assistant timestamps bound the session wall time.
               const ts = Date.parse((e as any).timestamp ?? "") || 0;
-              // Close the previous assistant's window with this entry's ts.
-              if (prevAssistantIdx >= 0 && ts > 0 && prevEntryTs > 0) {
-                recordDurations.set(prevAssistantIdx, Math.min(ts - prevEntryTs, 600_000));
-                prevAssistantIdx = -1;
-              }
-              if (ts > 0) prevEntryTs = ts;
               if (m.role === "user") {
                 userCount++;
                 continue;
@@ -274,7 +263,6 @@ function setupFooterUI(pi: ExtensionAPI, ctx: ExtensionContext, state: FooterSta
               if (ts > 0) {
                 if (firstAssistantTs === 0 || ts < firstAssistantTs) firstAssistantTs = ts;
                 if (ts > lastAssistantTs) lastAssistantTs = ts;
-                prevAssistantIdx = msgIndex; // close on next entry
               }
               const hasStop = !!m.stopReason;
               // Pass the whole message: completed messages get anchored to
@@ -301,7 +289,11 @@ function setupFooterUI(pi: ExtensionAPI, ctx: ExtensionContext, state: FooterSta
               msgIndex++;
             }
             tpsTracker.syncBranchStats(userCount, msgIndex);
-            if (recordDurations.size > 0) tpsTracker.syncRecordDurations(recordDurations);
+            // NOTE: no per-record duration seeding here on purpose. Timestamps
+            // alone cannot mark stream END — a 'next-entry' delta would include
+            // tool runs + user think-time inside the rate window (the bug that
+            // made 100-tok/s models read ~7 tok/s). AVG now uses only
+            // hook-measured decode windows; see getSessionAvgTps().
             if (lastAssistantTs > firstAssistantTs) {
               tpsTracker.syncWallMs(lastAssistantTs - firstAssistantTs);
             }
@@ -337,9 +329,10 @@ function setupFooterUI(pi: ExtensionAPI, ctx: ExtensionContext, state: FooterSta
     };
   });
 
-  // Top row widget — classic status line (suppressed in glance mode; the
-  // glance frame's top border already shows UNIPI │ branch and the bottom
-  // border shows context/model/thinking, so a segment row would duplicate it)
+  // Top row widget — dual role. Classic mode: status segment line. Glance
+  // mode: the bg-process one-liner, rendered directly above the glance frame
+  // (the frame replaces the editor, so this aboveEditor slot sits right above
+  // the footer); the frame's own borders show branch/context/model/thinking.
   ctx.ui.setWidget("footer-top", (_tui, theme) => {
     // Update the renderer's theme-like
     const themeLike = { fg: (color: string, text: string) => theme.fg(color as any, text) };
@@ -353,8 +346,8 @@ function setupFooterUI(pi: ExtensionAPI, ctx: ExtensionContext, state: FooterSta
       },
       render(width: number): string[] {
         if (!state.enabled || !state.piContext || width <= 0) return [];
-        // Glance mode replaces the classic segment line entirely.
-        if (state.glanceMode) return [];
+        // Glance mode: this slot becomes the bg-process one-liner.
+        if (state.glanceMode) return renderProcessLine(width);
         const layout = state.renderer.computeLayout(width);
         if (!layout.topContent) return [];
 

package/src/process-line.ts

@@ -0,0 +1,74 @@
+/**
+ * @pi-unipi/footer — Background process one-liner
+ *
+ * Glance-mode strip rendered above the footer frame: one colored dot + count
+ * per background-task status. Reads DIRECTLY from the
+ * @pi-unipi/background-tasks shared registry (no events, no polling
+ * channels); re-renders on the footer's existing 1s refresh timer.
+ *
+ * Dot → status mapping:
+ *   green ● running   yellow ● stopped (killed)   red ● failed   gray ● done (completed)
+ *
+ * Buckets with zero count are omitted; with nothing in flight the line is
+ * empty so the footer stays clean.
+ */
+
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { getSharedTaskRegistry } from "@pi-unipi/background-tasks";
+
+const GREEN_DOT = "\x1b[38;5;82m●\x1b[0m"; // running — active work
+const YELLOW_DOT = "\x1b[38;5;220m●\x1b[0m"; // stopped (killed) — needs attention
+const RED_DOT = "\x1b[38;5;196m●\x1b[0m"; // failed — needs attention
+const GRAY_DOT = "\x1b[38;5;245m●\x1b[0m"; // done (completed) — idle info
+
+export interface BgProcessCounts {
+  running: number;
+  stopped: number;
+  failed: number;
+  done: number;
+}
+
+/**
+ * Count background tasks by display status straight from the registry.
+ * Returns null when background-tasks has not published a registry (module
+ * disabled, before first load, or after session shutdown).
+ */
+export function countBgProcesses(): BgProcessCounts | null {
+  try {
+    const tasks = getSharedTaskRegistry()?.allTasks();
+    if (!tasks) return null;
+    const counts: BgProcessCounts = { running: 0, stopped: 0, failed: 0, done: 0 };
+    for (const task of tasks) {
+      if (task.status === "running") counts.running++;
+      else if (task.status === "killed") counts.stopped++;
+      else if (task.status === "failed") counts.failed++;
+      else if (task.status === "completed") counts.done++;
+    }
+    return counts;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Render the centered one-liner for the given terminal width.
+ * Returns [] when there is nothing to show.
+ */
+export function renderProcessLine(width: number): string[] {
+  if (width <= 0) return [];
+  const counts = countBgProcesses();
+  if (!counts) return [];
+
+  const parts: string[] = [];
+  if (counts.running > 0) parts.push(`${GREEN_DOT} ${counts.running} running`);
+  if (counts.stopped > 0) parts.push(`${YELLOW_DOT} ${counts.stopped} stopped`);
+  if (counts.failed > 0) parts.push(`${RED_DOT} ${counts.failed} failed`);
+  if (counts.done > 0) parts.push(`${GRAY_DOT} ${counts.done} done`);
+  if (parts.length === 0) return [];
+
+  const line = parts.join("  ");
+  const w = visibleWidth(line);
+  if (w >= width) return [truncateToWidth(line, width)];
+  const leftPad = Math.floor((width - w) / 2);
+  return [" ".repeat(leftPad) + line];
+}

package/src/tps-tracker.ts

@@ -56,8 +56,16 @@ interface MessageTpsRecord {
 	requestAt: number;
 	/** When OUTPUT GENERATION started (ms). First non-empty delta. */
 	startedAt: number;
+	/** True once a live streaming delta was observed (window is hook-measured). */
+	sawFirstDelta: boolean;
 	/** When generation completed (ms), 0 if still generating. */
 	completedAt: number;
+	/**
+	 * MEASURED output-only decode window (first delta → stream end, ms).
+	 * 0 when never measured — such records are excluded from the session
+	 * average (deepseek-harness rule: unmeasurable steps drop out).
+	 */
+	decodeMs: number;
 	/** Final TPS for this message (once completed). */
 	tps: number;
 }
@@ -141,7 +149,10 @@ function estimateOutputTokens(message: unknown): number {
 			}
 		}
 	}
-	return estimateTokens(String(chars)); // ceil(chars/4) via single call
+	// FIXED: was estimateTokens(String(chars)) — that divided the DIGIT COUNT
+	// of the number (String(8000).length === 4) by 4, collapsing an 8000-char
+	// response into 1 "token". Divide the actual char count instead.
+	return Math.ceil(chars / CHARS_PER_TOKEN);
 }
 
 /**
@@ -202,7 +213,9 @@ export class TpsTracker {
 				anchored: false,
 				requestAt: this.lastTurnStart,
 				startedAt: 0,
+				sawFirstDelta: false,
 				completedAt: 0,
+			decodeMs: 0,
 				tps: 0,
 			});
 		}
@@ -215,7 +228,9 @@ export class TpsTracker {
 			// record inherits the current open-turn start as its TTFT bound.
 			requestAt: this.lastTurnStart,
 			startedAt: 0,
+			sawFirstDelta: false,
 			completedAt: 0,
+			decodeMs: 0,
 			tps: 0,
 		});
 	}
@@ -252,6 +267,7 @@ export class TpsTracker {
 				this.ttftHookSamples += 1;
 			}
 		}
+		record.sawFirstDelta = true; // window becomes hook-measured
 		record.estimatedTokens += deltaContribution(deltaText);
 		record.tokens = record.estimatedTokens;
 	}
@@ -279,10 +295,19 @@ export class TpsTracker {
 			// provider message timestamp so the window is still output-ish.
 			record.startedAt =
 				messageTimestamp(finalMessage) || record.completedAt - 500;
-		}		const durationSec = Math.max(
+		}
+		const durationSec = Math.max(
 			(record.completedAt - record.startedAt) / 1000,
 			0.05,
 		);
+		// decodeMs is the measured output-only window ONLY when live hooks saw
+		// both bounds; scan-reconstructed windows stay 0 → excluded from AVG.
+		if (record.sawFirstDelta && record.startedAt > 0) {
+			const ms = Math.max(1, record.completedAt - record.startedAt);
+			// Guard: a hook-measured window should never be absurdly long —
+			// keep an over-flow safety cap far above any real generation.
+			record.decodeMs = Math.min(ms, 3600_000);
+		}
 		record.tps = record.tokens > 0 ? record.tokens / durationSec : 0;
 		this.totalOutput += record.tokens;
 		this.pendingChars.delete(messageIndex);
@@ -392,7 +417,9 @@ export class TpsTracker {
 					anchored: false,
 					requestAt: this.lastTurnStart,
 					startedAt: 0,
+					sawFirstDelta: false,
 					completedAt: 0,
+			decodeMs: 0,
 					tps: 0,
 				});
 			}
@@ -436,49 +463,33 @@ export class TpsTracker {
 		return 0;
 	}
 
-	/** Session average TPS across completed + current generation windows. */
-	/**
-	 * Honest per-record duration override from branch order: a persisted
-	 * assistant message ended by the time the NEXT entry arrived. Feeding
-	 * these durations replaces first-scan-sighting reconstruction (which made
-	 * every historical message look 10 min long → tok/s ≈ 0).
-	 */
-	syncRecordDurations(durations: Map<number, number>): void {
-		for (const [idx, durMs] of durations) {
-			const r = this.records[idx];
-			if (!r || r.completedAt === 0 || !r.startedAt) continue;
-			const sec = Math.max(0.05, Math.min(durMs / 1000, TpsTracker.MAX_RECORD_DURATION_SEC));
-			// Recompute this record's tps contribution lazily via tokens/duration
-			r.tps = sec > 0 ? r.tokens / sec : r.tps;
-			(r as unknown as { forcedDurationSec?: number }).forcedDurationSec = sec;
-		}
-	}
-
 	/** Session average TPS across completed + current generation windows.
 	 *
-	 * Scan-reconciled OLD messages (after restart/reload) can yield absurd
-	 * durations: startedAt comes from the provider timestamp, completedAt
-	 * from 'first time our scanner saw it' = now — i.e. minutes/hours for a
-	 * message that generated in seconds. Each record's duration is therefore
-	 * clamped to MAX_RECORD_DURATION_SEC before averaging; syncRecordDurations
-	 * supersedes the clamp with real next-entry deltas when available.
+	 * Deepseek-harness contract (projection.ts): throughput =
+	 * Σ decodeTokens ÷ Σ decodeMs, sampled ONLY over steps whose decode
+	 * window was actually measured (first delta → stream end by live hooks).
+	 * Steps without a measured window drop out of the average entirely.
+	 *
+	 * Scan-reconciled OLD messages (after restart/reload) previously entered
+	 * this average with fabricated durations: startedAt from the provider
+	 * timestamp, completedAt from 'when our scanner first saw it' (minutes
+	 * late), or worse a 'next-entry-ts' window that silently includes tool
+	 * runs and user think-time. That made a 100 tok/s model read ~7 tok/s.
+	 * We now honor the same rule as the harness: unmeasurable steps are
+	 * EXCLUDED, never averaged in with invented durations.
 	 */
-	private static readonly MAX_RECORD_DURATION_SEC = 600;
-
 	getSessionAvgTps(): number {
-		const cap = TpsTracker.MAX_RECORD_DURATION_SEC;
 		let totalTokens = 0;
 		let totalDurationSec = 0;
 		for (const r of this.records) {
-			if (r.completedAt > 0 && r.startedAt > 0) {
+			if (r.completedAt > 0 && r.startedAt > 0 && r.decodeMs > 0) {
+				// Measured output-only window (live streaming hooks).
 				totalTokens += r.tokens;
-				// Branch-derived duration wins; fallback reconstructs from
-				// startedAt→completedAt clamped at the cap.
-				const forced = (r as unknown as { forcedDurationSec?: number }).forcedDurationSec;
-				totalDurationSec += forced ?? Math.min((r.completedAt - r.startedAt) / 1000, cap);
+				totalDurationSec += r.decodeMs / 1000;
 			} else if (r.completedAt === 0 && r.startedAt > 0) {
+				// Open generation window: contribute what's elapsed so far.
 				totalTokens += r.tokens;
-				totalDurationSec += Math.min((Date.now() - r.startedAt) / 1000, cap);
+				totalDurationSec += Math.max(0.05, (Date.now() - r.startedAt) / 1000);
 			}
 		}
 		if (totalDurationSec <= 0) return 0;