@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/core/src/tui/progress.ts

@@ -0,0 +1,73 @@
+/**
+ * @pi-unipi/core — progress entries: `◎ Goal  ██████▒░░░░░  ~55%  turn 4/30`.
+ *
+ * Written with `pi.appendEntry`, so they persist in the transcript for the user
+ * but never reach the model (custom entries are outside the LLM context).
+ */
+
+import type { ExtensionAPI, ThemeColor } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, wrapTextWithAnsi, type Component } from "@earendil-works/pi-tui";
+import { type KitTheme, progressBar } from "./kit.js";
+
+export const PROGRESS_ENTRY = "unipi-progress";
+
+export interface ProgressData {
+  /** Leading glyph (◎ goal, ↻ ralph, ▣ kanboard). */
+  icon?: string;
+  label: string;
+  done: number;
+  /** Units in progress right now — rendered as the shaded part. */
+  active: number;
+  total: number;
+  /** Count suffix, e.g. "items", "tasks". Omitted → percent. */
+  unit?: string;
+  /** Estimated by a model rather than counted (prefixes `~`). */
+  estimated?: boolean;
+  detail?: string;
+  summary?: string;
+  color?: ThemeColor;
+}
+
+const BAR_WIDTH = 20;
+
+export function progressLines(t: KitTheme, d: ProgressData, width: number): string[] {
+  const color = d.color ?? "accent";
+  const pct = d.total > 0 ? Math.round((d.done / d.total) * 100) : 0;
+  const count = d.unit ? `${String(d.done)}/${String(d.total)} ${d.unit}` : `${d.estimated ? "~" : ""}${String(pct)}%`;
+  const head = [
+    `${t.fg(color, d.icon ?? "◎")} ${t.bold(d.label)}`,
+    progressBar(t, d.done, d.active, d.total, BAR_WIDTH, color),
+    t.fg("text", count),
+    d.detail ? t.fg("dim", d.detail) : "",
+  ].filter(Boolean).join("  ");
+  const out = [truncateToWidth(head, width)];
+  if (d.summary) {
+    for (const l of wrapTextWithAnsi(t.fg("muted", d.summary.trim()), Math.max(10, width - 2))) out.push(`  ${l}`);
+  }
+  return out;
+}
+
+const registered = new WeakSet<object>();
+
+/** Register the entry renderer once per extension API instance. */
+export function registerProgressRenderer(pi: ExtensionAPI): void {
+  if (registered.has(pi)) return;
+  registered.add(pi);
+  try {
+    pi.registerEntryRenderer<ProgressData>(PROGRESS_ENTRY, (entry, _opts, theme): Component | undefined => {
+      const d = entry.data;
+      if (!d) return undefined;
+      return { invalidate() {}, render: (w: number) => progressLines(theme as KitTheme, d, w) } satisfies Component;
+    });
+  } catch {
+    /* UI-dependent */
+  }
+}
+
+export function appendProgress(pi: ExtensionAPI, data: ProgressData): void {
+  try {
+    pi.appendEntry(PROGRESS_ENTRY, data);
+  } catch {
+    /* session replaced */
+  }
+}

package/packages/core/src/turn/arbiter.ts

@@ -0,0 +1,290 @@
+/**
+ * Turn arbiter — the single `agent_before_settle` decision point.
+ *
+ * Nudge providers (long-horizon owner, kanboard monitor, …) propose at most
+ * one continuation each; wait sources (bg wake, busy sidekick, background
+ * subagent) veto; the handler delivers at most ONE custom_message nudge per
+ * settle and continues the run exactly once.
+ *
+ * Composition semantics (pi 0.99, verified live, docs/plans/2026-09-30-01a0f095.md
+ * Step 0): boundary handlers run in registration order, each awaited; a handler
+ * result's `entries` REPLACES the accumulated array (so the handler must concat
+ * `event.entries` itself) and `continue` is OR-ed. Events queued as followUps
+ * are drained before the boundary, so `pendingMessages` is a defence-only
+ * check; a run aborted with Esc never reaches the boundary at all.
+ *
+ * State lives in a `Symbol.for` global so every package that imports core
+ * shares one arbiter, and the installer is idempotent across reloads.
+ */
+
+import type { AgentBeforeSettleEventResult, CustomMessageEntryDraft, ExtensionAPI, SessionBoundaryDraft } from "@earendil-works/pi-coding-agent";
+
+export interface SettleInfo {
+	outcome: "completed" | "aborted" | "error";
+	pendingMessages: number;
+	/** Text parts of the last assistant message, joined. */
+	lastAssistantText: string;
+	/** Whether the last assistant message carried tool-call parts. */
+	lastAssistantHadToolCalls: boolean;
+	/** Tool calls since the last `agent_start` (counted by the installer). */
+	toolCallsThisRun: number;
+}
+
+export interface Nudge {
+	source: string;
+	priority: number;
+	customType: string;
+	content: string;
+	display: boolean;
+	details?: unknown;
+	/** Called once, only when THIS nudge is the one delivered. */
+	onDelivered?: () => void;
+}
+
+export type SettleDecision =
+	| { kind: "nudge"; source: string; priority: number }
+	| { kind: "none"; reason: "outcome" | "pending" | "continuing" | "wait" | "no-proposal"; detail?: string };
+
+export type NudgeProvider = {
+	source: string;
+	priority: number;
+	propose: (s: SettleInfo) => Nudge | null | Promise<Nudge | null>;
+};
+
+export type WaitSource = { source: string; waiting: () => string | null };
+
+export type SettleDecisionListener = (decision: SettleDecision, info: SettleInfo) => void;
+
+interface ArbiterHolder {
+	/** Keyed by source: re-registering a source replaces it (reload-safe) and keeps its original order. */
+	providers: Map<string, NudgeProvider>;
+	waitSources: Map<string, WaitSource>;
+	listeners: Set<SettleDecisionListener>;
+	installed: boolean;
+	toolCallsThisRun: number;
+	providerTimeoutMs: number;
+}
+
+const KEY = Symbol.for("unipi.turn.arbiter");
+const DEFAULT_PROVIDER_TIMEOUT_MS = 2_000;
+
+function holder(): ArbiterHolder {
+	const g = globalThis as { [KEY]?: ArbiterHolder };
+	g[KEY] ??= {
+		providers: new Map(),
+		waitSources: new Map(),
+		listeners: new Set(),
+		installed: false,
+		toolCallsThisRun: 0,
+		providerTimeoutMs: DEFAULT_PROVIDER_TIMEOUT_MS,
+	};
+	return g[KEY] as ArbiterHolder;
+}
+
+/** Children are the hands, the lead is the voice: no arbiter, no nudges. */
+export function isChildProcess(env: NodeJS.ProcessEnv = process.env): boolean {
+	return env.UNIPI_FUSION_CHILD === "1" || env.UNIPI_SUBAGENT_CHILD === "1" || Boolean(env.UNIPI_KANBOARD_CHILD);
+}
+
+export function registerNudgeProvider(
+	source: string,
+	priority: number,
+	propose: (s: SettleInfo) => Nudge | null | Promise<Nudge | null>,
+): () => void {
+	const h = holder();
+	h.providers.set(source, { source, priority, propose });
+	return () => {
+		const current = h.providers.get(source);
+		if (current?.propose === propose) h.providers.delete(source);
+	};
+}
+
+export function registerWaitSource(source: string, waiting: () => string | null): () => void {
+	const h = holder();
+	h.waitSources.set(source, { source, waiting });
+	return () => {
+		const current = h.waitSources.get(source);
+		if (current?.waiting === waiting) h.waitSources.delete(source);
+	};
+}
+
+export function onSettleDecision(listener: SettleDecisionListener): () => void {
+	const h = holder();
+	h.listeners.add(listener);
+	return () => {
+		h.listeners.delete(listener);
+	};
+}
+
+async function raceTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | null> {
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const timeout = new Promise<null>((resolve) => {
+		timer = setTimeout(() => resolve(null), timeoutMs);
+	});
+	try {
+		return await Promise.race([promise, timeout]);
+	} finally {
+		if (timer !== undefined) clearTimeout(timer);
+	}
+}
+
+/**
+ * Pure decision core of the settle handler (no pi types), exported for tests.
+ * Order matters: outcome → pending (defence only, see Step 0) → already
+ * continuing → wait sources → highest-priority proposal (tie: earliest
+ * registered). Provider throw/timeout counts as no proposal.
+ */
+export async function decideSettle(
+	info: SettleInfo,
+	alreadyContinuing: boolean,
+): Promise<{ decision: SettleDecision; nudge?: Nudge }> {
+	const h = holder();
+	if (info.outcome !== "completed") {
+		return { decision: { kind: "none", reason: "outcome", detail: info.outcome } };
+	}
+	if (info.pendingMessages > 0) {
+		return { decision: { kind: "none", reason: "pending" } };
+	}
+	if (alreadyContinuing) {
+		return { decision: { kind: "none", reason: "continuing" } };
+	}
+	for (const waitSource of h.waitSources.values()) {
+		let reason: string | null = null;
+		try {
+			reason = waitSource.waiting();
+		} catch {
+			reason = null; // a broken wait source never blocks settlement
+		}
+		if (reason !== null) {
+			return { decision: { kind: "none", reason: "wait", detail: `${waitSource.source}: ${reason}` } };
+		}
+	}
+	let best: { nudge: Nudge } | undefined;
+	for (const provider of h.providers.values()) {
+		let nudge: Nudge | null | undefined;
+		try {
+			nudge = await raceTimeout(Promise.resolve(provider.propose(info)), h.providerTimeoutMs);
+		} catch {
+			nudge = null;
+		}
+		if (nudge === null || nudge === undefined) continue;
+		if (best === undefined || nudge.priority > best.nudge.priority) best = { nudge };
+	}
+	if (best === undefined) return { decision: { kind: "none", reason: "no-proposal" } };
+	return {
+		decision: { kind: "nudge", source: best.nudge.source, priority: best.nudge.priority },
+		nudge: best.nudge,
+	};
+}
+
+const TOOL_CALL_PART_TYPES = new Set(["toolCall", "tool_call", "toolUse", "tool_use"]);
+
+interface AssistantSummary {
+	text: string;
+	hadToolCalls: boolean;
+}
+
+function summarizeAssistant(messages: readonly unknown[]): AssistantSummary {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (typeof message !== "object" || message === null) continue;
+		const record = message as Record<string, unknown>;
+		if (record.role !== "assistant") continue;
+		const content = record.content;
+		if (typeof content === "string") return { text: content, hadToolCalls: false };
+		if (!Array.isArray(content)) return { text: "", hadToolCalls: false };
+		let text = "";
+		let hadToolCalls = false;
+		for (const part of content) {
+			if (typeof part !== "object" || part === null) continue;
+			const block = part as Record<string, unknown>;
+			if (block.type === "text" && typeof block.text === "string") text += block.text;
+			else if (block.type !== undefined && TOOL_CALL_PART_TYPES.has(String(block.type))) hadToolCalls = true;
+		}
+		return { text, hadToolCalls };
+	}
+	return { text: "", hadToolCalls: false };
+}
+
+/**
+ * Install the single `agent_before_settle` handler. Idempotent: the first
+ * call wins (holder flag) — later calls, including from long-horizon's
+ * standalone factory, are no-ops. In child processes it registers nothing.
+ */
+export function installArbiter(pi: ExtensionAPI): void {
+	const h = holder();
+	if (h.installed) return;
+	h.installed = true;
+	if (isChildProcess()) return;
+
+	pi.on("agent_start", () => {
+		try {
+			h.toolCallsThisRun = 0;
+		} catch {
+			// Accounting must never abort a turn.
+		}
+	});
+	pi.on("tool_call", () => {
+		try {
+			h.toolCallsThisRun += 1;
+		} catch {
+			// Accounting must never abort a turn.
+		}
+	});
+	pi.on("agent_before_settle", async (event): Promise<AgentBeforeSettleEventResult | undefined> => {
+		try {
+			const settleEvent = event as {
+				outcome?: SettleInfo["outcome"];
+				continue?: boolean;
+				entries?: SessionBoundaryDraft[];
+				context?: { pendingMessages?: unknown[]; contextMessages?: unknown[] };
+			};
+			const assistant = summarizeAssistant(settleEvent.context?.contextMessages ?? []);
+			const info: SettleInfo = {
+				outcome: settleEvent.outcome ?? "completed",
+				pendingMessages: settleEvent.context?.pendingMessages?.length ?? 0,
+				lastAssistantText: assistant.text,
+				lastAssistantHadToolCalls: assistant.hadToolCalls,
+				toolCallsThisRun: h.toolCallsThisRun,
+			};
+			const { decision, nudge } = await decideSettle(info, settleEvent.continue === true);
+			for (const listener of h.listeners) {
+				try {
+					listener(decision, info);
+				} catch {
+					// A broken listener must never break settlement.
+				}
+			}
+			if (decision.kind !== "nudge" || nudge === undefined) return undefined;
+			try {
+				nudge.onDelivered?.();
+			} catch {
+				// Delivery bookkeeping must never abort a turn.
+			}
+			const entry: CustomMessageEntryDraft = {
+				type: "custom_message",
+				customType: nudge.customType,
+				content: nudge.content,
+				display: nudge.display,
+				...(nudge.details !== undefined ? { details: nudge.details } : {}),
+			};
+			// Boundary `entries` are REPLACED by the last handler that returns
+			// them — always carry the accumulated array forward.
+			return { entries: [...(settleEvent.entries ?? []), entry], continue: true };
+		} catch {
+			// The arbiter must never abort a turn.
+			return undefined;
+		}
+	});
+}
+
+/** Test hook: clear every registration and the installed flag. */
+export function resetArbiterForTests(opts?: { providerTimeoutMs?: number }): void {
+	const h = holder();
+	h.providers.clear();
+	h.waitSources.clear();
+	h.listeners.clear();
+	h.installed = false;
+	h.toolCallsThisRun = 0;
+	h.providerTimeoutMs = opts?.providerTimeoutMs ?? DEFAULT_PROVIDER_TIMEOUT_MS;
+}

package/packages/footer/README.md

@@ -37,7 +37,7 @@ Footer subscribes to events from every Unipi package:
 | Group | Events | Segments |
 |-------|--------|----------|
 | core | Pi SDK | model, thinking, path, git, context_pct, cost, tokens, session |
-| compactor | Pi session data + `COMPACTOR_COMPACTED` | session_events, compactions, tokens_saved, compression_ratio |
+| compactor | Pi session data | compactions — `cmp 4× 39k→13k · 3m` (count, tokens before → after, time since the last; hidden until the first) |
 | memory | `MEMORY_STORED`/`DELETED`/`CONSOLIDATED` | project_count, total_count, consolidations |
 | mcp | `MCP_SERVER_STARTED`/`STOPPED`/`ERROR` | servers_total, servers_active, tools_total |
 | ralph | `RALPH_LOOP_START`/`END`/`ITERATION_DONE` | active_loops, total_iterations, loop_status |
@@ -90,9 +90,7 @@ Settings in `~/.pi/agent/settings.json` under `unipi.footer`:
         "compactor": {
           "show": true,
           "segments": {
-            "session_events": true,
-            "compactions": true,
-            "tokens_saved": true
+            "compactions": true
           }
         }
       }
@@ -137,11 +135,11 @@ When `iconStyle` is not set, footer auto-detects Nerd Font support and defaults
 
 ```
 Wide terminal (>120 cols):
-  model | thinking | path | git | context | cost | compactions | tokens_saved | project_count
+  model | thinking | path | git | context | compactions | cost | project_count
 
 Narrow terminal (<120 cols):
   Row 1: model | thinking | path | git | context | cost
-  Row 2: compactions | tokens_saved | project_count | ralph | workflow
+  Row 2: compactions | project_count | ralph | workflow
 ```
 
 ## License

package/packages/footer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/footer",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.21",
   "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.2",
-    "@pi-unipi/background-tasks": "3.0.0-alpha.2"
+    "@pi-unipi/core": "3.0.0-alpha.21",
+    "@pi-unipi/background-tasks": "3.0.0-alpha.21"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",

package/packages/footer/src/glance-editor.ts

@@ -5,12 +5,14 @@
  * subclass CustomEditor, use super.render() ONLY to obtain editor content
  * lines, then compose our own rounded frame. Layout per the v3 design:
  *
- *   ╭─UNIPI │ feat/footer-default-v2 │ ─────────────────────╮
- *   │ Type your prompt here...                              │
+ *   ╭─UNIPI │ feat/footer-default-v2 ─────────────────────╮
+ *     Type your prompt here...
  *   ╰─ unipi ────────── 42%/1.0M │ Claude Opus 4.5 │ thinking:high ╯
  *
  * Top border carries the UNIPI brand + git branch. Bottom border right side
  * carries workspace · context%/window · model · thinking level; left filler.
+ * The body is open-sided: no vertical rails — the rounded corners are the
+ * only frame marks (content keeps its column via a one-space indent).
  * All keybindings/autocomplete/history/paste behavior inherited.
  */
 
@@ -19,6 +21,7 @@ import type { EditorOptions, EditorTheme, TUI } from "@earendil-works/pi-tui";
 import type { KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { getIcon, getResolvedIconStyle } from "./rendering/icons.js";
+import { kanboardGlanceLabel } from "@pi-unipi/core";
 import { lolcatRainbow, paintLolcatGradient } from "./rendering/lolcat.js";
 
 /** Live status injected by the footer extension. */
@@ -41,12 +44,13 @@ export interface GlanceStatus {
 	modelName: string;
 	/** Current thinking level (already "off"-filtered by the provider). */
 	thinkingLevel: string | null;
-	/**
-	 * Active Fusion pair, when selected. When set, the model slot renders
-	 * `Fusion · <lead> <effort> ◆ <sidekick>` — lead lit, sidekick muted —
-	 * and the plain thinking slot is suppressed (efforts are inline).
+	/** Active Fusion pair, when selected. When set, the model slot renders
+	 *  `Fusion · <lead> <effort> ◆ <sidekick>` — lead lit, sidekick muted —
+	 *  and the plain thinking slot is suppressed (efforts are inline).
 	 */
 	fusion: { leadName: string; leadEffort: string; sidekickName: string; sidekickEffort: string; savedUsd?: number; busy?: boolean; leadToolCalls?: number; sidekickToolCalls?: number } | null;
+	/** Kanboard claims/autowork snapshot (null → no `▣` segment). */
+	kanboard: { claims: string[]; autowork: boolean } | null;
 }
 
 const BORDER = {
@@ -196,17 +200,21 @@ export function composeGlanceTitles(
 	branch: string | null,
 	workspace: string,
 	lhMode: string | null = null,
+	kanboard: { claims: string[]; autowork: boolean } | null = null,
 ): { titleParts: string[]; leftTitle: string } {
+	const kanboardLabel = kanboardGlanceLabel(kanboard);
 	const titleParts: string[] = [];
 	if (getResolvedIconStyle() === "text") {
 		titleParts.push(brand);
 		if (lhMode) titleParts.push(`mode:${lhMode}`);
+		if (kanboardLabel) titleParts.push(kanboardLabel.replace(/^▣ /, "kanboard:"));
 		if (branch) titleParts.push(`branch:${branch}`);
 		return { titleParts, leftTitle: ` workspace:${workspace} ` };
 	}
 	const brandIcon = getIcon("model");
 	titleParts.push(`${brandIcon ? brandIcon + " " : ""}${brand}`);
 	if (lhMode) titleParts.push(lhMode);
+	if (kanboardLabel) titleParts.push(kanboardLabel);
 	if (branch) {
 		const gitIcon = getIcon("git");
 		titleParts.push(`${gitIcon ? gitIcon + " " : ""}${branch}`);
@@ -276,7 +284,7 @@ export class GlanceEditor extends CustomEditor {
 		// Brand rendered as an animated lolcat gradient (phase from wall time;
 		// the footer's 1s refresh timer re-renders, so it shimmers each tick).
 		const brand = lolcatRainbow("UNIPI", Date.now() / 1000);
-		const { titleParts, leftTitle } = composeGlanceTitles(brand, st.branch, st.workspace, st.lhMode);
+		const { titleParts, leftTitle } = composeGlanceTitles(brand, st.branch, st.workspace, st.lhMode, st.kanboard);
 		const title = titleParts.join(SEP);
 		const leadRule = `${BORDER.horizontal} `;
 		const titleText = ` ${title}${SEP}`;
@@ -296,10 +304,10 @@ export class GlanceEditor extends CustomEditor {
 			topCluster +
 			border(BORDER.topRight);
 
-		// ── Body rows: │ content │ ──
-		const bodyRows = contentLines.map(row =>
-			border(BORDER.vertical) + padLine(row, inner) + border(BORDER.vertical),
-		);
+		// ── Body rows: open sides — the corner curves are the only frame marks.
+		// One-space indent keeps content in the column it had between the old
+		// rails; no trailing padding (rows may end short of the frame width).
+		const bodyRows = contentLines.map(row => " " + truncateToWidth(row, inner, ""));
 
 		// ── Bottom frame: ╰─ unipi ─────── [RIGHT CLUSTER] ─╯ ──
 		// Right cluster: workspace · pct%/window │ model │ thinking:level

package/packages/footer/src/help.ts

@@ -75,7 +75,7 @@ function buildHelpLines(
 export function getGroupForSegment(segId: string): string {
   const coreIds = ["model", "api_state", "tool_count", "git", "context_pct", "cost", "tokens_total", "tokens_in", "tokens_out", "session", "hostname", "time", "tps", "clock", "duration", "thinking_level", "uni", "directory"];
   if (coreIds.includes(segId)) return "core";
-  const compactorIds = ["session_events", "compactions", "tokens_saved", "compression_ratio", "sandbox_runs", "search_queries"];
+  const compactorIds = ["compactions"];
   if (compactorIds.includes(segId)) return "compactor";
   if (["project_count", "total_count", "consolidations"].includes(segId)) return "memory";
   if (["servers_total", "servers_active", "tools_total", "servers_failed"].includes(segId)) return "mcp";

package/packages/footer/src/index.ts

@@ -7,7 +7,7 @@
 
 import type { ExtensionAPI, Theme, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { UNIPI_EVENTS, emitEvent, UNIPI_PREFIX, FOOTER_COMMANDS, getSharedFusionStatus, getSharedLongHorizonMode, getSharedPlanPermissionStatus } from "@pi-unipi/core";
+import { UNIPI_EVENTS, emitEvent, UNIPI_PREFIX, FOOTER_COMMANDS, getSharedFusionStatus, getSharedKanboardStatus, getSharedLongHorizonMode, getSharedPlanPermissionStatus } from "@pi-unipi/core";
 import { FooterRegistry, getFooterRegistry } from "./registry/index.js";
 import { FooterRenderer } from "./rendering/renderer.js";
 import { subscribeToEvents } from "./events.js";
@@ -18,7 +18,7 @@ import { GlanceEditor } from "./glance-editor.js";
 
 // Import segment groups
 import { CORE_SEGMENTS } from "./segments/core.js";
-import { COMPACTOR_SEGMENTS } from "./segments/compactor.js";
+import { COMPACTOR_SEGMENTS, compactionSummary } from "./segments/compactor.js";
 import { MEMORY_SEGMENTS } from "./segments/memory.js";
 import { MCP_SEGMENTS } from "./segments/mcp.js";
 import { RALPH_SEGMENTS } from "./segments/ralph.js";
@@ -448,6 +448,7 @@ function installGlanceEditor(
         const lhMode = typeof lhModeRaw === "string" && lhModeRaw.length > 0
           ? MODE_LABELS[lhModeRaw] ?? lhModeRaw
           : null;
+        const kanboard = getSharedKanboardStatus() ?? null;
         // Plan/permission state rides the same CORE registry data, written by
         // the workflow module's events (also re-emitted on session_start).
         const coreData = st.registry.getGroupData("core") as
@@ -470,6 +471,7 @@ function installGlanceEditor(
           modelName,
           thinkingLevel: typeof p?.thinkingLevel === "string" ? p.thinkingLevel : null,
           fusion,
+          kanboard,
         };
       }),
     );
@@ -546,14 +548,30 @@ const STRIP_COLOR = {
 	psMid: "\x1b[97m", // white — in between
 	cacheHit: "\x1b[92m", // green — high hit
 	cacheWarn: "\x1b[93m", // amber — lowish hit
+	compact: "\x1b[94m", // blue — compactions
 	reset: "\x1b[39m",
 } as const;
 
 const c = (code: string, text: string) => `${code}${text}${STRIP_COLOR.reset}`;
 
+function fmtTokensShort(n: number): string {
+  if (n < 1000) return String(n);
+  if (n < 10000) return `${(n / 1000).toFixed(1)}k`;
+  if (n < 1000000) return `${Math.round(n / 1000)}k`;
+  return `${(n / 1000000).toFixed(1)}M`;
+}
+
+function agoShort(ms: number): string {
+  const sec = Math.max(0, Math.round(ms / 1000));
+  if (sec < 60) return "just now";
+  if (sec < 3600) return `${Math.round(sec / 60)}m ago`;
+  if (sec < 86400) return `${Math.round(sec / 3600)}h ago`;
+  return `${Math.round(sec / 86400)}d ago`;
+}
+
 /**
  * Glance-style centered stats strip under the input:
- *   n Turn · n Steps | wall · tool wall | avg TTFT · n tok/s | cache n%
+ *   n Turn · n Steps | wall · tool wall | avg TTFT · n tok/s | n compactions · 39k→13k · 3m ago | cache n%
  */
 function renderSessionStrip(piContext: unknown): string | null {
   const parts: string[] = [];
@@ -588,6 +606,21 @@ function renderSessionStrip(piContext: unknown): string | null {
     if (seg) parts.push(seg);
   }
 
+  // Compactions: hidden until the first one.
+  const branch = (() => {
+    try {
+      return ((piContext as any)?.sessionManager?.getBranch?.() ?? []) as unknown[];
+    } catch {
+      return [];
+    }
+  })();
+  const cmp = compactionSummary(branch);
+  if (cmp.count > 0) {
+    const sizes = cmp.before > 0 ? ` \u00b7 ${c(STRIP_COLOR.compact, `${fmtTokensShort(cmp.before)}\u2192${fmtTokensShort(cmp.after)}`)}` : "";
+    const age = cmp.lastAt != null ? ` \u00b7 ${agoShort(Date.now() - cmp.lastAt)}` : "";
+    parts.push(`${c(STRIP_COLOR.compact, String(cmp.count))} compaction${cmp.count === 1 ? "" : "s"}${sizes}${age}`);
+  }
+
   const hit = cacheHitPct(piContext);
   if (hit !== null) {
     const hitColor = hit >= 70 ? STRIP_COLOR.cacheHit : STRIP_COLOR.cacheWarn;

package/packages/footer/src/presets.ts

@@ -18,7 +18,7 @@ const DEFAULT_PRESET: PresetDef = {
     "uni", "lh_mode", "model", "thinking_level", "directory", "git",
   ],
   rightSegments: [
-    "context_pct", "tokens_total",
+    "context_pct", "compactions", "tokens_total",
     "tps", "cost",
     "clock", "duration",
   ],
@@ -33,7 +33,7 @@ const CLASSIC_PRESET: PresetDef = {
   ],
   rightSegments: [
     "tps", "context_pct", "cost",
-    "compactions", "tokens_saved", "project_count",
+    "compactions", "project_count",
     "current_command", "loop_status", "extension_statuses",
     "clock", "duration",
   ],
@@ -76,7 +76,7 @@ const FULL_PRESET: PresetDef = {
   ],
   rightSegments: [
     "tps", "context_pct", "cost", "tokens_total",
-    "session_events", "compactions", "tokens_saved",
+    "compactions",
     "project_count", "total_count",
     "servers_total", "servers_active", "tools_total",
     "active_loops", "loop_status",
@@ -87,7 +87,6 @@ const FULL_PRESET: PresetDef = {
   secondarySegments: [
     "hostname",
     "tokens_in", "tokens_out",
-    "compression_ratio",
     "platforms_enabled", "last_sent",
     "thinking_level",
   ],