@pellux/goodvibes-tui 0.27.0 → 0.29.0

package/src/runtime/diagnostics/panels/index.ts

@@ -12,13 +12,10 @@ export type { InspectableDomain } from '@/runtime/index.ts';
 export { HealthPanel } from '@/runtime/index.ts';
 export { DivergencePanel } from '@/runtime/index.ts';
 export { ReplayPanel } from '@/runtime/index.ts';
-export { PolicyPanel } from './policy.ts';
-export type { PolicyPanelSnapshot } from './policy.ts';
 export { ToolContractsPanel } from '@/runtime/index.ts';
 export { TransportPanel } from '@/runtime/index.ts';
 export type { TransportPanelSnapshot } from '@/runtime/index.ts';
 export { OpsPanel } from './ops.ts';
 export type { OpsAuditEntry } from './ops.ts';
-export { PanelResourcesPanel } from './panel-resources.ts';
 export { SecurityPanel } from '@/runtime/index.ts';
 export type { SecurityPanelSnapshot } from '@/runtime/index.ts';

package/src/runtime/ui/model-picker/health-enrichment.ts

@@ -154,6 +154,9 @@ export function enrichModelEntries(
     // Determine source: custom/local providers carry provenance on ModelDefinition;
     // for catalog models, if getContextWindowForModel returned more than the
     // static contextWindow it came from OpenRouter, else it's the registry value.
+    // NOTE: This is a best-effort heuristic. When the OpenRouter live value equals
+    // the static registry value the badge shows 'registry' even though OpenRouter
+    // was consulted. The contextWindow value itself is always accurate.
     let contextWindowSource: ModelPickerEntry['contextWindowSource'];
     if (model.contextWindowProvenance) {
       contextWindowSource = model.contextWindowProvenance;

package/src/runtime/ui/model-picker/types.ts

@@ -97,6 +97,10 @@ export interface ModelPickerEntry {
    * - `fallback`       — default constant (no config or API source)
    * - `openrouter`     — sourced from OpenRouter model data (built-in catalog models)
    * - `registry`       — static value in the built-in model registry
+   *
+   * For built-in catalog models this badge is best-effort: when the OpenRouter
+   * resolved value equals the static registry value the source shows 'registry'
+   * even if OpenRouter was consulted at runtime.
    */
   readonly contextWindowSource:
     | 'provider_api'

package/src/shell/ui-openers.ts

@@ -253,6 +253,7 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     if (!input.helpOverlayActive) input.modalOpened('help');
     input.helpOverlayActive = !input.helpOverlayActive;
     input.helpScrollOffset = 0;
+    render();
   };
 
   commandContext.openShortcutsOverlay = () => {
@@ -292,19 +293,16 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
   };
 
   commandContext.openPanelPicker = () => {
-    if (!panelManager.isVisible()) {
-      if (panelManager.getAllOpen().length === 0) {
-        try {
-          panelManager.open('panel-list');
-        } catch {
-          // non-fatal
-        }
-      }
-      panelManager.show();
-      input.panelFocused = true;
-      conversation.setSplashSuppressed(true);
+    // Focus ownership lives in PanelManager (focusTarget); read it there rather
+    // than tracking a parallel input.panelFocused flag. Toggle semantics: if the
+    // workspace is visible AND already focused, hide it; otherwise reveal and
+    // focus it (opening the panel list when nothing is open yet).
+    if (panelManager.isVisible() && panelManager.getFocusTarget() === 'panel') {
+      panelManager.hide();
+      panelManager.focusPrompt();
+      conversation.setSplashSuppressed(false);
       conversation.rebuildHistory();
-    } else if (!input.panelFocused) {
+    } else {
       if (panelManager.getAllOpen().length === 0) {
         try {
           panelManager.open('panel-list');
@@ -313,26 +311,20 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
         }
       }
       panelManager.show();
-      input.panelFocused = true;
+      panelManager.focusPanels();
       conversation.setSplashSuppressed(true);
       conversation.rebuildHistory();
-    } else {
-      panelManager.hide();
-      input.panelFocused = false;
-      conversation.setSplashSuppressed(false);
-      conversation.rebuildHistory();
     }
     render();
   };
 
   commandContext.focusPanels = () => {
-    if (!panelManager.isVisible() || panelManager.getAllOpen().length === 0) return;
-    input.panelFocused = true;
+    panelManager.focusPanels();
     render();
   };
 
   commandContext.focusPrompt = () => {
-    input.panelFocused = false;
+    panelManager.focusPrompt();
     input.indicatorFocused = false;
     render();
   };
@@ -340,7 +332,7 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
   commandContext.showPanel = (panelId, pane) => {
     panelManager.open(panelId, pane);
     panelManager.show();
-    input.panelFocused = true;
+    panelManager.focusPanels();
     conversation.setSplashSuppressed(true);
     conversation.rebuildHistory();
     render();

package/src/utils/format-duration.ts

@@ -0,0 +1,55 @@
+/**
+ * Shared ms-duration formatters for the panel layer.
+ *
+ * Three families are exported, each matching a distinct behavior cluster.
+ * DO NOT replace these with formatElapsed from utils/format-elapsed.ts —
+ * formatElapsed floors to integer seconds and lacks the null/'?ms' guards
+ * that the latency panels require.
+ */
+
+/**
+ * Format a latency value in milliseconds with sub-second precision.
+ *
+ * Used by: debug-panel, provider-health-panel
+ *
+ *   ms <= 0     → 'n/a'
+ *   ms >= 10000 → '12.3s'    (one decimal)
+ *   ms >= 1000  → '1.23s'   (two decimals)
+ *   else        → '500ms'   (integer ms)
+ */
+export function formatLatencyMs(ms: number): string {
+  if (ms <= 0)      return 'n/a';
+  if (ms >= 10_000) return `${(ms / 1000).toFixed(1)}s`;
+  if (ms >= 1_000)  return `${(ms / 1000).toFixed(2)}s`;
+  return `${Math.round(ms)}ms`;
+}
+
+/**
+ * Format a task/agent duration with minute-rolling notation.
+ *
+ * Used by: tool-inspector-panel, agent-inspector-shared
+ *
+ *   ms < 1000   → '500ms'
+ *   ms < 60000  → '3.5s'
+ *   else        → '1m30s'
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 1000)  return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${Math.floor(ms / 60000)}m${Math.floor((ms % 60000) / 1000)}s`;
+}
+
+/**
+ * Format a short eval/forensics duration; treats undefined as '?ms'.
+ *
+ * Used by: incident-review-panel, eval-panel
+ *
+ *   undefined → '?ms'
+ *   ms < 1000 → '500ms'
+ *   else      → '1.5s'
+ */
+export function formatShortDuration(ms: number | undefined): string {
+  if (ms === undefined) return '?ms';
+  if (ms < 1000)        return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}

package/src/utils/format-number.ts

@@ -0,0 +1,71 @@
+/**
+ * Parametrised number abbreviation helper.
+ *
+ * Each call site can reproduce its exact current output by passing the
+ * appropriate options rather than a single "agreed" format being imposed.
+ *
+ * Ranges (default opts: guard=1_000, decimals=1, rounding='fixed'):
+ *   n <  guard          → String(n)            e.g. 999  → '999'
+ *   n <  1_000_000      → X.Xk                 e.g. 1500 → '1.5k'
+ *   n <  1_000_000_000  → X.XM                 e.g. 1.5M → '1.5M'
+ *   (with bSuffix)      → X.XB / X.XT
+ *   (with noM)          → always k, never M
+ */
+
+export interface AbbreviateCountOpts {
+  /**
+   * Values strictly below this are returned as-is via String(n).
+   * Default: 1_000
+   */
+  guard?: number;
+  /**
+   * Decimal places used for the k suffix (and for M when mDecimals is not set).
+   * Default: 1
+   */
+  decimals?: number;
+  /**
+   * Override decimal places for the M suffix only.
+   * Default: same as decimals.
+   */
+  mDecimals?: number;
+  /**
+   * 'fixed'  → value.toFixed(decimals)  (default)
+   * 'round'  → String(Math.round(value)) — always integer, decimals ignored
+   */
+  rounding?: 'fixed' | 'round';
+  /**
+   * When true, extend formatting to B (billions) and T (trillions).
+   * Default: false
+   */
+  bSuffix?: boolean;
+  /**
+   * When true, never produce M/B/T — format as k even for millions.
+   * Default: false
+   */
+  noM?: boolean;
+}
+
+/**
+ * Format a non-negative integer with k/M/B/T magnitude suffix.
+ *
+ * Preserves each call site's exact current format by accepting
+ * per-site option overrides (guard, decimals, rounding, etc.).
+ */
+export function abbreviateCount(n: number, opts?: AbbreviateCountOpts): string {
+  const guard     = opts?.guard     ?? 1_000;
+  const decimals  = opts?.decimals  ?? 1;
+  const mDecimals = opts?.mDecimals ?? decimals;
+  const rounding  = opts?.rounding  ?? 'fixed';
+  const noM       = opts?.noM       ?? false;
+  const bSuffix   = opts?.bSuffix   ?? false;
+
+  /** Render a scaled value according to the configured rounding mode. */
+  const fmt = (val: number, d: number): string =>
+    rounding === 'round' ? String(Math.round(val)) : val.toFixed(d);
+
+  if (n < guard)                      return String(n);
+  if (noM || n < 1_000_000)           return fmt(n / 1_000, decimals)          + 'k';
+  if (!bSuffix || n < 1_000_000_000)  return fmt(n / 1_000_000, mDecimals)     + 'M';
+  if (n < 1_000_000_000_000)          return fmt(n / 1_000_000_000, decimals)  + 'B';
+  return                                     fmt(n / 1_000_000_000_000, decimals) + 'T';
+}

package/src/utils/splash-lines.ts

@@ -1,4 +1,4 @@
-import { center, getDisplayWidth } from './terminal-width.ts';
+import { center, getDisplayWidth, truncateDisplay } from './terminal-width.ts';
 import { VERSION } from '../version.ts';
 
 const ART_LINES = [
@@ -22,15 +22,33 @@ const TAGLINE = '[ ｇｏｏｄ ｖｉｂｅｓ ・ Ａ Ｉ ・ いい雰囲気
 
 const VERSION_LINE = `　✦　v${VERSION}　█　terminal AI assistant　█　自動ｺｰﾄﾞ 　✦`;
 
+/** Fixed hint line — the three primary shell entry points. */
+const HINT_LINE = 'Ctrl+P panels  /  ? help  /  F2 processes';
+
 export interface SplashOptions {
   workingDir?: string;
   model?: string;
   provider?: string;
   toolCount?: number;
+  /**
+   * Session id of the most recent session, as resolved by readLastSessionPointer.
+   * When present, the splash advertises a resume affordance.
+   */
+  lastSessionId?: string;
+}
+
+/** Collapse a $HOME-prefixed working directory to a leading `~`. */
+function collapseHome(dir: string): string {
+  const home = typeof process !== 'undefined' ? process.env.HOME ?? '' : '';
+  return home && dir.startsWith(home) ? '~' + dir.slice(home.length) : dir;
+}
+
+/** Center a meta line, truncating first so it never overflows the terminal width. */
+function metaLine(text: string, columns: number): string {
+  return center(truncateDisplay(text, Math.max(0, columns)), columns);
 }
 
 export function getSplashLines(columns: number, opts: SplashOptions = {}): string[] {
-  const splashHint = 'start chatting or type /help for commands';
   const lines: string[] = [
     center(TOP_BORDER, columns),
     ...ART_LINES.map((line) => center(line, columns)),
@@ -40,7 +58,30 @@ export function getSplashLines(columns: number, opts: SplashOptions = {}): strin
     '',
   ];
 
-  lines.push(center(splashHint, columns));
+  // Live session context — real state pulled from SplashOptions rather than a
+  // static "/help" signpost: model (provider) and tool count on one line, cwd
+  // on the next.
+  const contextBits: string[] = [];
+  if (opts.model) {
+    contextBits.push(opts.provider ? `${opts.model} (${opts.provider})` : opts.model);
+  }
+  if (typeof opts.toolCount === 'number') {
+    contextBits.push(`${opts.toolCount} tool${opts.toolCount === 1 ? '' : 's'}`);
+  }
+  if (contextBits.length > 0) {
+    lines.push(metaLine(contextBits.join('  ·  '), columns));
+  }
+  if (opts.workingDir) {
+    lines.push(metaLine(collapseHome(opts.workingDir), columns));
+  }
+
+  // Last-session resume pointer (readLastSessionPointer result), when recorded.
+  if (opts.lastSessionId) {
+    lines.push(metaLine(`↩ resume last session — /sessions resume ${opts.lastSessionId}`, columns));
+  }
+
+  lines.push('');
+  lines.push(metaLine(HINT_LINE, columns));
 
   return lines;
 }

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.27.0';
+let _version = '0.29.0';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;

package/src/work-plans/work-plan-store.ts

@@ -267,6 +267,19 @@ export class WorkPlanStore {
     return removed;
   }
 
+  /**
+   * Writes the current plan's `toMarkdown()` output to a sibling `.md` file
+   * next to the JSON store file, so the checklist can be opened outside the
+   * TUI. Returns the written path alongside the markdown that was written.
+   */
+  exportMarkdown(): { readonly path: string; readonly markdown: string } {
+    const plan = this.readPlan();
+    const markdown = this.toMarkdown(plan);
+    const path = this.filePath.replace(/\.json$/, '.md');
+    atomicWriteFileSync(path, `${markdown}\n`, { mkdirp: true });
+    return { path, markdown };
+  }
+
   toMarkdown(plan: WorkPlan = this.readPlan()): string {
     const lines = [
       `# ${plan.title}`,