@pellux/goodvibes-tui 1.1.0 → 1.7.0

package/src/renderer/compaction-quality.ts

@@ -0,0 +1,100 @@
+/**
+ * Compaction quality-score bridging (Wave-5 W5.4 / B28).
+ *
+ * Reality check (wo803): the SDK's `computeQualityScore()`
+ * (platform/runtime/compaction/quality-score.ts) is only ever called from a
+ * SEPARATE pipeline, `CompactionManager` (platform/runtime/compaction/manager.ts).
+ * The TUI's actual `/compact` path never instantiates `CompactionManager` — it
+ * goes through `platform/core/context-compaction.ts` via
+ * `ConversationManager.compact()` (see `compactConversation()` in
+ * runtime-services.ts), which has no scoring of its own. Adopting the whole
+ * `CompactionManager` pipeline just to get the score would be a far bigger
+ * change than this item calls for.
+ *
+ * Instead, this module calls `computeQualityScore()` directly and out-of-band,
+ * fed by the before/after message sets and token estimates
+ * `compactConversation()` already holds. That's enough to close the gap:
+ * quality scoring reaches `/compact` and `/compact-history` without adopting
+ * `CompactionManager`.
+ *
+ * Honesty note: the `strategy` value passed to `computeQualityScore()` is a
+ * BORROWED rubric label describing what `compactConversation()`'s structured
+ * multi-section extraction actually does (collapse the whole conversation
+ * into one handoff message) — it is NOT a real `CompactionStrategy`
+ * escalation result, and no strategy switch is triggered from it. Every
+ * rendering of the score says so explicitly (see `formatQualityScoreLine`).
+ *
+ * Storage: scores are kept in a TUI-local, timestamp-keyed store, never added
+ * to the SDK's public `CompactionEvent` type (that would force an
+ * api-extractor regen for a value the SDK's own compaction log never
+ * populates). Keyed by `CompactionEvent.timestamp` rather than array index,
+ * because `compactSmallWindow`'s null-event path (small-context-window
+ * models — see runtime-services.ts) can create index gaps.
+ */
+
+import { computeQualityScore, describeScore } from '@/runtime/index.ts';
+import type { CompactionQualityScore, StrategyInput, StrategyOutput } from '@/runtime/index.ts';
+import type { ProviderMessage } from '@pellux/goodvibes-sdk/platform/providers';
+
+export type { CompactionQualityScore } from '@/runtime/index.ts';
+
+/**
+ * Bound the TUI-local score store the same way the SDK bounds its own
+ * compaction event log (context-compaction.ts caps at 50 and shifts the
+ * oldest entry) — a long-running session should not accumulate this forever.
+ */
+const MAX_TRACKED_SCORES = 50;
+
+const scoresByTimestamp = new Map<number, CompactionQualityScore>();
+
+/** Record a computed quality score, keyed by the CompactionEvent's timestamp. */
+export function recordCompactionQualityScore(timestamp: number, score: CompactionQualityScore): void {
+  scoresByTimestamp.set(timestamp, score);
+  if (scoresByTimestamp.size > MAX_TRACKED_SCORES) {
+    const oldestKey = scoresByTimestamp.keys().next().value;
+    if (oldestKey !== undefined) scoresByTimestamp.delete(oldestKey);
+  }
+}
+
+/** Look up a previously-recorded quality score for a CompactionEvent, by timestamp. */
+export function getCompactionQualityScore(timestamp: number): CompactionQualityScore | undefined {
+  return scoresByTimestamp.get(timestamp);
+}
+
+export interface ScoreCompactionRunInput {
+  readonly sessionId: string;
+  readonly contextWindow: number;
+  readonly messagesBefore: readonly ProviderMessage[];
+  readonly messagesAfter: readonly ProviderMessage[];
+  readonly tokensBefore: number;
+  readonly tokensAfter: number;
+}
+
+/**
+ * Compute a CompactionQualityScore for one compaction run, out-of-band from
+ * the SDK's own (unused, in this TUI) CompactionManager pipeline.
+ */
+export function scoreCompactionRun(input: ScoreCompactionRunInput): CompactionQualityScore {
+  const strategyInput: StrategyInput = {
+    sessionId: input.sessionId,
+    messages: input.messagesBefore,
+    tokensBefore: input.tokensBefore,
+    contextWindow: input.contextWindow,
+    // Borrowed rubric label, not a real strategy escalation — see module doc.
+    strategy: 'collapse',
+  };
+  const strategyOutput: StrategyOutput = {
+    messages: [...input.messagesAfter],
+    tokensAfter: input.tokensAfter,
+    summary: '',
+    strategy: 'collapse',
+    durationMs: 0,
+    warnings: [],
+  };
+  return computeQualityScore(strategyInput, strategyOutput);
+}
+
+/** One-line grade summary for the /compact after-notice and /compact-history entries. */
+export function formatQualityScoreLine(score: CompactionQualityScore): string {
+  return `Quality: ${describeScore(score)} (rubric applied out-of-band; no strategy escalation ran)`;
+}

package/src/renderer/config-modal.ts

@@ -0,0 +1,81 @@
+import type { Line } from '../types/grid.ts';
+import { ModalFactory, type ModalSection, type ModalTab } from './modal-factory.ts';
+import { resolveUiTones } from './theme.ts';
+import type { ConfigModal, ConfigModalRenderModel } from '../input/config-modal.ts';
+
+const TONES = resolveUiTones('dark');
+
+/**
+ * renderConfigModal — the single render path for every ConfigModalSurface.
+ * Reads the host's frozen-structure-plus-live-values render model and maps it
+ * onto ModalFactory.createModal (the same renderer settings-modal uses), so the
+ * chrome, tab strip, list, and footer are one dialect across all migrated
+ * surfaces. Pure: takes the modal's render model, returns Line[].
+ */
+export function renderConfigModal(modal: ConfigModal, width: number, height: number): Line[] {
+  // Size the visible row window to the available height so the list scrolls
+  // rather than overflowing (posture header + separator + chrome ≈ 8 rows).
+  const visible = Math.max(3, Math.min(16, height - 8));
+  modal.setViewportRows(visible);
+  const model = modal.getRenderModel();
+  return renderConfigModalModel(model, width);
+}
+
+/** Pure model→Line[] mapping — the shared inner step of renderConfigModal. */
+function renderConfigModalModel(model: ConfigModalRenderModel, width: number): Line[] {
+  const sections: ModalSection[] = [];
+
+  if (model.degraded) {
+    sections.push({ type: 'text', content: `⚠ ${model.degraded}`, style: { fg: TONES.state.warn, bold: true } });
+    sections.push({ type: 'separator' });
+  }
+
+  for (const line of model.header) {
+    sections.push({ type: 'text', content: line, style: { fg: TONES.fg.secondary } });
+  }
+  if (model.header.length > 0) sections.push({ type: 'separator' });
+
+  if (model.rows.length === 0) {
+    sections.push({ type: 'text', content: model.emptyText ?? 'Nothing to show.', style: { fg: TONES.fg.muted, dim: true } });
+  } else {
+    sections.push({
+      type: 'list',
+      items: model.rows.map((row) => ({
+        label: row.label,
+        selected: row.selected,
+        style: row.stale
+          ? { fg: TONES.fg.muted, dim: true }
+          : row.style,
+      })),
+    });
+  }
+
+  const tabs: ModalTab[] | undefined = model.tabs.length > 1
+    ? model.tabs.map((t) => ({ label: t.label, active: t.active }))
+    : undefined;
+
+  // Keep the content region a stable height so live-value ticks never change
+  // the box size: frozen header + separator + the fixed visible-row window.
+  const targetContentRows =
+    (model.degraded ? 2 : 0) +
+    model.header.length +
+    (model.header.length > 0 ? 1 : 0) +
+    model.scroll.visible;
+
+  const helpers = model.status
+    ? [{ content: model.status, accent: true }]
+    : undefined;
+
+  return ModalFactory.createModal(
+    {
+      title: model.title,
+      width: 76,
+      tabs,
+      sections,
+      targetContentRows,
+      helpers,
+      hints: [...model.hints],
+    },
+    width,
+  );
+}

package/src/renderer/conversation-overlays.ts

@@ -8,11 +8,9 @@ import { renderModelWorkspace } from './model-workspace.ts';
 import { renderSelectionModalOverlay } from './selection-modal-overlay.ts';
 import { renderSearchOverlay } from './search-overlay.ts';
 import { renderHistorySearchOverlay } from './history-search-overlay.ts';
-import { renderProcessModal } from './process-modal.ts';
-import { renderAgentDetailModal } from './agent-detail-modal.ts';
-import { renderLiveTailModal } from './live-tail-modal.ts';
 import { renderContextInspector } from './context-inspector.ts';
 import { renderSettingsModal } from './settings-modal.ts';
+import { renderConfigModal } from './config-modal.ts';
 import { renderMcpWorkspace } from './mcp-workspace.ts';
 import { renderSessionPickerModal } from './session-picker-modal.ts';
 import { renderProfilePickerModal } from './profile-picker-modal.ts';
@@ -78,20 +76,9 @@ export function applyConversationOverlays(
     next.push(...renderHistorySearchOverlay(input.historySearch, conversationWidth));
   }
 
-  if (!fullscreenClaimed && input.processModal.active) {
-    const lines = renderProcessModal(input.processModal, conversationWidth, viewportHeight);
-    next = overlayViewportBottom(next, lines, conversationWidth, viewportHeight, bottomDockInset);
-  }
-
-  if (!fullscreenClaimed && input.agentDetailModal.active) {
-    const lines = renderAgentDetailModal(input.agentDetailModal, conversationWidth, viewportHeight);
-    next = overlayViewportBottom(next, lines, conversationWidth, viewportHeight, bottomDockInset);
-  }
-
-  if (!fullscreenClaimed && input.liveTailModal.active) {
-    const lines = renderLiveTailModal(input.liveTailModal, conversationWidth, viewportHeight);
-    next = overlayViewportBottom(next, lines, conversationWidth, viewportHeight, bottomDockInset);
-  }
+  // W6.1 retirement: the process, agent-detail, and live-tail modal overlays
+  // were removed with those modals — F2 now opens the Fleet panel, which
+  // subsumes the live process tree.
 
   if (!fullscreenClaimed && input.contextInspectorModal.active) {
     const lines = renderContextInspector(conversation, conversationWidth, viewportHeight, contextWindow);
@@ -104,6 +91,12 @@ export function applyConversationOverlays(
     fullscreenClaimed = true;
   }
 
+  if (!fullscreenClaimed && input.configModal.active) {
+    const lines = renderConfigModal(input.configModal, conversationWidth, viewportHeight);
+    next = replaceViewportWithOverlay(lines, conversationWidth, viewportHeight);
+    fullscreenClaimed = true;
+  }
+
   if (input.mcpWorkspace.active) {
     const lines = renderMcpWorkspace(input.mcpWorkspace, conversationWidth, viewportHeight);
     next = replaceViewportWithOverlay(lines, conversationWidth, viewportHeight);

package/src/renderer/fleet-tab-strip.ts

@@ -0,0 +1,56 @@
+// ---------------------------------------------------------------------------
+// fleet-tab-strip.ts
+//
+// Wave-3 (W3.1 Part C3) — renders FleetPanel's session-tab strip by reusing
+// renderTabStrip exactly as panel-workspace-bar.ts does for the workspace
+// tab bar. Deliberately a SEPARATE, visually distinct strip from the
+// workspace bar: workspace tabs switch PANELS, fleet session tabs switch
+// ATTACHED PROCESSES within one panel — conflating their styling would blur
+// that distinction for the operator.
+// ---------------------------------------------------------------------------
+
+import type { Line } from '../types/grid.ts';
+import type { FleetTabsState } from '../panels/fleet-tabs.ts';
+import { renderTabStrip, type TabHitRegion } from './tab-strip.ts';
+import { UI_TONES } from './ui-primitives.ts';
+
+const ACTIVE_FG = UI_TONES.fg.primary;
+const ACTIVE_BG = UI_TONES.bg.selected;
+const INACTIVE_FG = UI_TONES.fg.muted;
+const SEPARATOR_FG = UI_TONES.fg.dim;
+const LABEL_FG = UI_TONES.fg.secondary;
+
+/**
+ * Render the fleet session-tab strip, or `null` when there are no attached
+ * tabs — the panel omits the strip entirely in that case (root-tab-only),
+ * which is what keeps the pre-Wave-3 fleet-panel goldens byte-identical.
+ */
+export function renderFleetTabStrip(
+  state: FleetTabsState,
+  width: number,
+  onLayout?: (regions: readonly TabHitRegion[]) => void,
+): Line | null {
+  if (state.tabs.length === 0) return null;
+  return renderTabStrip({
+    width,
+    onLayout,
+    tabs: [
+      { label: 'Tree', active: state.activeTabIndex === 0 },
+      ...state.tabs.map((tab, index) => ({
+        label: tab.label,
+        active: state.activeTabIndex === index + 1,
+      })),
+    ],
+    prefixLabel: ' SESSIONS ',
+    style: {
+      activeFg: ACTIVE_FG,
+      activeBg: ACTIVE_BG,
+      activeBold: true,
+      inactiveFg: INACTIVE_FG,
+      separatorFg: SEPARATOR_FG,
+      labelFg: LABEL_FG,
+      overflowFg: SEPARATOR_FG,
+      trailingFg: INACTIVE_FG,
+    },
+  });
+}

package/src/renderer/footer-tips.ts

@@ -25,9 +25,17 @@ export function isAgentActive(composerStatus: string | undefined): boolean {
 }
 
 const TIP_PANELS = 'Ctrl+P panels';
-const TIP_PROCESSES = 'F2 processes';
+// W6.2 e: F2 now opens the Fleet panel (the process modal was retired), so the
+// tip names 'fleet', not 'processes'.
+const TIP_PROCESSES = 'F2 fleet';
 const TIP_HELP = '? help';
-const TIP_QUIT = 'Ctrl+C quit';
+// W6.2 f: an empty-composer Ctrl+C does NOT quit on the first press — it arms a
+// ~1s "press again to exit" confirm, and only a SECOND Ctrl+C within that window
+// exits (an intentional accidental-exit guard). The old 'Ctrl+C quit' tip
+// implied a single press quits, so two presses seconds apart appeared to do
+// nothing. 'Ctrl+C x2 quit' matches the real double-press contract (and the
+// help overlay's "Ctrl+C x2  Exit" row).
+const TIP_QUIT = 'Ctrl+C x2 quit';
 
 /**
  * Build the footer discoverability tip. Segments join with the shared middle

package/src/renderer/git-status.ts

@@ -24,6 +24,7 @@ export class GitStatusProvider {
   private lastFetch = 0;
   private readonly ttlMs = 2000;
   private fetching = false;
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
 
   constructor(private readonly workingDirectory: string) {}
 
@@ -53,6 +54,45 @@ export class GitStatusProvider {
     return this.cache;
   }
 
+  /**
+   * Start a lightweight live-repo-state poll. Mirrors DiffPanel's principle of
+   * never trusting a cached "is this a repo" flag (see diff-panel.ts
+   * showGitDiff/showFileDiffs/showStagedDiff, all gated on a fresh
+   * GitService.isGitRepo() check) but amortizes the cost for the header: the
+   * cheap synchronous isGitRepo() spawn runs every tick; the heavier async
+   * status()+branch() fetch (this.refresh()) only runs when that boolean
+   * actually flips — e.g. an external `git init`, or `.git` removed.
+   */
+  startPolling(intervalMs: number, onChange: (info: GitHeaderInfo) => void): void {
+    if (this.pollTimer !== null) return;
+    const checkIsRepo = (): boolean | null => {
+      try {
+        return GitService.isGitRepo(this.workingDirectory);
+      } catch (err) {
+        logger.debug('GitStatusProvider: isGitRepo poll check failed', { error: summarizeError(err) });
+        return null;
+      }
+    };
+    let lastKnownIsRepo = checkIsRepo();
+    this.pollTimer = setInterval(() => {
+      const isRepoNow = checkIsRepo();
+      if (isRepoNow !== null && isRepoNow !== lastKnownIsRepo) {
+        lastKnownIsRepo = isRepoNow;
+        this.refresh().then(onChange).catch((err) => {
+          logger.debug('GitStatusProvider: poll-triggered refresh failed', { error: summarizeError(err) });
+        });
+      }
+    }, intervalMs);
+  }
+
+  /** Stop the live-repo-state poll started by startPolling(). No-op if not polling. */
+  stopPolling(): void {
+    if (this.pollTimer !== null) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+
   private async _fetch(): Promise<void> {
     if (this.fetching) return;
     this.fetching = true;

package/src/renderer/help-overlay.ts

@@ -289,7 +289,7 @@ export function renderShortcutsOverlay(
     row(kb('block-copy'), 'Copy block to clipboard'),
     row(kb('block-save'), 'Save block to file'),
     row(kb('copy-selection'), 'Copy selection'),
-    row('F2', 'Process monitor'),
+    row('F2', 'Open the Fleet panel'),
     row('?', 'Help overlay'),
     row(`${kb('clear-cancel')} x2`, 'Exit'),
     '',
@@ -303,7 +303,7 @@ export function renderShortcutsOverlay(
     row(kb('panel-focus-toggle'), 'Swap focus between top / bottom pane'),
     row(kb('panel-close'), 'Close active panel'),
     row(kb('panel-close-all'), 'Close all panels'),
-    row(kb('panel-ops'), 'Open the Ops Control panel'),
+    row(kb('panel-ops'), 'Open and focus the Fleet panel'),
     '',
     '  In-Panel Controls',
     '  ' + '\u2500'.repeat(40),

package/src/renderer/model-workspace.ts

@@ -124,6 +124,10 @@ function modelKey(model: ModelDefinition): string {
 
 function targetSummary(info: ModelPickerTargetInfo): string {
   if (!info.enabled) return 'disabled';
+  // 'embeddings' has no model concept — configuredNote carries the honest
+  // provider id + dimensions + configured-state summary instead of a
+  // computed provider:model route (which would print a phantom "model:").
+  if (info.configuredNote) return info.configuredNote;
   const route = formatRoute(info.provider, info.model);
   if (info.inherited) return `inherits ${route}`;
   return route;
@@ -145,6 +149,7 @@ function targetLabelFor(target: string): string {
   if (target === 'helper') return 'Helper Model';
   if (target === 'tool') return 'Tool LLM';
   if (target === 'tts') return 'TTS LLM';
+  if (target === 'embeddings') return 'Embeddings';
   return 'Main Chat';
 }
 
@@ -174,6 +179,13 @@ function detailLines(picker: ModelPickerModal, width: number): string[] {
     }
   } else if (picker.mode === 'effort') {
     lines.push(`Reasoning effort applies to the main chat model. Select the default effort for this model.`);
+  } else if (picker.mode === 'embeddingProvider') {
+    lines.push('Embedding provider selection: choose the provider memory search and the code index use to embed content.');
+    const selectedEmbedding = picker.embeddingProviders[picker.selectedIndex];
+    if (selectedEmbedding) {
+      const status = selectedEmbedding.configured ? 'configured' : 'unconfigured';
+      lines.push(`Selected: ${selectedEmbedding.id} | ${selectedEmbedding.dimensions} dimensions | ${status}${selectedEmbedding.detail ? ` | ${selectedEmbedding.detail}` : ''}`);
+    }
   } else {
     lines.push(`Context cap overrides the detected local-model context window for this selection.`);
   }
@@ -288,6 +300,28 @@ function renderContextCapRows(picker: ModelPickerModal, lines: Line[], rows: num
   }
 }
 
+function renderEmbeddingProviderRows(picker: ModelPickerModal, lines: Line[], rows: number, startX: number, width: number): void {
+  const providers = picker.embeddingProviders;
+  const { start, end } = stableWindow(providers.length, picker.selectedIndex, rows);
+  for (let visibleRow = 0; visibleRow < rows; visibleRow += 1) {
+    const absolute = start + visibleRow;
+    const provider = providers[absolute];
+    const line = lines[visibleRow]!;
+    if (!provider) continue;
+    const selected = absolute === picker.selectedIndex;
+    const bg = selected ? PALETTE.selectedBg : PALETTE.bodyBg;
+    fillRange(line, startX, startX + width - 1, bg);
+    const marker = selected ? (picker.focusPane === 'items' ? GLYPHS.navigation.selected : '•') : ' ';
+    const status = provider.configured ? 'configured' : 'unconfigured';
+    writeText(line, startX + 1, width, padDisplay(marker, 2), { fg: PALETTE.text, bg, bold: selected });
+    writeText(line, startX + 3, Math.max(0, width - 30), padDisplay(provider.label, Math.max(0, width - 30)), { fg: selected ? PALETTE.text : PALETTE.muted, bg, bold: selected });
+    writeText(line, startX + Math.max(4, width - 25), 12, padDisplay(`${provider.dimensions}d`, 12), { fg: PALETTE.dim, bg });
+    writeText(line, startX + Math.max(4, width - 13), 12, padDisplay(status, 12), { fg: provider.configured ? PALETTE.good : PALETTE.warn, bg });
+  }
+  if (start > 0 && lines[0]) writeText(lines[0], startX + 1, width - 2, `${GLYPHS.navigation.moreAbove} ${start} more provider(s) above`, { fg: PALETTE.dim, bg: PALETTE.bodyBg, dim: true });
+  if (end < providers.length && lines[rows - 1]) writeText(lines[rows - 1]!, startX + 1, width - 2, `${GLYPHS.navigation.moreBelow} ${providers.length - end} more provider(s) below`, { fg: PALETTE.dim, bg: PALETTE.bodyBg, dim: true });
+}
+
 function writeTableHeader(line: Line, picker: ModelPickerModal, startX: number, width: number): void {
   fillRange(line, startX, startX + width - 1, PALETTE.footerBg);
   const style = { fg: PALETTE.muted, bg: PALETTE.footerBg, bold: true };
@@ -303,6 +337,10 @@ function writeTableHeader(line: Line, picker: ModelPickerModal, startX: number,
     writeText(line, startX + 1, width - 2, 'Context cap input', style);
     return;
   }
+  if (picker.mode === 'embeddingProvider') {
+    writeText(line, startX + 1, width - 2, 'Embedding provider                Dimensions   Status', style);
+    return;
+  }
   const providerW = clamp(Math.floor(width * 0.14), 10, 18);
   const ctxW = 8;
   const tierW = 8;
@@ -337,7 +375,7 @@ export function renderModelWorkspace(picker: ModelPickerModal, width: number, vi
   const header = contentLine(safeWidth, PALETTE.footerBg);
   writeText(header, 2, targetW - 2, 'Targets', { fg: PALETTE.subtitle, bold: true, bg: PALETTE.footerBg });
   drawVertical(header, targetW, PALETTE.footerBg);
-  const modeLabel = picker.mode === 'provider' ? 'Provider list' : picker.mode === 'model' ? 'Model list' : picker.mode === 'effort' ? 'Reasoning effort' : 'Context cap';
+  const modeLabel = picker.mode === 'provider' ? 'Provider list' : picker.mode === 'model' ? 'Model list' : picker.mode === 'effort' ? 'Reasoning effort' : picker.mode === 'embeddingProvider' ? 'Embedding providers' : 'Context cap';
   writeText(header, contentX + 1, contentW - 2, `${modeLabel}  •  ${picker.getItemCount()} item(s)`, { fg: PALETTE.subtitle, bold: true, bg: PALETTE.footerBg });
   lines.push(header);
 
@@ -380,6 +418,8 @@ export function renderModelWorkspace(picker: ModelPickerModal, width: number, vi
     renderModelRows(picker, listLines, listLines.length, contentX, contentW - 1);
   } else if (picker.mode === 'contextCap') {
     renderContextCapRows(picker, listLines, listLines.length, contentX, contentW - 1);
+  } else if (picker.mode === 'embeddingProvider') {
+    renderEmbeddingProviderRows(picker, listLines, listLines.length, contentX, contentW - 1);
   } else {
     renderEffortRows(picker, listLines, listLines.length, contentX, contentW - 1);
   }
@@ -432,6 +472,8 @@ function getRenderCacheKey(picker: ModelPickerModal, width: number, viewportHeig
     base.push(objectId(picker.effortLevels), picker.effortLevels.join('\u001f'), picker.pendingModel?.registryKey ?? picker.pendingModel?.id ?? '');
   } else if (picker.mode === 'contextCap') {
     base.push(picker.contextCapQuery, picker.contextCapPendingModel?.registryKey ?? picker.contextCapPendingModel?.id ?? '');
+  } else if (picker.mode === 'embeddingProvider') {
+    base.push(objectId(picker.embeddingProviders), picker.embeddingProviders.length);
   }
 
   return base.join('\u001e');
@@ -467,6 +509,7 @@ function keyForTargets(values: readonly ModelPickerTargetInfo[]): string {
       entry.model,
       entry.enabled ? 1 : 0,
       entry.inherited ? 1 : 0,
+      entry.configuredNote ?? '',
     ].join('\u001d'))
     .join('\u001f');
 }

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

@@ -21,12 +21,18 @@ export function renderPanelWorkspaceBar(
   return renderTabStrip({
     width,
     onLayout,
-    tabs: tabs.map((tab) => ({
+    tabs: tabs.map((tab, i) => ({
       // 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 ? ' ▸' : ''}`,
+      //
+      // A14: the pane marker uses ▲/▼ (top/bottom pane). The old '^'/'v'
+      // prefixes read as a Ctrl caret (^) implying a non-existent Ctrl+<tab>
+      // hotkey. The REAL per-tab jump key is Alt+N (panel-tab-1..9), rendered
+      // here as ⌥N for the first nine tabs so the shown affordance matches the
+      // binding (tabs past nine have no Alt+N chord, so no index is shown).
+      label: `${tab.pane === 'bottom' ? '▼' : '▲'}${i < 9 ? ` ⌥${i + 1}` : ''} ${tab.icon} ${tab.name}${tab.focused ? ' ▸' : ''}`,
       active: tab.active,
     })),
     prefixLabel: ' PANELS ',

package/src/renderer/turn-injection.ts

@@ -0,0 +1,114 @@
+/**
+ * Per-turn knowledge injection record rendering (Wave-5 W5.2, wo803).
+ *
+ * The SDK's passive per-turn retrieval engine (wo801, W5.1 —
+ * packages/sdk/src/platform/agents/turn-knowledge-injection.ts) stores one
+ * `TurnInjectionRecord` per turn on `AgentRecord.turnInjections` (a bounded
+ * ring, default 20 entries) and appends the same record to the agent's
+ * session transcript as `{type:'knowledge_injection', turn, ...record}`.
+ *
+ * `TurnInjectionRecord` itself is not re-exported from the SDK's
+ * `platform/agents` barrel (only `AgentRecord.turnInjections` carries its
+ * structural shape through the already-public `platform/tools` barrel), so
+ * the entry type here is DERIVED from `AgentRecord` rather than imported by
+ * name — this needs no SDK export change.
+ *
+ * Reality check (updated wo805): as of Wave-5 wo805 the TUI's main interactive
+ * session DOES route through this engine. The SDK `Orchestrator` runs per-turn
+ * passive injection on the evolving primary conversation and records each turn
+ * on its own bounded ring, exposed via `Orchestrator.getTurnInjections()` — the
+ * main-session counterpart to `AgentRecord.turnInjections` (there is no
+ * AgentRecord for the primary conversation). `buildMainSessionTurnInjectionsText`
+ * renders that ring for `/recall injections` with no agent id. Spawned agents
+ * (Task-tool runs, automation-triggered runs, session continuations) still
+ * record onto their own `AgentRecord.turnInjections`, rendered per-agent by
+ * `buildTurnInjectionsText` when an explicit agent id is given.
+ */
+import type { AgentRecord } from '@pellux/goodvibes-sdk/platform/tools';
+
+/** One TurnInjectionRecord entry, derived from AgentRecord (see module doc). */
+export type TurnInjectionEntry = NonNullable<AgentRecord['turnInjections']>[number];
+
+function fmtN(n: number): string {
+  return n.toLocaleString();
+}
+
+/** Render a single TurnInjectionRecord as one readable line. */
+export function formatTurnInjectionEntry(entry: TurnInjectionEntry): string {
+  const backendTag = entry.embeddingBackend === 'fallback-lexical' ? ' [lexical fallback]' : '';
+  if (entry.injectedIds.length === 0) {
+    // Honest empty state: the engine ran this turn but injected nothing —
+    // distinct from "the engine never ran" (see buildTurnInjectionsText).
+    const reasonText = entry.reason === 'no records cleared relevance floor'
+      ? 'nothing injected this turn — nothing cleared the relevance floor'
+      : `nothing injected this turn — ${entry.reason ?? 'unknown reason'}`;
+    return `  turn ${entry.turn}: ${reasonText}${backendTag} (considered ${entry.candidatesConsidered}, floor ${entry.relevanceFloor})`;
+  }
+  const droppedStr = entry.droppedForBudget.length > 0
+    ? `, dropped for budget: ${entry.droppedForBudget.join(', ')}`
+    : '';
+  // The retrieval query is part of the record's honesty contract — without it
+  // an injected line can't be traced back to WHY those ids were retrieved
+  // (Wave-5 replay flagged the omission). Truncated to keep the line scannable.
+  const queryStr = entry.query ? ` for ${JSON.stringify(truncateQuery(entry.query))}` : '';
+  return (
+    `  turn ${entry.turn}: injected ${entry.injectedIds.join(', ')}${queryStr} ` +
+    `(~${fmtN(entry.tokenCost)}/${fmtN(entry.budgetTokens)} tok, floor ${entry.relevanceFloor})${droppedStr}${backendTag}`
+  );
+}
+
+function truncateQuery(query: string): string {
+  const flat = query.replace(/\s+/g, ' ').trim();
+  return flat.length > 48 ? `${flat.slice(0, 47)}…` : flat;
+}
+
+/**
+ * Render the full per-turn injection history for one agent, most-recent-turn
+ * first, with an honest empty state when nothing has been recorded yet.
+ *
+ * An empty `entries` array is deliberately ambiguous about WHY it's empty
+ * (flag disabled, no turn with new input has run yet, or every turn's token
+ * budget had no headroom) — the SDK does not distinguish these cases in the
+ * ring itself, so this renders all three possibilities rather than guessing.
+ */
+export function buildTurnInjectionsText(agentId: string, entries: readonly TurnInjectionEntry[]): string {
+  if (entries.length === 0) {
+    return (
+      `[recall] No per-turn injection records for agent ${agentId} yet. This means one of: ` +
+      'passive knowledge injection is disabled, no turn with new input has run yet, or the ' +
+      'token budget had no headroom on every turn so far — there is no record either way.'
+    );
+  }
+  const lines = [`[recall] Per-turn knowledge injections for agent ${agentId} (${entries.length}, most recent first):`];
+  for (const entry of [...entries].reverse()) {
+    lines.push(formatTurnInjectionEntry(entry));
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Render the MAIN interactive session's per-turn injection ring
+ * (`Orchestrator.getTurnInjections()`, wo805), most-recent-turn first, with the
+ * same honest empty state as the per-agent path. The main-session counterpart
+ * to {@link buildTurnInjectionsText}: no agent id, main-session-appropriate
+ * wording, but the identical per-entry rendering (`formatTurnInjectionEntry`).
+ *
+ * As with the agent path, an empty `entries` array is deliberately ambiguous
+ * about WHY it's empty (flag disabled, no turn with new input has run yet, or
+ * every turn's token budget had no headroom) — the ring does not distinguish
+ * these, so this renders all three possibilities rather than guessing.
+ */
+export function buildMainSessionTurnInjectionsText(entries: readonly TurnInjectionEntry[]): string {
+  if (entries.length === 0) {
+    return (
+      '[recall] No per-turn injection records for the main session yet. This means one of: ' +
+      'passive knowledge injection is disabled, no turn with new input has run yet, or the ' +
+      'token budget had no headroom on every turn so far — there is no record either way.'
+    );
+  }
+  const lines = [`[recall] Per-turn knowledge injections for the main session (${entries.length}, most recent first):`];
+  for (const entry of [...entries].reverse()) {
+    lines.push(formatTurnInjectionEntry(entry));
+  }
+  return lines.join('\n');
+}