@pi-unipi/footer 3.0.0-alpha.35 → 3.0.0-alpha.36

package/README.md

@@ -63,7 +63,7 @@ Open `/unipi:settings` → **Footer**. The file is `~/.unipi/config/footer/confi
 | `iconStyle` | `nerd` | Icon set: `nerd` (needs a Nerd Font), `emoji` or `text`. |
 | `colorMode` | `auto` | `auto`, `truecolor`, `256` or `none`. The legacy value `mono` loads as `none`. |
 | `rainbow` | `always` | `always` animates the brand (and the whole frame at `xhigh`/`max` thinking); `brand-only` never animates the whole frame; `off` disables the animation. |
-| `processLine` | `true` | Shows the background-task line above the input. |
+| `processLine` | `false` | Shows an extra line above the input that counts background tasks by status. Background tasks live in the ↓ work tray. |
 | `strip.turns` | `true` | Turn and step counters. |
 | `strip.time` | `true` | Model time and tool time. |
 | `strip.speed` | `true` | Average TTFT and tokens per second. |

package/package.json

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

package/src/config.ts

@@ -32,7 +32,10 @@ export const DEFAULT_FOOTER_SETTINGS: FooterSettings = {
   iconStyle: "nerd",
   colorMode: "auto",
   rainbow: "always",
-  processLine: true,
+  // Off by default: bg tasks + subagents live in the ↓ work tray; the only
+  // line above the input is the UNI-221 "Working…" one while wake-capable
+  // work is pending.
+  processLine: false,
   strip: {
     turns: true,
     time: true,
@@ -118,7 +121,7 @@ registerSettings({
           description: "Which frame parts get the animated rainbow.",
           options: ["always", "brand-only", "off"],
         },
-        { key: "processLine", type: "boolean", label: "Background tasks line", description: "The one-liner above the input counting background tasks." },
+        { key: "processLine", type: "boolean", label: "Background tasks line", description: "Extra one-liner above the input counting background tasks by status (off by default — they live in the ↓ work tray)." },
         { key: "strip.turns", type: "boolean", label: "Strip: turns", description: "Turn and step counters in the stats strip." },
         { key: "strip.time", type: "boolean", label: "Strip: time", description: "Model time and tool time in the stats strip." },
         { key: "strip.speed", type: "boolean", label: "Strip: speed", description: "Average time to first token and tokens per second." },

package/src/index.ts

@@ -18,7 +18,18 @@ import {
   FOOTER_COMMANDS,
   getPackageVersion,
   findPackageRoot,
+  pendingWorkLabel,
+  workTrayItemCount,
 } from "@pi-unipi/core";
+
+/** The work tray has something to open with ↓ (hint on the Working line). */
+function trayHasItems(): boolean {
+  try {
+    return workTrayItemCount() > 0;
+  } catch {
+    return false;
+  }
+}
 import { getFooterRegistry, type FooterRegistry } from "./registry/index.js";
 import { loadFooterSettings, saveFooterSettings } from "./config.js";
 import { registerCommands } from "./commands.js";
@@ -26,7 +37,7 @@ import { GlanceEditor } from "./glance-editor.js";
 import type { GlanceStatus } from "./glance-editor.js";
 import { tpsTracker } from "./tps-tracker.js";
 import { publishSharedTps } from "./tps-shared.js";
-import { renderProcessLine, countBgProcesses } from "./process-line.js";
+import { renderProcessLine, countBgProcesses, renderWaitingLine } from "./process-line.js";
 import { lhModeLabel } from "./segments/long-horizon.js";
 import { SessionScanner } from "./session-scan.js";
 import { renderSessionStrip, stripVisibleAtRows } from "./strip.js";
@@ -232,14 +243,63 @@ function setupFooterUI(pi: ExtensionAPI, ctx: ExtensionContext, state: FooterSta
   // 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) => {
+  ctx.ui.setWidget("footer-top", (tui, theme) => {
     state.tuiRef = tui;
+    // UNI-221: animation state for the pending-work working line.
+    let waitingSince: number | undefined;
+    let spinTimer: ReturnType<typeof setInterval> | undefined;
+    const stopSpin = () => {
+      if (spinTimer) clearInterval(spinTimer);
+      spinTimer = undefined;
+    };
     return {
-      dispose() {},
+      dispose() {
+        stopSpin();
+      },
       invalidate() {},
       render(width: number): string[] {
         const settings = loadFooterSettings();
-        if (!state.enabled || !settings.processLine || !state.piContext || width <= 0) return [];
+        if (!state.enabled || !state.piContext || width <= 0) {
+          stopSpin();
+          return [];
+        }
+        // UNI-162 / UNI-221: while pi looks idle but wake-capable work is
+        // still pending (a background subagent, a bg wake, a fusion
+        // handoff) show a working line shaped like pi's own ("⠋ Working… ·
+        // bg: npm test · 12s") — the pane must not read as finished. It is
+        // a status, not part of the bg dots, so it ignores processLine/
+        // strip-hiding settings. It is the only bg/subagent line outside
+        // the ↓ work tray (the tray draws nothing while closed).
+        const ctx = state.piContext as { isIdle?: () => boolean } | undefined;
+        const now = Date.now();
+        const frame = Math.floor(now / 80);
+        const fg = (color: string, text: string) => {
+          try {
+            return (theme as unknown as { fg: (c: string, t: string) => string }).fg(color, text);
+          } catch {
+            return text;
+          }
+        };
+        const waiting = ctx?.isIdle
+          ? renderWaitingLine(width, () => ctx.isIdle!(), {
+              frame,
+              elapsedMs: waitingSince !== undefined ? now - waitingSince : 0,
+              spinner: (t) => fg("accent", t),
+              muted: (t) => fg("muted", t),
+              ...(trayHasItems() ? { hint: "↓ view" } : {}),
+            })
+          : undefined;
+        if (waiting !== undefined) {
+          waitingSince ??= now;
+          if (!spinTimer) {
+            spinTimer = setInterval(() => tui.requestRender(), 80);
+            spinTimer.unref?.();
+          }
+          return [waiting];
+        }
+        waitingSince = undefined;
+        stopSpin();
+        if (!settings.processLine) return [];
         if (!stripVisibleAtRows(terminalRows(tui))) return [];
         return renderProcessLine(width);
       },
@@ -340,6 +400,14 @@ function renderKey(state: FooterState): string {
     state.activeToolCalls,
     bg ? `${bg.running}/${bg.stopped}/${bg.failed}/${bg.done}` : "",
     tpsTracker.getStepCount(),
+    // UNI-221: the pending-work working line appears/disappears with it.
+    (() => {
+      try {
+        return pendingWorkLabel() ?? "";
+      } catch {
+        return "";
+      }
+    })(),
     // Rainbow brand animates with wall time — keep the 1s shimmer when on.
     loadFooterSettings().rainbow !== "off" ? Math.floor(Date.now() / 1000) : "",
   ].join("|");

package/src/process-line.ts

@@ -15,6 +15,7 @@
 
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { getSharedTaskRegistry } from "@pi-unipi/background-tasks";
+import { pendingWorkLabel, WORKING_TITLE } from "@pi-unipi/core";
 
 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
@@ -76,3 +77,61 @@ export function renderProcessLine(width: number): string[] {
   const leftPad = Math.floor((width - w) / 2);
   return [" ".repeat(leftPad) + line];
 }
+
+/** pi's own working spinner frames (pi-tui Loader default). */
+export const WORKING_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export interface WorkingLineStyle {
+  /** Colours the spinner frame (accent). */
+  spinner?: (text: string) => string;
+  /** Colours the detail text (muted). */
+  muted?: (text: string) => string;
+  /** Spinner frame index (animated by the caller). */
+  frame?: number;
+  /** Elapsed ms since the pending work was first seen idle. */
+  elapsedMs?: number;
+  /** Trailing quiet key hint (e.g. "↓ view" when the work tray has items). */
+  hint?: string;
+}
+
+function formatElapsed(ms: number): string {
+  const s = Math.max(0, Math.floor(ms / 1000));
+  if (s < 60) return `${String(s)}s`;
+  const m = Math.floor(s / 60);
+  return `${String(m)}m ${String(s % 60)}s`;
+}
+
+/**
+ * UNI-162 / UNI-221: while pi is idle but a wait source still has a reason
+ * (a background subagent running, a bg task that will wake the agent, a
+ * non-blocking fusion handoff in flight) the pane must not read as finished.
+ * Renders a working line shaped like pi's own ("⠋ Working… · bg: npm test ·
+ * 12s") read straight off the arbiter's wait sources via core's
+ * `pendingWorkLabel()` (whichever package registered the wait source is the
+ * source of truth).
+ *
+ * It is the ONLY bg/subagent line outside the ↓ work tray (the tray draws
+ * nothing while closed; the status-dot one-liner is opt-in `processLine`).
+ *
+ * Returns `undefined` when pi is busy (pi shows its own working line) or
+ * nothing is pending (callers show their normal idle state).
+ */
+export function renderWaitingLine(width: number, isIdle: () => boolean, style: WorkingLineStyle = {}): string | undefined {
+  if (width <= 1) return undefined;
+  let idle: boolean;
+  try {
+    idle = isIdle();
+  } catch {
+    idle = true;
+  }
+  if (!idle) return undefined;
+  const label = pendingWorkLabel();
+  if (label === null) return undefined;
+  const spinner = style.spinner ?? ((t: string) => t);
+  const muted = style.muted ?? ((t: string) => t);
+  const frame = WORKING_FRAMES[Math.abs(style.frame ?? 0) % WORKING_FRAMES.length] ?? WORKING_FRAMES[0];
+  const elapsed = style.elapsedMs !== undefined ? ` · ${formatElapsed(style.elapsedMs)}` : "";
+  const hint = style.hint ? ` · ${style.hint}` : "";
+  const line = ` ${spinner(frame)} ${spinner(WORKING_TITLE)}${muted(` · ${label}${elapsed}${hint}`)}`;
+  return truncateToWidth(line, Math.max(1, width - 1));
+}