omegon 0.6.0

package/extensions/dashboard/git.ts

@@ -0,0 +1,185 @@
+/**
+ * Git utilities for the dashboard extension.
+ *
+ * Reads local branches from .git/refs/heads/ without shell spawning,
+ * and renders a unicode branch tree for the raised layout.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { visibleWidth } from "@cwilson613/pi-tui";
+import type { Theme } from "@cwilson613/pi-coding-agent";
+
+// Shared ASCII-compat flag — same logic as footer.ts
+const useAscii = (() => {
+  if (process.env["PI_ASCII"] === "1") return true;
+  if (process.env["TERM"] === "dumb") return true;
+  const locale = (process.env["LC_ALL"] ?? process.env["LC_CTYPE"] ?? process.env["LANG"] ?? "").toUpperCase();
+  if (locale && !locale.includes("UTF")) return true;
+  return false;
+})();
+
+const T = useAscii
+  ? { single: "---", fork: "-+-", mid: "+-", last: "+-", ann: "# " }
+  : { single: " ─── ", fork: " ─┬─ ", mid: "├─ ", last: "└─ ", ann: "  ◈ " };
+
+// ── Branch reader ──────────────────────────────────────────────────────────────
+
+/**
+ * Recursively collect branch names from a directory, returning
+ * slash-joined paths relative to the base directory.
+ */
+function collectRefs(dir: string, base: string): string[] {
+  let results: string[] = [];
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const sub = collectRefs(fullPath, base);
+      results = results.concat(sub);
+    } else if (entry.isFile()) {
+      const rel = path.relative(base, fullPath).split(path.sep).join("/");
+      // Exclude HEAD and any name with illegal ref chars
+      // Exclude HEAD and any name with illegal ref chars (spaces, control chars, ~^:?*\[)
+      if (rel !== "HEAD" && !/[\x00-\x20\x7f ~^:?*[\\]/.test(rel)) {
+        results.push(rel);
+      }
+    }
+  }
+  return results;
+}
+
+/**
+ * Sort priority for branch names.
+ * Lower number = earlier in list.
+ */
+function branchPriority(b: string): number {
+  if (b === "main" || b === "master") return 0;
+  if (b.startsWith("feature/")) return 1;
+  if (b.startsWith("refactor/")) return 2;
+  if (b.startsWith("fix/") || b.startsWith("hotfix/")) return 3;
+  return 4;
+}
+
+/**
+ * Read local branches from .git/refs/heads/ without spawning a shell.
+ *
+ * Returns branch names sorted: main/master first, then feature/*, refactor/*,
+ * fix/hotfix, then the rest alphabetically.
+ * Returns [] gracefully if the directory does not exist (detached HEAD, worktree, etc.).
+ */
+export function readLocalBranches(cwd: string): string[] {
+  const headsDir = path.join(cwd, ".git", "refs", "heads");
+  const branches = collectRefs(headsDir, headsDir);
+  branches.sort((a, b) => {
+    const pa = branchPriority(a);
+    const pb = branchPriority(b);
+    if (pa !== pb) return pa - pb;
+    return a.localeCompare(b);
+  });
+  return branches;
+}
+
+// ── Branch tree renderer ───────────────────────────────────────────────────────
+
+export interface BranchTreeParams {
+  repoName: string;
+  currentBranch: string | null;
+  allBranches: string[];
+  designNodes?: Array<{ branches?: string[]; title: string }>;
+}
+
+/**
+ * Style a branch name according to its type and whether it is current.
+ */
+function styledBranch(b: string, isCurrent: boolean, theme: Theme): string {
+  // Use ASCII "*" rather than "●" (U+25CF): the Black Circle glyph is
+  // "ambiguous width" in Unicode East Asian metrics and many terminals
+  // (e.g. iTerm2 on macOS) render it as 2 cells.  pi-tui's visibleWidth()
+  // counts it as 1, causing a 1-char overflow in the top-border of the
+  // raised dashboard box and a TUI crash at exactly-full-width terminals.
+  const label = isCurrent ? "* " + b : b;
+  if (isCurrent) return theme.fg("success", label);
+  if (b.startsWith("feature/")) return theme.fg("accent", b);
+  if (b.startsWith("fix/") || b.startsWith("hotfix/")) return theme.fg("warning", b);
+  if (b.startsWith("refactor/")) return theme.fg("accent", b); // dim accent via same color
+  return theme.fg("muted", b);
+}
+
+/**
+ * Find annotation for a branch from design nodes.
+ */
+function branchAnnotation(
+  b: string,
+  designNodes: Array<{ branches?: string[]; title: string }> | undefined,
+  theme: Theme
+): string {
+  if (!designNodes) return "";
+  const node = designNodes.find((n) => n.branches?.includes(b));
+  if (!node) return "";
+  return "  " + theme.fg("dim", T.ann + node.title);
+}
+
+/**
+ * Build the branch tree lines for the raised layout.
+ *
+ * - 0 branches: [dim(repoName)]
+ * - 1 branch:   repoName + " ─── " + styledBranch
+ * - N branches: repoName + " ─┬─ " + styledBranch(branches[0])
+ *               indent       + "├─ " + styledBranch(branches[i])   (middle)
+ *               indent       + "└─ " + styledBranch(branches[N-1]) (last)
+ *
+ * Current branch is placed first; deduplication ensures it appears only once.
+ */
+export function buildBranchTreeLines(params: BranchTreeParams, theme: Theme): string[] {
+  const { repoName, currentBranch, allBranches, designNodes } = params;
+
+  // Build ordered, deduplicated branch list: current first
+  const ordered: string[] = [];
+  if (currentBranch) {
+    ordered.push(currentBranch);
+  }
+  for (const b of allBranches) {
+    if (!ordered.includes(b)) {
+      ordered.push(b);
+    }
+  }
+
+  if (ordered.length === 0) {
+    return [theme.fg("dim", repoName)];
+  }
+
+  if (ordered.length === 1) {
+    const b = ordered[0]!;
+    const isCurrent = b === currentBranch;
+    const annotation = branchAnnotation(b, designNodes, theme);
+    return [repoName + T.single + styledBranch(b, isCurrent, theme) + annotation];
+  }
+
+  // Multiple branches — indent aligned to just after the fork connector
+  const indentWidth = visibleWidth(repoName + (useAscii ? "-" : " ─"));
+  const indent = " ".repeat(indentWidth);
+
+  const lines: string[] = [];
+  for (let i = 0; i < ordered.length; i++) {
+    const b = ordered[i]!;
+    const isCurrent = b === currentBranch;
+    const styled = styledBranch(b, isCurrent, theme);
+    const annotation = branchAnnotation(b, designNodes, theme);
+
+    if (i === 0) {
+      lines.push(repoName + T.fork + styled + annotation);
+    } else if (i < ordered.length - 1) {
+      lines.push(indent + T.mid + styled + annotation);
+    } else {
+      lines.push(indent + T.last + styled + annotation);
+    }
+  }
+
+  return lines;
+}

package/extensions/dashboard/index.ts

@@ -0,0 +1,478 @@
+/**
+ * dashboard — Unified live dashboard for Design Tree + OpenSpec + Cleave
+ *
+ * Renders a custom footer via setFooter() that supports modes:
+ *   compact:  Dashboard summary + context gauge + original footer data
+ *   raised:   Section details for design tree, openspec, cleave + footer data
+ *   panel:    Non-capturing overlay (visible but doesn't steal input)
+ *   focused:  Interactive overlay with keyboard navigation
+ *
+ * Toggle: ctrl+` or /dashboard command.
+ * Cycle: compact → raised → panel → focused → compact
+ *
+ * Reads sharedState written by producer extensions (design-tree, openspec, cleave).
+ * Subscribes to "dashboard:update" events for live re-rendering.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@cwilson613/pi-coding-agent";
+import type { OverlayHandle } from "@cwilson613/pi-tui";
+import { DASHBOARD_UPDATE_EVENT } from "../shared-state.ts";
+import { getSharedBridge, buildSlashCommandResult } from "../lib/slash-command-bridge.ts";
+import { DashboardFooter } from "./footer.ts";
+import { DashboardOverlay, showDashboardOverlay } from "./overlay.ts";
+import type { DashboardState, DashboardMode } from "./types.ts";
+import { debug } from "../debug.ts";
+
+/** Valid /dashboard subcommands for tab completion (legacy) */
+const DASHBOARD_SUBCOMMANDS = ["compact", "raised", "panel", "focus", "open"];
+
+export default function (pi: ExtensionAPI) {
+  const state: DashboardState = {
+    mode: "compact",
+    turns: 0,
+  };
+
+  let footer: DashboardFooter | null = null;
+  let tui: any = null; // TUI reference for requestRender
+  let unsubscribeEvents: (() => void) | null = null;
+
+  // ── Non-capturing overlay state ─────────────────────────────
+  /** Overlay handle for non-capturing panel (visibility + focus control) */
+  let overlayHandle: OverlayHandle | null = null;
+  /** The done() callback to resolve the custom() promise on permanent close */
+  let overlayDone: ((result: void) => void) | null = null;
+  /** Whether the non-capturing overlay has been created this session */
+  let overlayCreated = false;
+  /** Whether focus should be applied once the handle arrives (handles async creation) */
+  let pendingFocus = false;
+  /** True while the agent is actively streaming — blocks focused overlay to prevent input lockup */
+  let agentRunning = false;
+
+  /**
+   * Restore persisted dashboard mode from session entries.
+   * Panel/focused modes restore to raised (overlay is session-transient).
+   */
+  function restoreMode(ctx: ExtensionContext): void {
+    try {
+      const entries = ctx.sessionManager.getEntries();
+      for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i] as any;
+        if (entry.type === "dashboard-state" && entry.data?.mode) {
+          const saved = entry.data.mode as DashboardMode;
+          // Overlay modes don't persist — fall back to raised
+          state.mode = (saved === "panel" || saved === "focused") ? "raised" : saved;
+          return;
+        }
+      }
+    } catch { /* first session, no entries yet */ }
+  }
+
+  /**
+   * Persist the current mode to the session.
+   */
+  function persistMode(_ctx: ExtensionContext): void {
+    try {
+      // Persist the base mode (panel/focused stored as raised)
+      const persistable = (state.mode === "panel" || state.mode === "focused") ? "raised" : state.mode;
+      pi.appendEntry("dashboard-state", { mode: persistable });
+    } catch { /* session may not support it */ }
+  }
+
+  /**
+   * Update footer context and trigger re-render.
+   */
+  function refresh(ctx: ExtensionContext): void {
+    debug("dashboard", "refresh", {
+      hasFooter: !!footer,
+      hasTui: !!tui,
+      footerType: footer?.constructor?.name,
+    });
+    if (footer) {
+      footer.setContext(ctx);
+    }
+    tui?.requestRender();
+  }
+
+  /**
+   * Show the non-capturing overlay panel.
+   * Creates it on first call, then toggles visibility via setHidden.
+   */
+  function showPanel(ctx: ExtensionContext): void {
+    if (overlayHandle && !overlayHandle.isHidden()) {
+      // Already visible — nothing to do
+      return;
+    }
+
+    if (overlayHandle) {
+      // Was hidden — show it
+      overlayHandle.setHidden(false);
+      tui?.requestRender();
+      return;
+    }
+
+    if (overlayCreated) {
+      // Overlay was created but handle hasn't arrived yet (async), or
+      // was permanently destroyed — don't recreate in same session
+      return;
+    }
+
+    // Create the non-capturing overlay (fire-and-forget — don't await)
+    overlayCreated = true;
+    void ctx.ui.custom<void>(
+      (tuiRef, theme, _kb, done) => {
+        overlayDone = done;
+        const overlay = new DashboardOverlay(tuiRef, theme, () => {
+          // Esc → close the panel entirely
+          hidePanel();
+        });
+        overlay.setEventBus(pi.events);
+        return overlay;
+      },
+      {
+        overlay: true,
+        overlayOptions: {
+          anchor: "right-center",
+          width: "42%",
+          minWidth: 42,
+          maxHeight: "80%",
+          margin: { top: 1, right: 1, bottom: 1 },
+          visible: (termWidth: number) => termWidth >= 80,
+          nonCapturing: true,
+        },
+        onHandle: (handle) => {
+          overlayHandle = handle;
+          // Apply deferred focus if cycleTo("focused") requested it before handle arrived
+          if (pendingFocus) {
+            pendingFocus = false;
+            handle.focus();
+          }
+        },
+      },
+    );
+  }
+
+  /**
+   * Hide the non-capturing overlay without destroying it.
+   */
+  function hidePanel(): void {
+    pendingFocus = false;
+    if (overlayHandle) {
+      if (overlayHandle.isFocused()) {
+        overlayHandle.unfocus();
+      }
+      overlayHandle.setHidden(true);
+    }
+    state.mode = "compact";
+    tui?.requestRender();
+  }
+
+  /**
+   * Focus the non-capturing overlay for interactive keyboard navigation.
+   * Blocked while the agent is streaming — focusing during active output
+   * causes the TUI input loop to deadlock with the render loop.
+   */
+  function focusPanel(): void {
+    if (agentRunning) {
+      // Can't safely capture input while agent is streaming — stay as panel
+      state.mode = "panel";
+      return;
+    }
+    if (overlayHandle && !overlayHandle.isHidden()) {
+      overlayHandle.focus();
+    } else {
+      // Handle not yet available — defer until onHandle fires
+      pendingFocus = true;
+    }
+  }
+
+  /**
+   * Cycle to a specific dashboard mode.
+   */
+  function cycleTo(ctx: ExtensionContext, targetMode: DashboardMode): void {
+    state.mode = targetMode;
+
+    switch (targetMode) {
+      case "compact":
+      case "raised":
+        hidePanel();
+        // hidePanel sets mode to "compact"; override for "raised"
+        state.mode = targetMode;
+        break;
+      case "panel":
+        pendingFocus = false;
+        showPanel(ctx);
+        break;
+      case "focused":
+        showPanel(ctx);
+        focusPanel();
+        break;
+    }
+
+    persistMode(ctx);
+    tui?.requestRender();
+  }
+
+  /**
+   * Toggle between compact and raised (2-state /dash toggle).
+   * Panel modes are closed first and footer returns to compact.
+   */
+  function dashToggle(ctx: ExtensionContext): void {
+    // If panel is open, close it first and go to compact
+    if (state.mode === "panel" || state.mode === "focused") {
+      hidePanel();
+      return;
+    }
+    // 2-state toggle: compact ↔ raised
+    const next = state.mode === "raised" ? "compact" : "raised";
+    cycleTo(ctx, next);
+  }
+
+  /**
+   * Toggle panel on/off. Panel and raised footer are mutually exclusive:
+   * opening the panel collapses the footer to compact and focuses the overlay.
+   */
+  function panelToggle(ctx: ExtensionContext): void {
+    if (state.mode === "panel" || state.mode === "focused") {
+      hidePanel();
+    } else {
+      // Opening panel forces compact footer and focuses overlay for key input
+      state.mode = "compact";
+      cycleTo(ctx, "focused");
+    }
+  }
+
+  // ── Session start: set up the custom footer ──────────────────
+
+  pi.on("session_start", async (_event, ctx) => {
+    debug("dashboard", "session_start:enter", {
+      hasUI: ctx.hasUI,
+      cwd: ctx.cwd,
+      hasSetFooter: typeof ctx.ui?.setFooter === "function",
+    });
+    if (!ctx.hasUI) {
+      debug("dashboard", "session_start:bail", { reason: "no UI" });
+      return;
+    }
+
+    state.turns = 0;
+    overlayHandle = null;
+    overlayDone = null;
+    overlayCreated = false;
+    pendingFocus = false;
+    restoreMode(ctx);
+    debug("dashboard", "session_start:mode", { mode: state.mode });
+
+    // Set the custom footer
+    try {
+      ctx.ui.setFooter((tuiRef, theme, footerData) => {
+        debug("dashboard", "footer:factory:enter", {
+          hasTui: !!tuiRef,
+          hasTheme: !!theme,
+          hasFooterData: !!footerData,
+          themeFgType: typeof theme?.fg,
+        });
+        try {
+          tui = tuiRef;
+          footer = new DashboardFooter(tuiRef, theme, footerData, state);
+          footer.setContext(ctx);
+          debug("dashboard", "footer:factory:ok", {
+            footerType: footer?.constructor?.name,
+            hasRender: typeof footer?.render === "function",
+          });
+          return footer;
+        } catch (factoryErr: any) {
+          debug("dashboard", "footer:factory:ERROR", {
+            error: factoryErr?.message,
+            stack: factoryErr?.stack?.split("\n").slice(0, 5).join(" | "),
+          });
+          throw factoryErr;
+        }
+      });
+      debug("dashboard", "session_start:setFooter:ok");
+    } catch (err: any) {
+      debug("dashboard", "session_start:setFooter:ERROR", {
+        error: err?.message,
+        stack: err?.stack?.split("\n").slice(0, 5).join(" | "),
+      });
+    }
+
+    // Subscribe to dashboard:update events from producer extensions.
+    unsubscribeEvents = pi.events.on(DASHBOARD_UPDATE_EVENT, (_data) => {
+      debug("dashboard", "update-event", _data as Record<string, unknown>);
+      tui?.requestRender();
+    });
+
+    // Deferred initial render
+    queueMicrotask(() => {
+      debug("dashboard", "microtask:render", {
+        tuiSet: !!tui,
+        footerSet: !!footer,
+        footerType: footer?.constructor?.name,
+      });
+      tui?.requestRender();
+    });
+
+    // Non-blocking capability health check — probes Omegon's own runtime deps
+    // (ollama, d2, pandoc, etc.) using the bootstrap DEPS registry.
+    // This is NOT a project linter — it tells the user which Omegon features
+    // won't work in the current environment.
+    setTimeout(async () => {
+      try {
+        const { DEPS } = await import("../bootstrap/deps.ts");
+        const probed = DEPS.filter(d => d.tier === "core" || d.tier === "recommended");
+        const missing = probed.filter(d => !d.check());
+        if (missing.length === 0) return;
+
+        const summary = missing.map(d => d.name).join(", ");
+        const details = missing.map(d => `• ${d.name} — ${d.purpose}`).join("\n");
+        ctx.ui.notify(`Missing Omegon deps: ${summary}`, "info");
+        pi.sendMessage({
+          customType: "guardrail-health-check",
+          content: `[omegon startup check] Missing runtime dependencies: ${summary}.\n\n`
+            + `These Omegon features may not work:\n${details}\n\n`
+            + `Run \`/bootstrap\` to install interactively.`,
+          display: true,
+        });
+      } catch {
+        /* non-fatal */
+      }
+    }, 2000);
+  });
+
+  // ── Session shutdown: cleanup ─────────────────────────────────
+
+  pi.on("session_shutdown", async () => {
+    if (unsubscribeEvents) {
+      unsubscribeEvents();
+      unsubscribeEvents = null;
+    }
+    // Permanently close the non-capturing overlay
+    if (overlayHandle) {
+      overlayHandle.hide();
+      overlayHandle = null;
+    }
+    if (overlayDone) {
+      overlayDone();
+      overlayDone = null;
+    }
+    overlayCreated = false;
+    pendingFocus = false;
+    footer = null;
+    tui = null;
+  });
+
+  // ── Agent running state — guards focused overlay during streaming ─────
+
+  pi.on("before_agent_start", async () => {
+    agentRunning = true;
+    // If focus was pending and agent starts before handle arrived, cancel it
+    pendingFocus = false;
+    // If overlay is currently focused, unfocus to avoid input deadlock
+    if (overlayHandle?.isFocused()) {
+      overlayHandle.unfocus();
+      state.mode = "panel";
+    }
+  });
+
+  // ── Events that trigger re-render ─────────────────────────────
+
+  pi.on("turn_end", async (_event, ctx) => {
+    agentRunning = false;
+    state.turns++;
+    refresh(ctx);
+  });
+
+  pi.on("message_end", async (_event, ctx) => {
+    refresh(ctx);
+  });
+
+  pi.on("tool_execution_end", async (_event, ctx) => {
+    refresh(ctx);
+  });
+
+  // ── Keyboard shortcut: ctrl+` ────────────────────────────────
+  // Cycles through: compact → raised → panel → focused → compact
+
+  pi.registerShortcut("ctrl+`", {
+    description: "Toggle dashboard footer (compact ↔ raised)",
+    handler: (ctx) => {
+      dashToggle(ctx);
+    },
+  });
+
+  // ── Slash commands: /dash and /dashboard ─────────────────────
+  // Registered with the shared bridge as interactive-only (agentCallable: false)
+  // so the agent gets a structured refusal instead of an opaque "not registered" error.
+
+  const bridge = getSharedBridge();
+
+  bridge.register(pi, {
+    name: "dash",
+    description: "Toggle dashboard footer: compact ↔ raised. /dashboard opens the side panel.",
+    bridge: {
+      agentCallable: false,
+      sideEffectClass: "read",
+      summary: "Interactive-only dashboard footer toggle",
+    },
+    structuredExecutor: async (_args, ctx) => {
+      dashToggle(ctx as ExtensionContext);
+      const label = state.mode === "raised" ? "raised" : "compact";
+      return buildSlashCommandResult("dash", [], {
+        ok: true,
+        summary: `Dashboard: ${label}`,
+        humanText: `Dashboard: ${label}`,
+        effects: { sideEffectClass: "read" },
+      });
+    },
+  });
+
+  bridge.register(pi, {
+    name: "dashboard",
+    description: "Toggle dashboard side panel (open/close). Use /dash to raise/lower the footer.",
+    getArgumentCompletions: (prefix) => {
+      const lower = (prefix ?? "").toLowerCase();
+      return DASHBOARD_SUBCOMMANDS
+        .filter(s => s.startsWith(lower))
+        .map(s => ({ label: s, value: s }));
+    },
+    bridge: {
+      agentCallable: false,
+      sideEffectClass: "read",
+      summary: "Interactive-only dashboard panel toggle",
+    },
+    structuredExecutor: async (args, ctx) => {
+      const arg = (args ?? "").trim().toLowerCase();
+      const extCtx = ctx as ExtensionContext;
+
+      if (arg === "open") {
+        state.mode = "raised";
+        persistMode(extCtx);
+        tui?.requestRender();
+        await showDashboardOverlay(extCtx, pi);
+        return buildSlashCommandResult("dashboard", [arg], {
+          ok: true,
+          summary: "Dashboard: raised + panel",
+          humanText: "Dashboard: raised + panel",
+          effects: { sideEffectClass: "read" },
+        });
+      }
+      if (arg === "compact") { cycleTo(extCtx, "compact"); return buildSlashCommandResult("dashboard", [arg], { ok: true, summary: "Dashboard: compact", humanText: "Dashboard: compact", effects: { sideEffectClass: "read" } }); }
+      if (arg === "raised")  { cycleTo(extCtx, "raised");  return buildSlashCommandResult("dashboard", [arg], { ok: true, summary: "Dashboard: raised", humanText: "Dashboard: raised", effects: { sideEffectClass: "read" } }); }
+      if (arg === "panel")   { cycleTo(extCtx, "panel");   return buildSlashCommandResult("dashboard", [arg], { ok: true, summary: "Dashboard: panel", humanText: "Dashboard: panel", effects: { sideEffectClass: "read" } }); }
+      if (arg === "focus")   { cycleTo(extCtx, "focused"); return buildSlashCommandResult("dashboard", [arg], { ok: true, summary: "Dashboard: focused", humanText: "Dashboard: focused", effects: { sideEffectClass: "read" } }); }
+
+      // Default: open blocking full-page operator panel
+      await showDashboardOverlay(extCtx, pi);
+      return buildSlashCommandResult("dashboard", [], {
+        ok: true,
+        summary: "Dashboard: closed",
+        humanText: "Dashboard: closed",
+        effects: { sideEffectClass: "read" },
+      });
+    },
+    interactiveHandler: async (result) => {
+      // The structuredExecutor already performs the toggle; just suppress double notification
+      // since dashToggle/cycleTo/panelToggle already update visual state.
+    },
+  });
+}

package/extensions/dashboard/memory-audit.ts

@@ -0,0 +1,34 @@
+import type { MemoryInjectionMetrics } from "../project-memory/injection-metrics.ts";
+
+export function formatMemoryAuditSummary(
+  metrics: MemoryInjectionMetrics | undefined,
+  opts?: { wide?: boolean },
+): string {
+  if (!metrics) {
+    return "Memory · pending first injection";
+  }
+
+  const wide = opts?.wide ?? false;
+  if (wide) {
+    return [
+      `Memory audit: ${metrics.mode}`,
+      `facts:${metrics.projectFactCount}`,
+      `edges:${metrics.edgeCount}`,
+      `wm:${metrics.workingMemoryFactCount}`,
+      `hits:${metrics.semanticHitCount}`,
+      `ep:${metrics.episodeCount}`,
+      `global:${metrics.globalFactCount}`,
+      `chars:${metrics.payloadChars}`,
+      `~${metrics.estimatedTokens} tok`,
+    ].join(" · ");
+  }
+
+  return [
+    `Memory ${metrics.mode}`,
+    `facts:${metrics.projectFactCount}`,
+    `wm:${metrics.workingMemoryFactCount}`,
+    `ep:${metrics.episodeCount}`,
+    `global:${metrics.globalFactCount}`,
+    `~${metrics.estimatedTokens} tok`,
+  ].join(" · ");
+}