@pellux/goodvibes-tui 1.16.1 → 1.18.0

package/src/panels/notifications-panel.ts

@@ -0,0 +1,160 @@
+/**
+ * NotificationsPanel — the visible home for notifications routed to the
+ * `panel_only` target (see notifications-feed.ts for why this exists).
+ *
+ * Renders every entry the feed has accumulated: standalone panel-routed
+ * notifications, and collapsed burst/batch groups shown honestly with their
+ * real running count and the plain-language reason they were held back from
+ * the conversation. Descriptive text (titles, bodies, reason descriptions)
+ * is always wrapped in full — never clipped to a column width.
+ */
+import type { Line } from '../types/grid.ts';
+import type { RoutingDecision } from '@/runtime/index.ts';
+import { BasePanel } from './base-panel.ts';
+import {
+  buildEmptyState,
+  buildKeyboardHints,
+  buildPanelWorkspace,
+  buildStyledPanelLine,
+  DEFAULT_PANEL_PALETTE,
+  resolveScrollablePanelSection,
+} from './polish.ts';
+import { wrapText } from '../utils/terminal-width.ts';
+import { getSharedNotificationFeed, type PanelFeedEntry, type PanelNotificationFeed } from './notifications-feed.ts';
+
+// Reuses the shared, mode-aware (dark/light) panel palette's existing
+// bad/warn/info/dim tokens rather than minting new hex literals — this
+// panel has no color needs the shared palette doesn't already name.
+const C = DEFAULT_PANEL_PALETTE;
+
+/** Plain-language description of why a notification never reached the conversation or status bar. Every reason code is covered so a new one fails visibly (a TypeScript error on this object) rather than silently. */
+const REASON_DESCRIPTIONS: Record<RoutingDecision['reasonCode'], string> = {
+  allowed: 'routed here by domain verbosity',
+  quiet_while_typing: 'held while you were typing',
+  mode_context_minimal: 'held back by quiet mode',
+  mode_context_normal: 'held back by balanced mode',
+  burst_collapsed: 'rapid repeats collapsed',
+  batch_window_collapsed: 'repeated within a few seconds, collapsed',
+  domain_verbosity_low: "below this domain's verbosity setting",
+};
+
+function levelColor(level: PanelFeedEntry['level']): string {
+  switch (level) {
+    case 'critical': return C.bad;
+    case 'warning': return C.warn;
+    case 'debug': return C.dim;
+    default: return C.info;
+  }
+}
+
+function levelTag(level: PanelFeedEntry['level']): string {
+  return `[${level}]`;
+}
+
+/** Build every Line an entry needs — title/meta row, then the full body and reason text wrapped with no line cap (descriptive text is never clipped). */
+function renderEntry(entry: PanelFeedEntry, width: number): Line[] {
+  const lines: Line[] = [];
+  const fg = levelColor(entry.level);
+  const countSuffix = entry.collapsedCount > 1 ? ` ×${entry.collapsedCount}` : '';
+  const headerText = `${levelTag(entry.level)} ${entry.domain} — ${entry.title}${countSuffix}`;
+  for (const wrapped of wrapText(headerText, Math.max(1, width - 1))) {
+    lines.push(buildStyledPanelLine(width, [{ text: ` ${wrapped}`, fg, bold: true }]));
+  }
+  const reasonText = entry.collapsedCount > 1
+    ? `  ${entry.collapsedCount} notifications collapsed — ${REASON_DESCRIPTIONS[entry.reasonCode]}`
+    : `  ${REASON_DESCRIPTIONS[entry.reasonCode]}`;
+  for (const wrapped of wrapText(reasonText, Math.max(1, width - 1))) {
+    lines.push(buildStyledPanelLine(width, [{ text: ` ${wrapped}`, fg: C.dim }]));
+  }
+  if (entry.body) {
+    for (const wrapped of wrapText(`  ${entry.body}`, Math.max(1, width - 1))) {
+      lines.push(buildStyledPanelLine(width, [{ text: ` ${wrapped}`, fg: C.value }]));
+    }
+  }
+  return lines;
+}
+
+export class NotificationsPanel extends BasePanel {
+  private readonly unsubscribe: () => void;
+  private scrollOffset = 0;
+
+  constructor(private readonly feed: PanelNotificationFeed = getSharedNotificationFeed()) {
+    super('notifications', 'Notifications', 'N', 'runtime-ops');
+    this.unsubscribe = this.feed.subscribe(() => this.markDirty());
+  }
+
+  override onDestroy(): void {
+    this.unsubscribe();
+    super.onDestroy();
+  }
+
+  handleInput(key: string): boolean {
+    switch (key) {
+      case 'up': return this.scroll(-1);
+      case 'down': return this.scroll(1);
+      case 'pageup': return this.scroll(-10);
+      case 'pagedown': return this.scroll(10);
+      default: return false;
+    }
+  }
+
+  private scroll(delta: number): boolean {
+    const entries = this.feed.list();
+    if (entries.length <= 1) return false;
+    const maxOffset = Math.max(0, entries.length - 1);
+    const prev = this.scrollOffset;
+    this.scrollOffset = Math.max(0, Math.min(maxOffset, this.scrollOffset + delta));
+    if (this.scrollOffset !== prev) this.markDirty();
+    return true;
+  }
+
+  render(width: number, height: number): Line[] {
+    if (width <= 0 || height <= 0) return [];
+    const entries = this.feed.list();
+    const hintRow = buildKeyboardHints(width, [
+      { keys: 'Up/Down', label: 'scroll' },
+      { keys: 'PgUp/PgDn', label: 'page' },
+    ], DEFAULT_PANEL_PALETTE);
+
+    if (entries.length === 0) {
+      return buildPanelWorkspace(width, height, {
+        title: ' Notifications',
+        intro: 'Notifications held back from the conversation or status bar (panel_only) land here, including their real collapsed counts.',
+        sections: [{
+          lines: buildEmptyState(
+            width,
+            ' No panel-routed notifications yet',
+            'Nothing has been routed here this session. Quiet/balanced-mode operational chatter and collapsed bursts will appear here honestly, with their real counts, once something routes to this target.',
+            [],
+            DEFAULT_PANEL_PALETTE,
+          ),
+        }],
+        footerLines: [hintRow],
+        palette: DEFAULT_PANEL_PALETTE,
+      });
+    }
+
+    const scrollableLines = entries.flatMap((entry) => renderEntry(entry, width - 2));
+    const section = resolveScrollablePanelSection(width, height, {
+      intro: 'Notifications held back from the conversation or status bar (panel_only) land here, including their real collapsed counts.',
+      footerLines: [hintRow],
+      palette: DEFAULT_PANEL_PALETTE,
+      section: {
+        title: `Notifications (${entries.length})`,
+        scrollableLines,
+        scrollOffset: this.scrollOffset,
+        minRows: 4,
+        appendWindowSummary: scrollableLines.length > 0 ? { dimColor: DEFAULT_PANEL_PALETTE.dim } : undefined,
+      },
+    });
+    this.scrollOffset = section.scrollOffset;
+
+    return buildPanelWorkspace(width, height, {
+      title: ' Notifications',
+      intro: 'Notifications held back from the conversation or status bar (panel_only) land here, including their real collapsed counts.',
+      sections: [section.section],
+      footerLines: [hintRow],
+      palette: DEFAULT_PANEL_PALETTE,
+    });
+  }
+}

package/src/panels/panel-manager.ts

@@ -34,18 +34,18 @@ export interface WorkspaceTab {
 export class PanelManager {
   private registry: PanelRegistration[] = [];
   private retainedPanels = new Map<string, Panel>();
-  /** Old/absorbed panel id -> merged target id (WO-1xx console merges). */
+  /** Old/absorbed panel id -> merged target id (from the console panel merges). */
   private aliases = new Map<string, string>();
   /**
-   * Retired panel id -> modal name (W6.1 purge, MIGRATE-TO-MODAL surfaces).
+   * Retired panel id -> modal name (panels migrated to config-modal surfaces).
    * Unlike `aliases` (panel -> panel), a hit here means no panel is ever
    * constructed for this id — `open()` invokes `openModalCallback` instead
-   * and returns a sentinel. Registrations are added by WO-A/B; this map and
-   * the open()-time check are WO-C's mechanism only.
+   * and returns a sentinel. This map and the open()-time check are the
+   * sole mechanism for that redirect.
    */
   private modalRedirects = new Map<string, string>();
   /**
-   * Modal name -> the surface the config-modal host renders (W6.1). Built once
+   * Modal name -> the surface the config-modal host renders. Built once
    * in builtin-modals.ts (closing over read-models) and looked up by
    * ui-openers' openModal callback. Distinct from `modalRedirects` (panel id ->
    * modal name): a redirect resolves a legacy panel id to a name; this map
@@ -100,7 +100,7 @@ export class PanelManager {
 
   registerType(registration: PanelRegistration): void {
     const existing = this.registry.findIndex(r => r.id === registration.id);
-    // WO-152: registry-time icon-uniqueness assertion. Tab-bar icons are a
+    // registry-time icon-uniqueness assertion. Tab-bar icons are a
     // single glyph; two panels sharing one silently made the workspace tab
     // strip ambiguous (the historical W/R/U/K/M/Q/Y/J/P collisions). Compare
     // against every OTHER registration (excluding a re-registration of the
@@ -276,7 +276,7 @@ export class PanelManager {
   }
 
   /**
-   * Hand an optional deep-link target (DEBT-5 item 4) to a panel that just
+   * Hand an optional deep-link target (item 4) to a panel that just
    * resolved from open(). Panels without a "node" concept simply don't
    * implement `receiveDeepLink` — the call is a no-op via optional chaining.
    */
@@ -496,7 +496,7 @@ export class PanelManager {
           this.bottomPane.panels.push(panel);
           this.bottomPane.activeIndex = 0;
         } else {
-          // Open a predictable default panel in the bottom pane. W6.1 purge:
+          // Open a predictable default panel in the bottom pane. purge:
           // 'panel-list' was deleted (dead weight over a 5-panel registry —
           // see the DELETE disposition), so the default is explicitly
           // 'fleet' rather than falling back to registry[0] (whatever
@@ -606,7 +606,7 @@ export class PanelManager {
   toggle(): void {
     this._visible = !this._visible;
     // Auto-open a default panel if toggling visible with nothing open.
-    // W6.1 purge: explicitly 'fleet' rather than registry[0] — see the
+    // purge: explicitly 'fleet' rather than registry[0] — see the
     // matching comment in toggleBottomPane() above.
     if (this._visible && this.topPane.panels.length === 0 && this.bottomPane.panels.length === 0) {
       const defaultPanel = this._getRegistration('fleet') ?? this.registry[0];

package/src/panels/plugins-panel.ts

@@ -21,11 +21,11 @@ import {
 } from './polish.ts';
 
 // Base chrome only — title band, state colors, and text tokens all come
-// straight from DEFAULT_PANEL_PALETTE (WO-002).
+// straight from DEFAULT_PANEL_PALETTE.
 const C = DEFAULT_PANEL_PALETTE;
 
 /**
- * WO-134: PluginsPanel drives real plugin-manager mutations (enable/disable/
+ * PluginsPanel drives real plugin-manager mutations (enable/disable/
  * verify/lift-quarantine) from the keyboard, not just read-only inspection.
  * `PluginManagerObserver` alone (the read-only surface most panels need) has
  * no mutation methods, so the constructor param is widened to also require
@@ -87,7 +87,7 @@ export class PluginsPanel extends ScrollableListPanel<PluginStatus> {
       || plugin.version.toLowerCase().includes(q);
   }
 
-  // WO-134: selection is preserved across onActivate — BasePanel's default
+  // selection is preserved across onActivate — BasePanel's default
   // (mark dirty, no index reset) is exactly what we want, so no override.
 
   public override onDestroy(): void {
@@ -149,7 +149,7 @@ export class PluginsPanel extends ScrollableListPanel<PluginStatus> {
   }
 
   /**
-   * WO-134: optional one-key capture-to-memory for a quarantined plugin — 'm'
+   * optional one-key capture-to-memory for a quarantined plugin — 'm'
    * dispatches `/recall capture plugin <name>` (recall-capture.ts:146 pattern)
    * instead of requiring the operator to type the command by hand.
    */

package/src/panels/project-planning-answer-actions.ts

@@ -37,7 +37,7 @@ function compactAnswerDetail(text: string): string {
  * recommendedAnswer echoing one of the scope answers verbatim, must not show
  * the same suggested answer twice), then the fixed ask-narrower/custom actions.
  *
- * DEBT-3: dismissing planning is no longer a pseudo answer-row — it is a
+ * dismissing planning is no longer a pseudo answer-row — it is a
  * first-class confirmed modal action (the `d` key), so no dismiss row is
  * produced here. A canned answer records against the current open question via
  * /plan answer; the custom row's free-form text is submitted to chat.

package/src/panels/provider-health-routes.ts

@@ -1,7 +1,7 @@
 // ---------------------------------------------------------------------------
 // provider-health-routes.ts
 //
-// Single-source auth-route posture for the provider console (WO-112 merge of
+// Single-source auth-route posture for the provider console (merge of
 // the retired accounts panel into provider-health). All route data flows from
 // ProviderRuntimeInspectionQuery.inspectAll() snapshots; this module only
 // normalizes descriptors (synthesizing them for providers that do not declare
@@ -137,7 +137,7 @@ function pickRoute(
 /**
  * Derive the console's account/auth posture for one inspectAll() snapshot.
  * This is the only route-posture derivation in the TUI (the retired accounts
- * panel's parallel snapshot model was deleted with WO-112).
+ * panel's parallel snapshot model was deleted with).
  */
 export function buildAccountPosture(snapshot: ProviderRuntimeSnapshotLike): ProviderAccountPosture {
   const auth = snapshot.runtime.auth;

package/src/panels/skills-panel.ts

@@ -259,7 +259,7 @@ export class SkillsPanel extends ScrollableListPanel<SkillRecord> {
   public constructor(options: SkillsPanelOptions) {
     super('skills', 'Skills', '▩', 'automation-control', options.componentHealthMonitor);
     this.showSelectionGutter = true; // I5: non-color selection affordance
-    this.filterEnabled = true; // WO-153: converged modal '/' filter
+    this.filterEnabled = true; // converged modal '/' filter
     this.filterLabel = 'Filter';
     this.shellPaths = options.shellPaths;
     this.ecosystemPaths = options.ecosystemPaths;
@@ -367,12 +367,12 @@ export class SkillsPanel extends ScrollableListPanel<SkillRecord> {
 
   public override onDestroy(): void {}
 
-  // W6.1 (the purge): Enter used to open the skill's markdown source in the
+  // (the purge): Enter used to open the skill's markdown source in the
   // preview panel via a staged pendingOpenPreview flag + handlePanelIntegrationAction
   // (same pattern diff-panel.ts used). 'preview' is DELETE-disposition with no
   // successor surface (no file-picker-overlay preview to repoint to either —
   // verified), so that cross-panel jump was removed rather than repointed;
-  // Enter is currently a no-op on this list (browse-only until WO-B migrates
+  // Enter is currently a no-op on this list (browse-only until migrates
   // Skills to a modal).
 
   public handleInput(key: string): boolean {
@@ -393,8 +393,7 @@ export class SkillsPanel extends ScrollableListPanel<SkillRecord> {
     if (confirmResult === 'absorbed') return true;
 
     // I1: 'd' prompts delete confirmation — only outside filter mode, so 'd'
-    // remains typeable into the filter query while it is active (WO-153:
-    // converged modal '/' filter coexists with single-letter action keys).
+    // remains typeable into the filter query while it is active (// converged modal '/' filter coexists with single-letter action keys).
     if (!this.filterActive && key === 'd') {
       const skill = this.getSelectedItem();
       if (skill) {

package/src/panels/token-budget-panel.ts

@@ -7,7 +7,7 @@ import type { TurnEvent } from '@/runtime/index.ts';
 import type { UiEventFeed } from '../runtime/ui-events.ts';
 import type { UiReadModel, UiSessionSnapshot } from '../runtime/ui-read-models.ts';
 import type { SessionMemoryQuery } from '../runtime/ui-service-queries.ts';
-import { calcSessionCost, isModelPriced } from '../export/cost-utils.ts';
+import { calcSessionCost, describePricingSource, isModelPriced } from '../export/cost-utils.ts';
 import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
 import type { PanelIntegrationContext } from './types.ts';
 import {
@@ -460,7 +460,7 @@ export class TokenBudgetPanel extends BasePanel {
 
     if (status.guidanceMode !== 'off' && status.nextSteps.length > 0) {
       const nextStep = status.nextSteps[0]!;
-      // WO-160: when the recommended next step is /compact and C is armed
+      // when the recommended next step is /compact and C is armed
       // (see handleInput's elevated-only C branch and the footer hint),
       // advertise the key instead of the command — pressing C already
       // dispatches it for real, so printing '/compact' here was a redundant
@@ -618,9 +618,17 @@ export class TokenBudgetPanel extends BasePanel {
       const modelId = this.getCurrentModelId();
       const priced = isModelPriced(modelId);
       const cost = calcSessionCost(u.input, u.output, u.cacheRead, u.cacheWrite, modelId);
+      // Dollars carry their source; an unknown price renders the explicit
+      // marker (never $0.00) and names the one-key fix on the cost panel.
+      const source = priced ? describePricingSource(modelId) : null;
       lines.push(buildStyledPanelLine(width, [
         { text: '  Cost:       ', fg: C.label },
-        { text: priced ? `$${cost.toFixed(4)}` : 'unpriced', fg: C.value, bold: true },
+        { text: priced ? `$${cost.toFixed(4)}` : 'price unknown', fg: C.value, bold: true },
+        ...(priced && source
+          ? [{ text: ` (${source})`, fg: C.dim }]
+          : priced
+            ? []
+            : [{ text: ' — set it with p on the cost panel', fg: C.dim }]),
       ]));
     }
 

package/src/panels/types.ts

@@ -17,7 +17,7 @@ export interface PanelIntegrationContext {
 }
 
 /**
- * A cross-panel deep-link target (DEBT-5 item 4): a specific node a panel
+ * A cross-panel deep-link target (item 4): a specific node a panel
  * should select + reveal when opened via `PanelManager.open(id, pane, target)`,
  * e.g. a Fleet tree node keyed by its process id and (optionally) its
  * ProcessKind for disambiguation. Panel-agnostic on purpose — only panels that
@@ -56,7 +56,7 @@ export type NamedKey =
 export type KeyName = NamedKey | (string & {});
 
 /**
- * WO-152: the former single 'monitoring' bucket held 33 panels pre-merge —
+ * the former single 'monitoring' bucket held 33 panels pre-merge —
  * too coarse for the picker to be useful and too large for any one operator
  * mental model. Split into named operator domains so each category holds a
  * bounded, coherent set (no category may exceed 10 registrations):
@@ -97,7 +97,7 @@ export interface Panel {
   isPinned: boolean;
   needsRender: boolean;
 
-  // Dirty-flag contract (R2: activated panel render skipping)
+  // Dirty-flag contract (activated panel render skipping)
   /** Mark this panel as needing a re-render on the next frame. */
   invalidate(): void;
   /** Called by the compositor after a successful render to clear the dirty flag. */
@@ -154,7 +154,7 @@ export interface Panel {
 
   /**
    * Optional: consume a deep-link target handed in by `PanelManager.open(id,
-   * pane, target)` (DEBT-5 item 4) — select + reveal the matching node on the
+   * pane, target)` (item 4) — select + reveal the matching node on the
    * panel's next snapshot. A panel without a "node" concept simply doesn't
    * implement this (the call is a no-op via optional chaining in
    * PanelManager). A panel that DOES implement it owns its own honest
@@ -169,7 +169,7 @@ export interface PanelRegistration extends Pick<Panel, 'id' | 'name' | 'icon' |
   factory: () => Panel;
   description: string;
   /**
-   * WO-152 lifecycle flags. `preload` and `retainOnClose` are independent —
+   * lifecycle flags. `preload` and `retainOnClose` are independent —
    * a panel can eagerly instantiate without being kept alive on close, or be
    * kept alive on close without eager bootstrap instantiation. They happened
    * to be identical for all builtin panels before this split (both driven by

package/src/panels/workstream-graph-render.ts

@@ -0,0 +1,123 @@
+// ---------------------------------------------------------------------------
+// workstream-graph-render.ts — render a workstream's task graph (fleet.graph.get)
+// legibly, so the observability layer shows the dependency graph's shape,
+// states, and pool posture WITHOUT opening any transcript.
+//
+// The SDK serves a WorkstreamGraphSnapshot: nodes (id/title/state, plus
+// blockedReason, orphaned, stalled, agentId), edges (from → to dependency
+// links), and the elastic-pool state (ready/running/atCap/maxSize). This module
+// is a pure string renderer; every line is fit to the given width (no clipping,
+// no horizontal overflow), so the same output drives a panel or a command.
+// ---------------------------------------------------------------------------
+
+import type { OperatorMethodOutput } from '@pellux/goodvibes-sdk';
+import { truncateDisplay, getDisplayWidth } from '../utils/terminal-width.ts';
+
+export type WorkstreamGraphSnapshot = OperatorMethodOutput<'fleet.graph.get'>;
+export type WorkstreamGraphNode = WorkstreamGraphSnapshot['nodes'][number];
+
+/** The pool posture line: "N ready, M running[, at cap (fleet.maxSize=N)]". */
+export function renderPoolSummary(pool: WorkstreamGraphSnapshot['pool']): string {
+  if (!pool) return 'no pool state';
+  const base = `${pool.ready} ready, ${pool.running} running`;
+  return pool.atCap ? `${base}, at cap (fleet.maxSize=${pool.maxSize})` : base;
+}
+
+/** The leading glyph for a node — orphaned/blocked/stalled tells win over the base state. */
+function nodeGlyph(node: WorkstreamGraphNode): string {
+  if (node.orphaned) return '⊘';
+  if (node.blockedReason) return '⊘';
+  if (node.stalled) return '◒';
+  switch (node.state) {
+    case 'running': return '●';
+    case 'ready': return '○';
+    case 'done': return '✓';
+    case 'failed': return '✕';
+    default: return '·';
+  }
+}
+
+/** The state tell for a node: the "waiting on: X" for blocked, running/ready, plus orphaned/stalled markers. */
+function nodeTell(node: WorkstreamGraphNode, needs: readonly string[]): string {
+  const parts: string[] = [];
+  if (node.blockedReason) {
+    parts.push(`blocked — waiting on: ${node.blockedReason}`);
+  } else if (node.state === 'running') {
+    parts.push(node.agentId ? `running (${node.agentId})` : 'running');
+  } else if (node.state === 'ready') {
+    parts.push('ready');
+  } else {
+    parts.push(node.state);
+  }
+  if (needs.length > 0 && !node.blockedReason) parts.push(`needs: ${needs.join(', ')}`);
+  if (node.orphaned) parts.push('orphaned');
+  if (node.stalled) parts.push('stalled');
+  return parts.join(' · ');
+}
+
+/** Fit a line to the width without overflowing (truncates with an ellipsis). */
+function fit(line: string, width: number): string {
+  return getDisplayWidth(line) > width ? truncateDisplay(line, width) : line;
+}
+
+/**
+ * Wrap content to the width on word boundaries — NO clipping: the whole tell
+ * (including a long "waiting on: …" reason) survives onto indented continuation
+ * lines rather than being cut off. `firstIndent` leads the first line;
+ * `contIndent` leads each continuation. A single word longer than the width is
+ * hard-fit defensively so a line never overflows.
+ */
+function wrapContent(content: string, width: number, firstIndent: string, contIndent: string): string[] {
+  const words = content.split(/\s+/).filter(Boolean);
+  const out: string[] = [];
+  let cur = firstIndent;
+  let hasWord = false;
+  for (const word of words) {
+    const candidate = hasWord ? `${cur} ${word}` : `${cur}${word}`;
+    if (getDisplayWidth(candidate) > width && hasWord) {
+      out.push(cur);
+      cur = `${contIndent}${word}`;
+    } else {
+      cur = candidate;
+    }
+    hasWord = true;
+  }
+  if (hasWord) out.push(cur);
+  return out.map((l) => (getDisplayWidth(l) > width ? fit(l, width) : l));
+}
+
+/**
+ * Render the whole snapshot as legible lines, each fit to `width`. The header
+ * carries the pool posture; every node is one line with its glyph, title, and
+ * state tell (ready / running / blocked-with-waiting-on / stalled / orphaned),
+ * with its dependency edges named inline ("needs: …"). An empty graph states so
+ * honestly rather than rendering a blank surface.
+ */
+export function renderWorkstreamGraphLines(snapshot: WorkstreamGraphSnapshot, width: number): string[] {
+  const lines: string[] = [];
+  // Title and pool posture on their own lines so neither clips the other at a
+  // narrow width — the pool summary ("… at cap (fleet.maxSize=N)") is load-bearing.
+  lines.push(fit(snapshot.title, width));
+  lines.push(fit(`  ${renderPoolSummary(snapshot.pool)}`, width));
+
+  if (snapshot.nodes.length === 0) {
+    lines.push(fit('  (no work items in this workstream)', width));
+    return lines;
+  }
+
+  const titleById = new Map<string, string>();
+  for (const node of snapshot.nodes) titleById.set(node.id, node.title);
+  const needsByNode = new Map<string, string[]>();
+  for (const edge of snapshot.edges) {
+    const list = needsByNode.get(edge.to) ?? [];
+    list.push(titleById.get(edge.from) ?? edge.from);
+    needsByNode.set(edge.to, list);
+  }
+
+  for (const node of snapshot.nodes) {
+    const glyph = nodeGlyph(node);
+    const tell = nodeTell(node, needsByNode.get(node.id) ?? []);
+    lines.push(...wrapContent(`${glyph} ${node.title}  ${tell}`, width, '  ', '      '));
+  }
+  return lines;
+}