@pi-unipi/footer 0.1.1

package/src/segments/core.ts

@@ -0,0 +1,283 @@
+/**
+ * @pi-unipi/footer — Core segments
+ *
+ * Segment renderers for the core group: model, thinking, path, git,
+ * context_pct, cost, tokens_total, tokens_in, tokens_out, session,
+ * hostname, time.
+ */
+
+import { hostname as osHostname } from "node:os";
+import { basename } from "node:path";
+import type { FooterSegment, FooterSegmentContext, RenderedSegment, SemanticColor } from "../types.js";
+import { applyColor } from "../rendering/theme.js";
+import { getIcon } from "../rendering/icons.js";
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function withIcon(segmentId: string, text: string): string {
+  const icon = getIcon(segmentId);
+  return icon ? `${icon} ${text}` : text;
+}
+
+function formatTokens(n: number): string {
+  if (n < 1000) return n.toString();
+  if (n < 10000) return `${(n / 1000).toFixed(1)}k`;
+  if (n < 1000000) return `${Math.round(n / 1000)}k`;
+  if (n < 10000000) return `${(n / 1000000).toFixed(1)}M`;
+  return `${Math.round(n / 1000000)}M`;
+}
+
+function color(ctx: FooterSegmentContext, semantic: SemanticColor, text: string): string {
+  return applyColor(semantic, text, ctx.theme, ctx.colors);
+}
+
+/** Extract usage stats from piContext */
+interface UsageStats {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+}
+
+function getUsageStats(piContext: unknown): UsageStats {
+  const ctx = piContext as Record<string, unknown> | undefined;
+  if (!ctx) return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+
+  let input = 0, output = 0, cacheRead = 0, cacheWrite = 0, cost = 0;
+  const sessionEvents = (ctx.sessionManager as any)?.getBranch?.() ?? [];
+  for (const e of sessionEvents) {
+    if (!e || typeof e !== "object") continue;
+    if (e.type !== "message") continue;
+    const m = e.message;
+    if (!m || m.role !== "assistant") continue;
+    if (m.stopReason === "error" || m.stopReason === "aborted") continue;
+    input += m.usage?.input ?? 0;
+    output += m.usage?.output ?? 0;
+    cacheRead += m.usage?.cacheRead ?? 0;
+    cacheWrite += m.usage?.cacheWrite ?? 0;
+    cost += m.usage?.cost?.total ?? 0;
+  }
+  return { input, output, cacheRead, cacheWrite, cost };
+}
+
+// ─── Rainbow helpers for xhigh thinking level ───────────────────────────────
+
+/** ANSI 256-color rainbow palette for xhigh thinking level */
+const RAINBOW_COLORS = [
+  "\x1b[38;5;196m", // red
+  "\x1b[38;5;202m", // orange
+  "\x1b[38;5;226m", // yellow
+  "\x1b[38;5;82m",  // green
+  "\x1b[38;5;45m",  // blue
+  "\x1b[38;5;129m", // indigo
+  "\x1b[38;5;171m", // violet
+];
+
+const ANSI_RESET = "\x1b[0m";
+
+/** Apply rainbow coloring to text, cycling through colors per character */
+export function rainbowText(text: string): string {
+  let result = "";
+  let colorIdx = 0;
+  for (const char of text) {
+    if (char === " ") {
+      result += char;
+    } else {
+      result += `${RAINBOW_COLORS[colorIdx % RAINBOW_COLORS.length]}${char}${ANSI_RESET}`;
+      colorIdx++;
+    }
+  }
+  return result;
+}
+
+/** Render a rainbow border line of the given width */
+export function rainbowBorder(width: number): string {
+  let result = "";
+  for (let i = 0; i < width; i++) {
+    result += `${RAINBOW_COLORS[i % RAINBOW_COLORS.length]}─${ANSI_RESET}`;
+  }
+  return result;
+}
+
+/** Get the current thinking level from piContext */
+export function getThinkingLevel(piContext: unknown): string {
+  const piCtx = piContext as Record<string, unknown> | undefined;
+  return typeof piCtx?.getThinkingLevel === "function"
+    ? (piCtx as any).getThinkingLevel()
+    : "off";
+}
+
+// ─── Segment Renderers ──────────────────────────────────────────────────────
+
+function renderModelSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const piCtx = ctx.piContext as Record<string, unknown> | undefined;
+  const model = piCtx?.model as Record<string, unknown> | undefined;
+  let modelName = (model?.name || model?.id || "no-model") as string;
+  if (modelName.startsWith("Claude ")) {
+    modelName = modelName.slice(7);
+  }
+  const content = withIcon("model", modelName);
+  return { content: color(ctx, "model", content), visible: true };
+}
+
+function renderThinkingSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const thinkingLevel = getThinkingLevel(ctx.piContext);
+
+  if (thinkingLevel === "off") return { content: "", visible: false };
+
+  const levelText: Record<string, string> = {
+    minimal: "min", low: "low", medium: "med", high: "high", xhigh: "xhigh",
+  };
+  const label = levelText[thinkingLevel] || thinkingLevel;
+  const icon = getIcon("thinking");
+  const text = `think:${label}`;
+  const content = icon ? `${icon} ${text}` : text;
+
+  // xhigh uses rainbow coloring
+  if (thinkingLevel === "xhigh") {
+    return { content: rainbowText(content), visible: true };
+  }
+
+  let semanticColor: SemanticColor = "thinking";
+  if (thinkingLevel === "minimal") semanticColor = "thinkingMinimal";
+  else if (thinkingLevel === "low") semanticColor = "thinkingLow";
+  else if (thinkingLevel === "medium") semanticColor = "thinkingMedium";
+  else if (thinkingLevel === "high") semanticColor = "thinkingHigh";
+
+  return { content: color(ctx, semanticColor, content), visible: true };
+}
+
+function renderPathSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const piCtx = ctx.piContext as Record<string, unknown> | undefined;
+  const cwd = (piCtx?.cwd as string) || process.cwd();
+  const home = process.env.HOME || process.env.USERPROFILE;
+  let pwd = cwd;
+
+  if (home && pwd.startsWith(home)) {
+    pwd = `~${pwd.slice(home.length)}`;
+  }
+  // For brevity, show basename by default
+  if (pwd.length > 30) {
+    pwd = `…${pwd.slice(-29)}`;
+  }
+
+  const content = withIcon("path", pwd);
+  return { content: color(ctx, "path", content), visible: true };
+}
+
+function renderGitSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const footerData = ctx.footerData as any;
+  const branch = footerData?.getGitBranch?.() ?? null;
+  if (!branch) return { content: "", visible: false };
+
+  const content = withIcon("git", branch);
+  return { content: color(ctx, "git", content), visible: true };
+}
+
+function renderContextPctSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const piCtx = ctx.piContext as Record<string, unknown> | undefined;
+
+  // Use pi's built-in getContextUsage() — handles compaction and cache correctly
+  const contextUsage = typeof (piCtx as any)?.getContextUsage === "function"
+    ? (piCtx as any).getContextUsage()
+    : undefined;
+
+  const model = piCtx?.model as Record<string, unknown> | undefined;
+  const contextWindow = contextUsage?.contextWindow ?? (model?.contextWindow as number) ?? 0;
+  if (!contextWindow) return { content: "", visible: false };
+
+  const pct = contextUsage?.percent;
+  const tokens = contextUsage?.tokens;
+
+  // If percent is null (post-compaction, awaiting next response), show ?%
+  const pctDisplay = pct !== null && pct !== undefined ? pct.toFixed(1) : "?";
+  const text = `${pctDisplay}%/${formatTokens(contextWindow)}`;
+  const content = withIcon("context", text);
+
+  let semanticColor: SemanticColor = "context";
+  if (pct !== null && pct !== undefined) {
+    if (pct > 90) semanticColor = "contextError";
+    else if (pct > 70) semanticColor = "contextWarn";
+  }
+
+  return { content: color(ctx, semanticColor, content), visible: true };
+}
+
+function renderCostSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const piCtx = ctx.piContext as Record<string, unknown> | undefined;
+  const stats = getUsageStats(piCtx);
+  const usingSubscription = piCtx?.model
+    ? (piCtx as any).modelRegistry?.isUsingOAuth?.(piCtx.model) ?? false
+    : false;
+
+  if (!stats.cost && !usingSubscription) return { content: "", visible: false };
+
+  const costDisplay = usingSubscription ? "(sub)" : `$${stats.cost.toFixed(2)}`;
+  return { content: color(ctx, "cost", costDisplay), visible: true };
+}
+
+function renderTokensSegment(variant: "total" | "in" | "out"): (ctx: FooterSegmentContext) => RenderedSegment {
+  return (ctx: FooterSegmentContext) => {
+    const piCtx = ctx.piContext as Record<string, unknown> | undefined;
+    const stats = getUsageStats(piCtx);
+
+    let value: number;
+    let segmentId: string;
+    if (variant === "in") {
+      value = stats.input;
+      segmentId = "tokensIn";
+    } else if (variant === "out") {
+      value = stats.output;
+      segmentId = "tokensOut";
+    } else {
+      value = stats.input + stats.output + stats.cacheRead + stats.cacheWrite;
+      segmentId = "tokens";
+    }
+
+    if (!value) return { content: "", visible: false };
+
+    const content = withIcon(segmentId, formatTokens(value));
+    return { content: color(ctx, "tokens", content), visible: true };
+  };
+}
+
+function renderSessionSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const piCtx = ctx.piContext as Record<string, unknown> | undefined;
+  const sessionId = (piCtx?.sessionManager as any)?.getSessionId?.();
+  const display = sessionId?.slice(0, 8) || "new";
+  const content = withIcon("session", display);
+  return { content: color(ctx, "model", content), visible: true };
+}
+
+function renderHostnameSegment(_ctx: FooterSegmentContext): RenderedSegment {
+  const name = osHostname().split(".")[0];
+  const content = withIcon("hostname", name);
+  return { content, visible: true };
+}
+
+function renderTimeSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const now = new Date();
+  const hours = now.getHours();
+  const mins = now.getMinutes().toString().padStart(2, "0");
+  const timeStr = `${hours}:${mins}`;
+  const content = withIcon("time", timeStr);
+  return { content, visible: true };
+}
+
+// ─── Core segments array ────────────────────────────────────────────────────
+
+export const CORE_SEGMENTS: FooterSegment[] = [
+  { id: "model", label: "Model", icon: "", render: renderModelSegment, defaultShow: true },
+  { id: "thinking", label: "Thinking", icon: "", render: renderThinkingSegment, defaultShow: true },
+  { id: "path", label: "Path", icon: "", render: renderPathSegment, defaultShow: true },
+  { id: "git", label: "Git", icon: "", render: renderGitSegment, defaultShow: true },
+  { id: "context_pct", label: "Context %", icon: "", render: renderContextPctSegment, defaultShow: true },
+  { id: "cost", label: "Cost", icon: "", render: renderCostSegment, defaultShow: true },
+  { id: "tokens_total", label: "Tokens Total", icon: "", render: renderTokensSegment("total"), defaultShow: false },
+  { id: "tokens_in", label: "Tokens In", icon: "", render: renderTokensSegment("in"), defaultShow: false },
+  { id: "tokens_out", label: "Tokens Out", icon: "", render: renderTokensSegment("out"), defaultShow: false },
+  { id: "session", label: "Session", icon: "", render: renderSessionSegment, defaultShow: false },
+  { id: "hostname", label: "Hostname", icon: "", render: renderHostnameSegment, defaultShow: false },
+  { id: "time", label: "Time", icon: "", render: renderTimeSegment, defaultShow: false },
+];

package/src/segments/kanboard.ts

@@ -0,0 +1,75 @@
+/**
+ * @pi-unipi/footer — Kanboard segments
+ *
+ * Segment renderers for the kanboard group: docs_count, tasks_done,
+ * tasks_total, task_pct.
+ * Reads directly from kanboard's parser registry (no events).
+ */
+
+import type { FooterSegment, FooterSegmentContext, RenderedSegment } from "../types.js";
+import { applyColor } from "../rendering/theme.js";
+import { getIcon } from "../rendering/icons.js";
+
+function withIcon(segmentId: string, text: string): string {
+  const icon = getIcon(segmentId);
+  return icon ? `${icon} ${text}` : text;
+}
+
+/**
+ * Try to read kanboard data from globalThis registry.
+ * Kanboard doesn't emit events — it exposes its parser via globalThis.
+ */
+function getKanboardData(): Record<string, unknown> | null {
+  try {
+    const registry = (globalThis as Record<string, unknown>).__unipi_kanboard_registry;
+    if (!registry || typeof registry !== "object") return null;
+    return registry as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+function renderDocsCountSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const kb = getKanboardData();
+  const value = kb?.docsCount;
+  if (value === undefined || value === null) return { content: "", visible: false };
+  const content = withIcon("docsCount", `${value}`);
+  return { content: applyColor("kanboard", content, ctx.theme, ctx.colors), visible: true };
+}
+
+function renderTasksDoneSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const kb = getKanboardData();
+  const value = kb?.tasksDone;
+  if (value === undefined || value === null) return { content: "", visible: false };
+  const content = withIcon("tasksDone", `${value}`);
+  return { content: applyColor("kanboard", content, ctx.theme, ctx.colors), visible: true };
+}
+
+function renderTasksTotalSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const kb = getKanboardData();
+  const value = kb?.tasksTotal;
+  if (value === undefined || value === null) return { content: "", visible: false };
+  const content = withIcon("tasksTotal", `${value}`);
+  return { content: applyColor("kanboard", content, ctx.theme, ctx.colors), visible: true };
+}
+
+function renderTaskPctSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const kb = getKanboardData();
+  const done = kb?.tasksDone as number | undefined;
+  const total = kb?.tasksTotal as number | undefined;
+
+  if (done === undefined || total === undefined || total === 0) {
+    return { content: "", visible: false };
+  }
+
+  const pct = Math.round((done / total) * 100);
+  const content = withIcon("taskPct", `${pct}%`);
+  return { content: applyColor("kanboard", content, ctx.theme, ctx.colors), visible: true };
+}
+
+export const KANBOARD_SEGMENTS: FooterSegment[] = [
+  { id: "docs_count", label: "Docs Count", icon: "", render: renderDocsCountSegment, defaultShow: true },
+  { id: "tasks_done", label: "Tasks Done", icon: "", render: renderTasksDoneSegment, defaultShow: true },
+  { id: "tasks_total", label: "Tasks Total", icon: "", render: renderTasksTotalSegment, defaultShow: true },
+  { id: "task_pct", label: "Task %", icon: "", render: renderTaskPctSegment, defaultShow: true },
+];

package/src/segments/mcp.ts

@@ -0,0 +1,100 @@
+/**
+ * @pi-unipi/footer — MCP segments
+ *
+ * Segment renderers for the MCP group: servers_total, servers_active,
+ * tools_total, servers_failed.
+ *
+ * Data sourced from:
+ * 1. globalThis.__unipi_mcp_stats (if available — direct from MCP registry)
+ * 2. ctx.data aggregate fields maintained by events.ts handlers
+ * 3. Falls back to hidden when no meaningful data is available
+ *
+ * Never shows "—" — segments hide instead of showing placeholder values.
+ */
+
+import type { FooterSegment, FooterSegmentContext, RenderedSegment } from "../types.js";
+import { applyColor } from "../rendering/theme.js";
+import { getIcon } from "../rendering/icons.js";
+
+/** Shape of aggregate MCP stats from globalThis or registry */
+interface McpStats {
+  serversTotal?: number;
+  serversActive?: number;
+  serversFailed?: number;
+  toolsTotal?: number;
+}
+
+/** Shape of the global escape-hatch object */
+interface GlobalMcpStats extends McpStats {}
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __unipi_mcp_stats: GlobalMcpStats | undefined;
+}
+
+function withIcon(segmentId: string, text: string): string {
+  const icon = getIcon(segmentId);
+  return icon ? `${icon} ${text}` : text;
+}
+
+/**
+ * Resolve MCP stats from available sources:
+ * 1. globalThis.__unipi_mcp_stats (direct from MCP registry)
+ * 2. ctx.data aggregate fields (maintained by events.ts)
+ */
+function getMcpStats(ctx: FooterSegmentContext): McpStats {
+  // Source 1: globalThis escape hatch (future: MCP registry may expose this)
+  const global = globalThis.__unipi_mcp_stats;
+  if (global && typeof global === "object") {
+    return global;
+  }
+
+  // Source 2: registry data with aggregate fields
+  const data = ctx.data;
+  if (data && typeof data === "object") {
+    return data as McpStats;
+  }
+
+  return {};
+}
+
+function hasUsefulValue(value: unknown): value is number {
+  return typeof value === "number";
+}
+
+function renderServersTotalSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const stats = getMcpStats(ctx);
+  if (!hasUsefulValue(stats.serversTotal)) return { content: "", visible: false };
+  const content = withIcon("serversTotal", `${stats.serversTotal}`);
+  return { content: applyColor("mcp", content, ctx.theme, ctx.colors), visible: true };
+}
+
+function renderServersActiveSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const stats = getMcpStats(ctx);
+  if (!hasUsefulValue(stats.serversActive)) return { content: "", visible: false };
+  const content = withIcon("serversActive", `${stats.serversActive}`);
+  return { content: applyColor("mcp", content, ctx.theme, ctx.colors), visible: true };
+}
+
+function renderToolsTotalSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const stats = getMcpStats(ctx);
+  if (!hasUsefulValue(stats.toolsTotal)) return { content: "", visible: false };
+  const content = withIcon("toolsTotal", `${stats.toolsTotal}`);
+  return { content: applyColor("mcp", content, ctx.theme, ctx.colors), visible: true };
+}
+
+function renderServersFailedSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const stats = getMcpStats(ctx);
+  if (!hasUsefulValue(stats.serversFailed) || stats.serversFailed === 0) {
+    return { content: "", visible: false };
+  }
+  const content = withIcon("serversFailed", `${stats.serversFailed}`);
+  return { content: applyColor("mcp", content, ctx.theme, ctx.colors), visible: true };
+}
+
+export const MCP_SEGMENTS: FooterSegment[] = [
+  { id: "servers_total", label: "Servers Total", icon: "", render: renderServersTotalSegment, defaultShow: true },
+  { id: "servers_active", label: "Servers Active", icon: "", render: renderServersActiveSegment, defaultShow: true },
+  { id: "tools_total", label: "Tools Total", icon: "", render: renderToolsTotalSegment, defaultShow: true },
+  { id: "servers_failed", label: "Servers Failed", icon: "", render: renderServersFailedSegment, defaultShow: true },
+];

package/src/segments/memory.ts

@@ -0,0 +1,140 @@
+/**
+ * @pi-unipi/footer — Memory segments
+ *
+ * Segment renderers for the memory group: project_count, total_count, consolidations.
+ *
+ * Data sources (in priority order):
+ * 1. `globalThis.__unipi_info_registry` — the info-screen registry exposes a
+ *    memory group with a dataProvider that returns { projectCount: { value }, totalCount: { value } }.
+ *    We read from its cache synchronously via getCachedData("memory").
+ * 2. `ctx.data` — the footer registry cache, populated by MEMORY_STORED/DELETED/CONSOLIDATED
+ *    events. These carry raw event payloads (not aggregate counts), so they are NOT
+ *    used for count segments. They may still carry lastConsolidated info.
+ *
+ * If no data source has aggregate counts available, segments return visible: false
+ * instead of showing a stale "—" placeholder.
+ *
+ * Display format:  76/102 (project/total) — uses  Nerd Font icon
+ */
+
+import type { FooterSegment, FooterSegmentContext, RenderedSegment } from "../types.js";
+import { applyColor } from "../rendering/theme.js";
+import { getIcon } from "../rendering/icons.js";
+
+/** Nerd Font icon for memory:  */
+const MEMORY_ICON = "\uee9c";
+
+/**
+ * Shape of the info-screen memory group data:
+ * { projectCount: { value: string }, totalCount: { value: string }, ... }
+ */
+interface InfoMemoryData {
+  projectCount?: { value: string };
+  totalCount?: { value: string };
+  consolidations?: { value: string };
+  [key: string]: unknown;
+}
+
+/**
+ * Shape of the info-screen registry (subset we use).
+ */
+interface InfoRegistryLike {
+  getCachedData(groupId: string): Record<string, unknown> | null;
+}
+
+/**
+ * Try to read memory stats from the info-screen registry on globalThis.
+ * Returns the cached data for the "memory" group if available.
+ */
+function getInfoRegistryMemoryData(): InfoMemoryData | null {
+  try {
+    const g = globalThis as Record<string, unknown>;
+    const registry = g.__unipi_info_registry;
+    if (!registry || typeof registry !== "object") return null;
+
+    // The info registry exposes getCachedData(groupId) synchronously
+    const getCached = (registry as InfoRegistryLike).getCachedData;
+    if (typeof getCached !== "function") return null;
+
+    const data = getCached.call(registry, "memory");
+    if (!data || typeof data !== "object") return null;
+
+    return data as InfoMemoryData;
+  } catch {
+    return null;
+  }
+}
+
+/** Get project and total counts from info registry */
+function getMemoryCounts(): { project: number | null; total: number | null } {
+  const infoData = getInfoRegistryMemoryData();
+  const projectStr = infoData?.projectCount?.value;
+  const totalStr = infoData?.totalCount?.value;
+  return {
+    project: projectStr !== undefined ? parseInt(projectStr, 10) : null,
+    total: totalStr !== undefined ? parseInt(totalStr, 10) : null,
+  };
+}
+
+function renderProjectCountSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const counts = getMemoryCounts();
+  if (counts.project === null) {
+    return { content: "", visible: false };
+  }
+
+  // Show as 76/102 format when both are available
+  if (counts.total !== null) {
+    const content = `${MEMORY_ICON} ${counts.project}/${counts.total}`;
+    return { content: applyColor("memory", content, ctx.theme, ctx.colors), visible: true };
+  }
+
+  const content = `${MEMORY_ICON} ${counts.project}`;
+  return { content: applyColor("memory", content, ctx.theme, ctx.colors), visible: true };
+}
+
+function renderTotalCountSegment(ctx: FooterSegmentContext): RenderedSegment {
+  // If project_count already shows project/total, this segment is redundant
+  // Only show when project_count isn't showing the combined format
+  const counts = getMemoryCounts();
+  if (counts.total === null) {
+    return { content: "", visible: false };
+  }
+
+  // If both project and total are available, project_count shows the combined view
+  // Only show this as standalone when project count isn't available
+  if (counts.project !== null) {
+    return { content: "", visible: false };
+  }
+
+  const content = `${MEMORY_ICON} ${counts.total}`;
+  return { content: applyColor("memory", content, ctx.theme, ctx.colors), visible: true };
+}
+
+function renderConsolidationsSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const infoData = getInfoRegistryMemoryData();
+
+  // Check for explicit consolidations stat from info registry
+  const consolidationsValue = infoData?.consolidations?.value;
+  if (consolidationsValue !== undefined && consolidationsValue !== null) {
+    const content = `${MEMORY_ICON} cns:${consolidationsValue}`;
+    return { content: applyColor("memory", content, ctx.theme, ctx.colors), visible: true };
+  }
+
+  // Fall back to lastConsolidated from footer event cache (ctx.data)
+  const eventData = ctx.data as Record<string, unknown> | undefined;
+  const lastConsolidated = eventData?.lastConsolidated as Record<string, unknown> | undefined;
+  const count = lastConsolidated?.count;
+
+  if (count === undefined || count === null) {
+    return { content: "", visible: false };
+  }
+
+  const content = `${MEMORY_ICON} cns:${count}`;
+  return { content: applyColor("memory", content, ctx.theme, ctx.colors), visible: true };
+}
+
+export const MEMORY_SEGMENTS: FooterSegment[] = [
+  { id: "project_count", label: "Project Count", icon: "", render: renderProjectCountSegment, defaultShow: true },
+  { id: "total_count", label: "Total Count", icon: "", render: renderTotalCountSegment, defaultShow: true },
+  { id: "consolidations", label: "Consolidations", icon: "", render: renderConsolidationsSegment, defaultShow: false },
+];

package/src/segments/notify.ts

@@ -0,0 +1,50 @@
+/**
+ * @pi-unipi/footer — Notify segments
+ *
+ * Segment renderers for the notify group: platforms_enabled, last_sent.
+ * Data sourced from NOTIFICATION_SENT event via registry cache.
+ */
+
+import type { FooterSegment, FooterSegmentContext, RenderedSegment } from "../types.js";
+import { applyColor } from "../rendering/theme.js";
+import { getIcon } from "../rendering/icons.js";
+
+function withIcon(segmentId: string, text: string): string {
+  const icon = getIcon(segmentId);
+  return icon ? `${icon} ${text}` : text;
+}
+
+function getNotifyData(ctx: FooterSegmentContext): Record<string, unknown> {
+  const data = ctx.data;
+  if (!data || typeof data !== "object") return {};
+  return data as Record<string, unknown>;
+}
+
+function renderPlatformsEnabledSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const data = getNotifyData(ctx);
+  const platforms = data.platforms as string[] | undefined;
+  if (!platforms || platforms.length === 0) return { content: "", visible: false };
+
+  const content = withIcon("platformsEnabled", platforms.join(","));
+  return { content: applyColor("notify", content, ctx.theme, ctx.colors), visible: true };
+}
+
+function renderLastSentSegment(ctx: FooterSegmentContext): RenderedSegment {
+  const data = getNotifyData(ctx);
+  const timestamp = data.timestamp as string | undefined;
+  if (!timestamp) return { content: "", visible: false };
+
+  // Show relative time
+  const sent = new Date(timestamp);
+  const diffMs = Date.now() - sent.getTime();
+  const diffMin = Math.floor(diffMs / 60000);
+  const display = diffMin < 1 ? "just now" : diffMin < 60 ? `${diffMin}m ago` : `${Math.floor(diffMin / 60)}h ago`;
+
+  const content = withIcon("lastSent", display);
+  return { content: applyColor("notify", content, ctx.theme, ctx.colors), visible: true };
+}
+
+export const NOTIFY_SEGMENTS: FooterSegment[] = [
+  { id: "platforms_enabled", label: "Platforms", icon: "", render: renderPlatformsEnabledSegment, defaultShow: true },
+  { id: "last_sent", label: "Last Sent", icon: "", render: renderLastSentSegment, defaultShow: true },
+];