@pellux/goodvibes-tui 0.19.23 → 0.19.24

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.19.24] — 2026-04-22
+
+Four correctness and honesty fixes from an external architecture review. No SDK change (pinned at 0.23.2).
+
+### Fixed
+
+- **`/clear` now actually clears the display** (`src/core/conversation.ts`). The original `clearDisplay()` immediately rebuilt the display buffer from `this.messages`, so `getDisplayBlocks().length` was unchanged before and after the call — `/clear` was a no-op. The fix introduces a `_displayFromMessageIndex` watermark: `clearDisplay()` records the current message count and clears the buffer without re-rendering; `rebuildHistory()` now only renders messages added *after* the watermark, so the screen is blank until the next message arrives. The full LLM context (`getMessagesForLLM()`, `getMessageSnapshot()`) is untouched. `resetAll()` zeroes the watermark so a full reset continues to work. Regression tests added to `src/test/core/conversation.test.ts` (4 new tests).
+
+- **Workspace tab bar shows active state on the unfocused pane** (`src/panels/panel-manager.ts`, `src/renderer/panel-workspace-bar.ts`). `getWorkspaceTabs()` previously set both `active` and `focused` from the single globally-focused panel, so the unfocused pane's selected tab lost its active marker entirely when focus moved to the other pane. The fix splits the two semantics: `active` is now true for the currently-selected tab in *its own pane* (derived from `pane.activeIndex`, independent of keyboard focus); `focused` is true only for the one tab in the globally-focused pane. The workspace bar renderer uses the `focused` flag to append a `▸` glyph to the focused tab's label, making keyboard-focus distinct from pane-level selection. Both panes now show their selected tab highlighted regardless of which has focus. Regression tests added to `src/test/panels/panel-manager.test.ts` (2 new tests).
+
+- **Panel render cache race guard** (`src/renderer/panel-composite.ts`). The documented hazard in the R2 cache — where a mid-render `invalidate()` call would be silently clobbered by the trailing `markRendered()` — has been resolved. The fix wraps each panel's `invalidate()` the first time it enters `renderPanel()` to maintain a per-panel generation counter (stored in a module-level `WeakMap`). The generation is snapshotted before `render()` and compared after: `markRendered()` is only called when the generation is unchanged, meaning no concurrent invalidation fired. If the generation changed, `needsRender` stays `true` and the next frame re-renders with the fresh state. Backward-compatible: existing panels that don't invalidate during render are unaffected. New test file `src/test/renderer/panel-composite.test.ts` (4 tests).
+
+- **Release gate filenames renamed to match what the tests actually verify** (`src/test/release-gates/`). `runtime-certification-gate.test.ts` was renamed to `runtime-contract-shape-gate.test.ts` and its `describe()` block updated to `'runtime contract shape gate'`. `foundation-surfaces-gate.test.ts` was renamed to `foundation-surface-stability-gate.test.ts` and its `describe()` block updated to `'foundation surface stability gate'`. The test content (assertions, helpers) is unchanged — this is an honesty rename only, removing the implication that the tests verify runtime behavior certification when they actually verify structural shape preservation.
+
+---
+
 ## [0.19.23] — 2026-04-22
 
 SDK 0.23.x constraint-propagation reconciliation. Surfaces the new per-chain constraint data across the WRFC panel, process modal, agent inspector, and agent detail modal; adds system-message notifications for constraint enumeration and violations; exposes the WRFC-injected `systemPromptAddendum` so operators can see the engineer addendum was applied.

package/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml/badge.svg)](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-0.19.23-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.19.24-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
 
 A terminal-native AI coding, operations, automation, knowledge, and integration console with a typed runtime, omnichannel surfaces, structured memory/knowledge, and a raw ANSI renderer.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.23",
+  "version": "0.19.24",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",

package/src/core/conversation.ts

@@ -74,6 +74,13 @@ export class ConversationManager extends SdkConversationManager {
   private errorLineRegistry: number[] = [];
   /** Streaming block start line in history buffer (for incremental streaming update). */
   private streamingStartLine = -1;
+  /**
+   * Message index at the time of the last clearDisplay() call.
+   * rebuildHistory() renders only messages at or after this index, so the
+   * display stays blank for messages added before the clear while LLM history
+   * is fully preserved. Reset to 0 on resetAll() or rebuildHistory() width change.
+   */
+  private _displayFromMessageIndex = 0;
 
   public suppressSplash: boolean = false;
   public splashOptions: SplashOptions = {};
@@ -215,6 +222,7 @@ export class ConversationManager extends SdkConversationManager {
     this.messageLineRegistry = [];
     this.errorLineRegistry = [];
     this.streamingStartLine = -1;
+    this._displayFromMessageIndex = 0; // full reset — show everything on next render
   }
 
   /**
@@ -293,20 +301,27 @@ export class ConversationManager extends SdkConversationManager {
     this.lastRenderedWidth = width;
     this.dirty = false;
 
+    const snapshot = this.getMessageSnapshot();
+    // When _displayFromMessageIndex > 0, clearDisplay() was called. Only render
+    // messages added after the clear — the pre-clear history stays off-screen.
+    // On a full rebuild (e.g. width change), reset the display-start to 0 so the
+    // user can scroll back to the full history if needed.
+    const displayStart = this._displayFromMessageIndex;
+    const visibleSnapshot = displayStart > 0 ? snapshot.slice(displayStart) : snapshot;
+
     // Tool messages ARE rendered (as collapsed blocks); this filter is only
     // for determining whether to show the splash screen (tool-only messages
     // don't count as visible conversation content for splash purposes).
-    const snapshot = this.getMessageSnapshot();
-    const displayMessages = snapshot.filter(
+    const displayMessages = visibleSnapshot.filter(
       (m) => m.role !== 'tool' && m.role !== 'system',
     );
 
-    if (displayMessages.length === 0 && !this.suppressSplash) {
+    if (displayMessages.length === 0 && displayStart === 0 && !this.suppressSplash) {
       this.addSplashScreen(width);
       return;
     }
 
-    this.appendMessages(snapshot, width);
+    this.appendMessages(visibleSnapshot, width);
     this.appendedUpTo = snapshot.length;
   }
 
@@ -509,19 +524,27 @@ export class ConversationManager extends SdkConversationManager {
 
   /**
    * clearDisplay - Clear the visual history buffer without touching the LLM context messages.
-   * The next render will show a blank conversation area.
+   * The next render will show a blank conversation area. Subsequent message additions
+   * rebuild the display incrementally from that point forward.
+   *
+   * Contract:
+   * - getDisplayBlocks() returns an empty array immediately after this call.
+   * - getMessageSnapshot() is unaffected — full LLM history is preserved.
+   * - resetAll() (which clears both display and messages) continues to work.
+   * - rebuildHistory() can be called by callers that need a full display rebuild.
    */
   public clearDisplay(): void {
     this.history.clear();
-    this.appendedUpTo = 0;
-    this.dirty = true;
-    // Re-render from existing messages to rebuild buffer
-    const width = this._getWidth();
-    this.lastRenderedWidth = width;
+    this.blockRegistry = [];
+    this.messageLineRegistry = [];
+    this.errorLineRegistry = [];
+    // Advance _displayFromMessageIndex to exclude all current messages from display.
+    // rebuildHistory() will only render messages added AFTER this point.
+    this._displayFromMessageIndex = this.getMessageSnapshot().length;
+    this.appendedUpTo = this._displayFromMessageIndex;
     this.dirty = false;
-    const snapshot = this.getMessageSnapshot();
-    this.appendMessages(snapshot, width);
-    this.appendedUpTo = snapshot.length;
+    // Do NOT re-render here — display stays blank until the next message is added.
+    // The lastRenderedWidth is kept so subsequent appends use the correct width.
   }
 }
 

package/src/panels/panel-manager.ts

@@ -347,13 +347,17 @@ export class PanelManager {
 
   getWorkspaceTabs(): readonly WorkspaceTab[] {
     if (this._cachedWorkspaceTabs !== null) return this._cachedWorkspaceTabs;
+    // `active` = the currently selected tab in its own pane (independent of focus).
+    // `focused` = true only for the one tab in the globally focused pane that is active.
     const focusedPanelId = this.getActivePanel()?.id;
+    const topActivePanelId = this.topPane.panels[this.topPane.activeIndex]?.id;
+    const bottomActivePanelId = this.bottomPane.panels[this.bottomPane.activeIndex]?.id;
     const topTabs = this.topPane.panels.map((panel) => ({
       id: panel.id,
       name: panel.name,
       icon: panel.icon,
       pane: 'top' as const,
-      active: panel.id === focusedPanelId,
+      active: panel.id === topActivePanelId,
       focused: panel.id === focusedPanelId,
     }));
     const bottomTabs = this.bottomPane.panels.map((panel) => ({
@@ -361,7 +365,7 @@ export class PanelManager {
       name: panel.name,
       icon: panel.icon,
       pane: 'bottom' as const,
-      active: panel.id === focusedPanelId,
+      active: panel.id === bottomActivePanelId,
       focused: panel.id === focusedPanelId,
     }));
     const tabs = [...topTabs, ...bottomTabs] as WorkspaceTab[];

package/src/renderer/panel-composite.ts

@@ -24,9 +24,9 @@ import { renderPanelWorkspaceBar } from './panel-workspace-bar.ts';
  * path (e.g. deferred lazy-load) should call `this.invalidate()` AFTER the
  * trailing work so the next frame picks it up.
  *
- * If this becomes a real bug, the fix is to snapshot `needsRender` before
- * calling `render()` and only `markRendered()` if the snapshot was true —
- * preserving any concurrent invalidation. Deferred pending more evidence.
+ * The fix (now applied): snapshot `needsRender` before calling `render()` and
+ * only call `markRendered()` when no concurrent invalidation occurred during
+ * the render pass — preserving any mid-render invalidation.
  */
 interface PanelRenderCache {
   lines: Line[];
@@ -34,15 +34,52 @@ interface PanelRenderCache {
   height: number;
 }
 const panelRenderCache = new WeakMap<Panel, PanelRenderCache>();
+/**
+ * Per-panel render-generation counter. Incremented whenever invalidate() fires
+ * on the panel (tracked here externally since Panel does not expose a version).
+ * We monkey-patch each panel the first time it enters renderPanel() by wrapping
+ * its invalidate() to bump the counter stored in this map.
+ *
+ * Race-guard: snapshot the generation before render(), compare after. If it
+ * changed, a mid-render invalidation occurred — leave needsRender=true.
+ */
+const panelRenderGen = new WeakMap<Panel, { gen: number }>();
+
+function getRenderGenState(panel: Panel): { gen: number } {
+  let state = panelRenderGen.get(panel);
+  if (!state) {
+    state = { gen: 0 };
+    panelRenderGen.set(panel, state);
+    // Wrap invalidate() to bump generation counter.
+    const origInvalidate = panel.invalidate.bind(panel);
+    panel.invalidate = () => {
+      state!.gen++;
+      origInvalidate();
+    };
+  }
+  return state;
+}
 
 /** R2: Render a panel, skipping if nothing changed. Returns cached lines on a skip. */
-function renderPanel(panel: Panel, width: number, height: number): Line[] {
+export function renderPanel(panel: Panel, width: number, height: number): Line[] {
   const cached = panelRenderCache.get(panel);
   if (cached && !panel.needsRender && cached.width === width && cached.height === height) {
     return cached.lines;
   }
+  // Snapshot render-generation counter BEFORE calling render(). If an event
+  // listener fires during render() and calls panel.invalidate(), the generation
+  // counter will be bumped. We compare after render to detect mid-render races.
+  const genState = getRenderGenState(panel);
+  const genBefore = genState.gen;
   const lines = panel.render(width, height);
-  panel.markRendered();
+  // Only call markRendered() when no mid-render invalidation occurred.
+  // If the generation changed during render(), a concurrent invalidate() fired —
+  // leave needsRender=true so the next frame re-renders with the new state.
+  if (genState.gen === genBefore) {
+    panel.markRendered();
+  }
+  // If gen changed, needsRender is already true (invalidate() set it); do not
+  // call markRendered() — the next frame will pick it up.
   panelRenderCache.set(panel, { lines, width, height });
   return lines;
 }

package/src/renderer/panel-workspace-bar.ts

@@ -17,7 +17,11 @@ export function renderPanelWorkspaceBar(
   return renderTabStrip({
     width,
     tabs: tabs.map((tab) => ({
-      label: `${tab.pane === 'bottom' ? 'v' : '^'} ${tab.icon} ${tab.name}`,
+      // tab.active = selected in its own pane (drives highlighted background).
+      // tab.focused = has keyboard focus (drives brighter text / focus indicator).
+      // A tab can be active-but-not-focused (selected in the unfocused pane) or
+      // active-and-focused (selected in the focused pane).
+      label: `${tab.pane === 'bottom' ? 'v' : '^'} ${tab.icon} ${tab.name}${tab.focused ? ' ▸' : ''}`,
       active: tab.active,
     })),
     prefixLabel: ' PANELS ',

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.19.23';
+let _version = '0.19.24';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;