@pellux/goodvibes-tui 1.7.0 → 1.9.0

package/src/renderer/session-picker-modal.ts

@@ -5,15 +5,135 @@
  * Shows a list of saved sessions with:
  *   - name, timestamp (formatted), message count
  * Footer hints: [Enter] Load  [d] Delete  [Esc] Close
+ *
+ * W3-T2: when the modal was wired with a cross-surface session union
+ * (`modal.crossSurfaceView.mode !== 'local'`), an additional read-only
+ * "Cross-surface sessions" section is appended, badged kind/status/project
+ * (parity with the webui SessionsView) with one of three honest states —
+ * true-empty, offline, or stale — never a silently-collapsed list. In
+ * 'local' mode (no sessionBroker wired, e.g. every pre-existing caller/test)
+ * this section is entirely absent and the box sizing is unchanged.
  */
 
 import type { Line } from '../types/grid.ts';
+import type { SharedSessionRecord } from '@pellux/goodvibes-sdk/platform/control-plane';
 import { ModalFactory } from './modal-factory.ts';
+import { UI_TONES } from './ui-primitives.ts';
 import type { SessionPickerModal } from '../input/session-picker-modal.ts';
 import { formatTimestamp } from './modal-utils.ts';
 import { fitDisplay } from '../utils/terminal-width.ts';
 import { getOverlaySurfaceMetrics, getStableOverlayContentRows } from './overlay-viewport.ts';
 
+// ---------------------------------------------------------------------------
+// Cross-surface badge helpers (parity with webui's src/lib/sessions-union.ts)
+// ---------------------------------------------------------------------------
+
+/** Verbatim for unknown/future kinds — never dropped, never guessed. */
+function kindLabel(kind: string): string {
+  return kind.trim() || 'unknown';
+}
+
+function projectLabel(project: string): string {
+  return project.trim() || 'unknown';
+}
+
+function isClosedStatus(status: string): boolean {
+  return status.trim().toLowerCase() === 'closed';
+}
+
+/**
+ * D-TUI/#A2: closed sessions carry an optional, honest reason for WHY they
+ * closed under `metadata.closeReason` (SDK's `SharedSessionCloseReason`,
+ * 'closeReason' key — see `@pellux/goodvibes-sdk` platform/control-plane
+ * session-broker-sessions.ts's `readSessionCloseReason`). `metadata` is an
+ * open record so old readers and records from a build that predates this
+ * field ignore it safely — read it duck-typed here rather than importing the
+ * SDK's helper, and tolerate `metadata` itself being absent or malformed.
+ */
+function readCloseReason(record: SharedSessionRecord): string | undefined {
+  const raw = (record.metadata as Record<string, unknown> | undefined)?.['closeReason'];
+  return typeof raw === 'string' ? raw : undefined;
+}
+
+/**
+ * A GC sweep closing an idle session ('idle-reaped') auto-reopens on the next
+ * heartbeat — it is NOT the same event as a deliberate user/surface close, so
+ * it must never render under the same "closed" badge (W4/#A2). Tolerant of
+ * records without the field (pre-feature builds, or a deliberate close).
+ */
+function isReapedRecord(record: SharedSessionRecord): boolean {
+  return isClosedStatus(record.status) && readCloseReason(record) === 'idle-reaped';
+}
+
+/**
+ * Wave-4 UX-lens note: 'reaped' names a mechanism (the idle-session sweep),
+ * not a state a first-time reader can guess — the webui pairs its own
+ * 'reaped' badge with a tooltip explaining it
+ * (SessionsView.tsx: "Closed by the idle-session sweep — reopens
+ * automatically on the next activity"). The TUI has no hover/tooltip
+ * surface, so the plain-language explanation is rendered as its own short
+ * line under the cross-surface list instead — shown ONLY when at least one
+ * visible row actually carries the badge, so it never adds noise to a list
+ * with no reaped rows.
+ */
+const REAPED_BADGE_HINT = 'reaped = closed by the idle sweep — reopens on next activity';
+
+/** True when at least one of the currently-rendered (post-truncation) cross-surface rows carries the 'reaped' badge. */
+function hasVisibleReapedRow(modal: SessionPickerModal): boolean {
+  if (modal.crossSurfaceView.mode === 'local') return false;
+  return modal.crossSurfaceSessions.slice(0, MAX_CROSS_SURFACE_ROWS).some(isReapedRecord);
+}
+
+function statusLabel(record: SharedSessionRecord): string {
+  const trimmed = record.status.trim();
+  if (!trimmed) return 'active';
+  if (!isClosedStatus(trimmed)) return trimmed;
+  return isReapedRecord(record) ? 'reaped' : 'closed';
+}
+
+const MAX_CROSS_SURFACE_ROWS = 5;
+
+/**
+ * The exact honest note for the current state, or null when the union view
+ * needs no caveat (fresh/embedded with rows). Precedence: offline > stale >
+ * true-empty — the three states from the W3-T2 brief, never collapsed into
+ * each other (an offline view never silently renders as "no sessions yet").
+ */
+function crossSurfaceNote(view: SessionPickerModal['crossSurfaceView'], rowCount: number): string | null {
+  if (view.mode === 'local') return null;
+  if (view.offlineNote) return `${view.offlineNote} — showing local sessions only`;
+  if (view.stale) {
+    if (view.lastSyncAt === null) return 'Union view may be stale.';
+    const ageSeconds = Math.max(0, Math.round((Date.now() - view.lastSyncAt) / 1000));
+    return `Union view may be stale, last synced ${ageSeconds}s ago`;
+  }
+  if (rowCount === 0) return 'No sessions yet.';
+  return null;
+}
+
+function crossSurfaceRowCount(modal: SessionPickerModal): number {
+  return modal.crossSurfaceView.mode === 'local' ? 0 : Math.min(MAX_CROSS_SURFACE_ROWS, modal.crossSurfaceSessions.length);
+}
+
+/**
+ * Extra content rows the cross-surface section needs: separator + header
+ * (+note) + rows (+the "[showing N of M]" overflow line when the union has
+ * more records than MAX_CROSS_SURFACE_ROWS — previously uncounted here, which
+ * let modal-factory's tail-clip silently eat that trailing line even though
+ * the rest of the budget accounting held; see W3 Finding 1).
+ */
+function crossSurfaceExtraRows(modal: SessionPickerModal): number {
+  if (modal.crossSurfaceView.mode === 'local') return 0;
+  const rows = crossSurfaceRowCount(modal);
+  const noteRow = crossSurfaceNote(modal.crossSurfaceView, rows) ? 1 : 0;
+  const overflowRow = modal.crossSurfaceSessions.length > MAX_CROSS_SURFACE_ROWS ? 1 : 0;
+  // W4 UX-lens: the plain-language 'reaped' explainer is its own row —
+  // uncounted here it would be silently eaten by modal-factory's tail-clip
+  // exactly the way W3 Finding 1 describes above.
+  const reapedHintRow = hasVisibleReapedRow(modal) ? 1 : 0;
+  return 2 + noteRow + overflowRow + reapedHintRow + Math.max(rows, noteRow === 1 && rows === 0 ? 0 : rows);
+}
+
 // ---------------------------------------------------------------------------
 // Renderer
 // ---------------------------------------------------------------------------
@@ -29,16 +149,37 @@ export function renderSessionPickerModal(
   width: number,
   viewportHeight = 24,
 ): Line[] {
+  const extraRows = crossSurfaceExtraRows(modal);
   const metrics = getOverlaySurfaceMetrics(width, viewportHeight, {
     chromeRows: 6,
     minContentRows: 5,
-    maxContentRows: 9,
+    maxContentRows: 9 + extraRows,
   });
   const boxMargin = metrics.margin;
   const boxW = metrics.boxWidth;
   const contentW = metrics.contentWidth;
-  const visibleRows = metrics.contentRows;
-  const targetContentRows = getStableOverlayContentRows(metrics.contentRows, 8);
+  const targetContentRows = getStableOverlayContentRows(metrics.contentRows, 8 + extraRows);
+
+  // W3 Finding 1: when a cross-surface union section is present, cap the
+  // LOCAL list's window to what's left after reserving extraRows for the
+  // union — otherwise the local list expands to fill metrics.contentRows
+  // (which already includes the union's reservation) and modal-factory's
+  // single tail-clip (createModal, targetContentRows) silently drops the
+  // union section, or its trailing rows, once the box fills up. In local
+  // mode (extraRows === 0, every pre-existing caller/test) this reduces to
+  // the exact pre-T2 formula, so local-only output is byte-for-byte
+  // unaffected.
+  let visibleRows: number;
+  if (extraRows === 0) {
+    visibleRows = metrics.contentRows;
+  } else {
+    const localBudget = Math.max(0, targetContentRows - extraRows);
+    const overhead = 2; // header + separator row, present whenever sessions.length > 0
+    const remaining = Math.max(0, localBudget - overhead);
+    visibleRows = modal.sessions.length > remaining
+      ? Math.max(3, remaining - 2) // reserve 2 more rows for the local "[x-y of N]" overflow line
+      : Math.max(3, remaining);
+  }
   modal.setVisibleRows(visibleRows);
 
   const sections: import('./modal-factory.ts').ModalSection[] = [];
@@ -97,6 +238,58 @@ export function renderSessionPickerModal(
     }
   }
 
+  // W3-T2: cross-surface session union — visible only when a sessionBroker
+  // was wired (mode !== 'local'); absent entirely otherwise, so the box size
+  // and content of every pre-existing (local-only) caller is unaffected.
+  if (modal.crossSurfaceView.mode !== 'local') {
+    sections.push({ type: 'separator' });
+    sections.push({
+      type: 'text',
+      content: `Cross-surface sessions (${modal.crossSurfaceView.mode})`,
+      style: { fg: '240', dim: true, bold: true },
+    });
+    const note = crossSurfaceNote(modal.crossSurfaceView, modal.crossSurfaceSessions.length);
+    if (note) {
+      sections.push({
+        type: 'text',
+        content: note,
+        style: { fg: modal.crossSurfaceView.offlineNote ? UI_TONES.state.warn : '244', dim: !modal.crossSurfaceView.offlineNote },
+      });
+    }
+    if (modal.crossSurfaceSessions.length > 0) {
+      const rows = modal.crossSurfaceSessions.slice(0, MAX_CROSS_SURFACE_ROWS);
+      const listItems: import('./modal-factory.ts').ModalListItem[] = rows.map((record) => {
+        const reaped = isReapedRecord(record);
+        const closed = isClosedStatus(record.status);
+        const label = fitDisplay(
+          `${record.title || record.id} · ${kindLabel(record.kind)} · ${statusLabel(record)} · ${projectLabel(record.project)}`,
+          contentW,
+        );
+        // Reaped rows get their own tone (not plain dim-closed): the session
+        // will auto-reopen on the next heartbeat, unlike a deliberate close.
+        const style = reaped ? { fg: UI_TONES.state.info } : closed ? { fg: '244', dim: true } : undefined;
+        return { label, style };
+      });
+      sections.push({ type: 'list', items: listItems });
+      if (modal.crossSurfaceSessions.length > MAX_CROSS_SURFACE_ROWS) {
+        sections.push({
+          type: 'text',
+          content: `[showing ${MAX_CROSS_SURFACE_ROWS} of ${modal.crossSurfaceSessions.length}]`,
+          style: { fg: '244', dim: true },
+        });
+      }
+      // W4 UX-lens: only ever rendered when a visible row actually carries
+      // the 'reaped' badge — never speculative noise.
+      if (hasVisibleReapedRow(modal)) {
+        sections.push({
+          type: 'text',
+          content: REAPED_BADGE_HINT,
+          style: { fg: UI_TONES.state.info, dim: true },
+        });
+      }
+    }
+  }
+
   // Status message if present
   if (modal.statusMessage) {
     sections.push({ type: 'separator' });

package/src/renderer/settings-modal-helpers.ts

@@ -59,10 +59,12 @@ export const CATEGORY_LABELS: Record<(typeof SETTINGS_CATEGORIES)[number], strin
   storage: 'Storage',
   permissions: 'Permissions',
   orchestration: 'Orchestration',
+  planner: 'Planner',
   wrfc: 'WRFC',
   helper: 'Helper',
   tts: 'TTS',
   service: 'Service',
+  daemon: 'Daemon',
   controlPlane: 'Control Plane',
   httpListener: 'HTTP Listener',
   web: 'Web',

package/src/renderer/settings-modal.ts

@@ -32,10 +32,12 @@ const CATEGORY_INFO: Record<SettingsCategory, string> = {
   storage: 'Local storage posture, including secret storage policy and maximum artifact size for knowledge/home graph/document ingestion.',
   permissions: 'Permission mode and tool-class policy. These settings decide whether the shell prompts before read/write/exec/network/agent actions.',
   orchestration: 'Agent orchestration limits and recursion controls.',
+  planner: 'How /workstream decomposes a goal into work items: agent-driven decomposition (with heuristic fallback) or the forced heuristic path, plus the planning agent\'s turn, token, and wall-clock bounds.',
   wrfc: 'Work-review-fix-cycle thresholds, retry limits, and automatic commit behavior.',
   helper: 'Helper model defaults used by helper subsystems when they do not use the main chat route.',
   tts: 'Text-to-speech provider, voice, and optional spoken-turn LLM overrides.',
   service: 'Background service posture: enabled state, autostart, restart behavior, service name, platform, and logs.',
+  daemon: 'Local session daemon. It hosts the shared session broker and companion chat so a session started here is visible and steerable from other surfaces. On by default, bound to loopback (127.0.0.1) only.',
   controlPlane: 'Daemon control-plane settings for local admin/API access.',
   httpListener: 'HTTP listener settings for webhook and integration ingress.',
   web: 'Browser surface settings for the local or network web UI.',
@@ -57,6 +59,11 @@ const CATEGORY_INFO: Record<SettingsCategory, string> = {
 };
 
 const ENUM_VALUE_DESCRIPTIONS: Record<string, Record<string, string>> = {
+  'display.themeMode': {
+    auto: 'Probe the terminal background colour (OSC 11) once at startup and pick light or dark. Falls back to dark on unreadable/unsupported terminals. Only evaluated at startup — selecting auto takes effect next launch.',
+    dark: 'Force the dark theme regardless of terminal background. Applies immediately.',
+    light: 'Force the light theme regardless of terminal background. Applies immediately.',
+  },
   'behavior.hitlMode': {
     quiet: 'Minimize operational interruptions and surface fewer Human-in-the-Loop prompts.',
     balanced: 'Show important Human-in-the-Loop prompts without turning routine work into noise.',

package/src/renderer/shell-surface.ts

@@ -15,7 +15,7 @@ export interface ShellFooterBuildOptions {
    * themselves (main.ts does) do not need to also pass this.
    */
   readonly panelFocused?: boolean;
-  readonly usage: { up: number; down: number };
+  readonly usage: { up: number; down: number; fleetCostUsd?: number | null };
   readonly showExitNotice: boolean;
   readonly lastCopyTime: number;
   readonly model?: string;
@@ -47,6 +47,12 @@ export interface ShellFooterBuildOptions {
    * the process indicator, context bar, context-info line and posture block.
    */
   readonly compact?: boolean;
+  /**
+   * S3d: cross-surface session-spine posture for the context-info segment.
+   * Set ONLY in adopted-daemon mode ('online'/'offline'); left undefined in
+   * embedded/local mode so no segment renders.
+   */
+  readonly sessionSpineStatus?: 'online' | 'offline';
 }
 
 export interface ShellFooterBuildResult {
@@ -120,6 +126,7 @@ export function buildShellFooter(
     options.composerFlags,
     options.composerPendingRisk,
     options.compact ?? false,
+    options.sessionSpineStatus,
   );
   // Compact posture drops the process indicator and context hint entirely so
   // the footer fits within ~5 rows on short terminals.

package/src/renderer/status-glyphs.ts

@@ -4,20 +4,19 @@
 // Extracted as a neutral module so both status-token.ts and polish.ts can
 // import from here without creating a circular ESM dependency.
 //
-// STATE_GLYPHS is an alias into GLYPHS.status (ui-primitives.ts) — the single
-// glyph registry. Previously GLYPHS.status.info ('•') collided with
-// GLYPHS.status.pending, and STATE_GLYPHS.info ('○') collided with
-// GLYPHS.status.idle. GLYPHS.status.info is now '○' (this module's historical
-// value) and idle uses a distinct glyph ('◌').
+// W6-P1: STATE_GLYPHS is no longer hardcoded here. It is the SDK presentation
+// contract (@pellux/goodvibes-sdk/platform/presentation, landed by W4-S1 and
+// already adopted by the agent in W4-R4), aliased to GLYPHS.status so the
+// four semantic glyphs are spelled out in exactly one place and can never
+// drift from the registry again. Re-exported under the historical name so
+// status-token.ts and polish.ts import unchanged.
+//
+// Glyphs (unchanged — this module's historical values, the TUI reference the
+// contract was extracted from):
+//   good  ✓  (CHECK MARK U+2713)     — GLYPHS.status.success
+//   warn  ⚠  (WARNING SIGN U+26A0)    — GLYPHS.status.warn
+//   bad   ✕  (MULTIPLICATION X U+2715) — GLYPHS.status.failure
+//   info  ○  (WHITE CIRCLE U+25CB)    — GLYPHS.status.info
 // ---------------------------------------------------------------------------
 
-import { GLYPHS } from './ui-primitives.ts';
-
-export type StatusState = 'good' | 'warn' | 'bad' | 'info';
-
-export const STATE_GLYPHS: Record<StatusState, string> = {
-  good: GLYPHS.status.success, // ✓
-  warn: GLYPHS.status.warn,    // ⚠
-  bad:  GLYPHS.status.failure, // ✕
-  info: GLYPHS.status.info,    // ○
-};
+export { STATE_GLYPHS, type StatusState } from '@pellux/goodvibes-sdk/platform/presentation';

package/src/renderer/system-message.ts

@@ -1,6 +1,7 @@
 import { type Line } from '../types/grid.ts';
-import { BORDERS, COLORS } from './layout.ts';
+import { BORDERS } from './layout.ts';
 import { renderConversationNotice } from './conversation-surface.ts';
+import { activeUiTones } from './theme.ts';
 
 /** Exported for use by typeOverride callers and tests. */
 export type SystemMessageType = 'error' | 'warning' | 'info';
@@ -71,12 +72,23 @@ export function renderSystemMessage(
   typeOverride?: SystemMessageType,
 ): Line[] {
   const msgType = typeOverride ?? classifySystemMessage(content);
+  // System-message notices paint the ▌ marker and body text on the TRANSPARENT
+  // terminal background (renderConversationNotice passes no bodyBg), so the
+  // accent and dim text resolve per-render through activeUiTones() to stay
+  // legible on a light terminal. Dark values are byte-identical to the prior
+  // static reads (chrome.bad == state.bad, chrome.warn == state.warn,
+  // state.info unchanged, chrome.faint == fg.dim). The ▌ marker glyph is still
+  // sourced from the BORDERS table.
+  const t = activeUiTones();
   const border = msgType === 'error' ? BORDERS.ERROR
     : msgType === 'warning' ? BORDERS.WARNING
     : BORDERS.INFO;
-  const textColor = msgType === 'info' ? COLORS.DIM_TEXT : border.color;
+  const accent = msgType === 'error' ? t.chrome.bad
+    : msgType === 'warning' ? t.chrome.warn
+    : t.state.info;
+  const textColor = msgType === 'info' ? t.chrome.faint : accent;
   return renderConversationNotice(content, width, {
-    accent: border.color,
+    accent,
     text: textColor,
     dim: msgType === 'info',
   }, border.char);