@pellux/goodvibes-tui 1.1.0 → 1.9.0

package/src/core/conversation-rendering.ts

@@ -1,8 +1,10 @@
 import { UIFactory } from '../renderer/ui-factory.ts';
 import { renderMarkdownTracked } from '../renderer/markdown.ts';
 import { renderDiffView } from '../renderer/diff-view.ts';
-import { DARK_THEME } from '../renderer/theme.ts';
+import { activeTheme } from '../renderer/theme.ts';
 import { renderToolCallBlock } from '../renderer/tool-call.ts';
+import { summarizeToolResult } from '../renderer/tool-result-summary.ts';
+import type { ToolCall } from '@pellux/goodvibes-sdk/platform/types';
 import { renderThinkingBlock } from '../renderer/thinking.ts';
 import { renderSystemMessage } from '../renderer/system-message.ts';
 import { createEmptyLine, type Line, type Cell } from '../types/grid.ts';
@@ -20,7 +22,9 @@ import { extractUserDisplayText } from '@pellux/goodvibes-sdk/platform/core';
 //   conversation-rendering.ts → system-message-router.ts → conversation.ts → conversation-rendering.ts
 import type { SystemMessageKind } from '@/runtime/index.ts';
 
-const T = DARK_THEME;
+// Transcript tokens are read live per render (const T = activeTheme() at the top
+// of each render function that styles content) so a dark→light repaint
+// re-resolves with no module reload. See theme.ts's active-mode runtime note.
 
 /**
  * Navigable system message kinds for error-navigation (nextErrorLine/prevErrorLine).
@@ -38,6 +42,20 @@ const NAVIGABLE_KINDS: ReadonlySet<SystemMessageKind> = new Set(['system', 'wrfc
 
 type Message = ConversationMessageSnapshot;
 
+/**
+ * Collect the ids of tool calls that have a matching tool-result message in the
+ * given slice — i.e. the tools that actually ran. Used to decide whether an
+ * assistant tool call still shows as pending (awaiting approval) or done.
+ * (UX-B item 2c.)
+ */
+export function collectCompletedToolCallIds(messages: readonly Message[]): Set<string> {
+  const ids = new Set<string>();
+  for (const message of messages) {
+    if (message.role === 'tool' && message.callId) ids.add(message.callId);
+  }
+  return ids;
+}
+
 function summarizeCallId(callId: string, maxLength = 24): string {
   return callId.length <= maxLength ? callId : `${callId.slice(0, maxLength - 1)}…`;
 }
@@ -55,6 +73,15 @@ export interface ConversationRenderContext {
   readonly messageKindRegistry: ReadonlyMap<number, SystemMessageKind>;
   readonly configManager: ConfigManager | null;
   readonly splashOptions: SplashOptions;
+  /**
+   * Tool-call ids that have a corresponding tool-result message (i.e. the tool
+   * actually ran). An assistant tool call whose id is NOT in this set is still
+   * awaiting a decision (e.g. an approval prompt) and renders with a pending
+   * glyph instead of the completed ✓. When undefined (single-message callers
+   * without sibling context), every tool call renders as done — the prior
+   * behaviour. (UX-B item 2c.)
+   */
+  readonly completedToolCallIds?: ReadonlySet<string>;
 }
 
 export function renderConversationUserMessage(
@@ -62,6 +89,7 @@ export function renderConversationUserMessage(
   message: Extract<Message, { role: 'user' }>,
   width: number,
 ): void {
+  const T = activeTheme();
   const displayText = extractUserDisplayText(message.content);
   if (message.cancelled) {
     context.history.addLines(UIFactory.createMessageBar(width, displayText, T.errorBarBg, '196', ' x ', true));
@@ -78,6 +106,7 @@ export function renderConversationAssistantMessage(
   collapseThreshold: number,
   msgIdx: number,
 ): void {
+  const T = activeTheme();
   const assistantHeaderDetails = [];
   if (message.model) {
     assistantHeaderDetails.push({ text: ` ${message.model}${message.provider ? ` (${message.provider})` : ''} `, fg: T.modelNameDim, dim: true });
@@ -195,7 +224,11 @@ export function renderConversationAssistantMessage(
 
   if (message.toolCalls && message.toolCalls.length > 0) {
     for (const tc of message.toolCalls) {
-      context.history.addLines(renderToolCallBlock(tc, 'done', undefined, width));
+      // A tool call with no result message yet is still awaiting a decision
+      // (e.g. approval) — show a pending glyph, not the completed ✓.
+      const ran = context.completedToolCallIds === undefined
+        || (tc.id !== undefined && context.completedToolCallIds.has(tc.id));
+      context.history.addLines(renderToolCallBlock(tc, ran ? 'done' : 'pending', undefined, width));
     }
   }
 }
@@ -223,6 +256,7 @@ export function renderConversationToolMessage(
   width: number,
   msgIdx: number,
 ): void {
+  const T = activeTheme();
   const collapseKey = `msg_${msgIdx}`;
   const blockIdx = context.blockRegistry.length;
   const startLine = context.history.getLineCount();
@@ -236,7 +270,17 @@ export function renderConversationToolMessage(
   // block-registry meta merge below regardless of collapsed/expanded state.
   const diffParse = isDiff ? parseDiffForApply(message.content) : undefined;
 
-  const isShort = message.content.length <= 200;
+  // Human one-line summary for tool results (write/read/exec/edit): shown as the
+  // collapsed line so the transcript reads "wrote foo.txt (532 B)" instead of a
+  // raw JSON blob; the full payload stays behind the expand toggle. Only for
+  // 'tool' blocks (diffs render their own view). (UX-B item 3.)
+  const resultSummary = blockType === 'tool'
+    ? summarizeToolResult(message.toolName, message.content)
+    : null;
+
+  // A summarizable result is kept collapsed-by-default even when short, so the
+  // one-line summary wins and the raw JSON is tucked behind the expand toggle.
+  const isShort = message.content.length <= 200 && resultSummary === null;
   const isCollapsed = isShort
     ? false
     : context.collapseState.has(collapseKey)
@@ -262,11 +306,20 @@ export function renderConversationToolMessage(
 
   if (isCollapsed) {
     const collapseSuffixReserve = 30;
-    const preview = contentLines[0].slice(0, width - LAYOUT.LEFT_MARGIN - LAYOUT.RIGHT_MARGIN - collapseSuffixReserve);
+    const avail = Math.max(0, width - LAYOUT.LEFT_MARGIN - LAYOUT.RIGHT_MARGIN - collapseSuffixReserve);
     const hiddenCount = lineCount - 1;
-    const collapsedText = hiddenCount > 0
-      ? `${preview}...  [${GLYPHS.navigation.collapsed} ${hiddenCount} hidden]`
-      : preview;
+    let collapsedText: string;
+    if (resultSummary !== null) {
+      // Summary line — the header already shows "▸ N lines", so no hidden badge.
+      collapsedText = resultSummary.length > avail
+        ? `${resultSummary.slice(0, Math.max(0, avail - 1))}…`
+        : resultSummary;
+    } else {
+      const preview = contentLines[0].slice(0, avail);
+      collapsedText = hiddenCount > 0
+        ? `${preview}...  [${GLYPHS.navigation.collapsed} ${hiddenCount} hidden]`
+        : preview;
+    }
     const rendered = renderConversationCollapsedFragment(collapsedText, width, {
       prefix: blockType === 'diff' ? ` ${GLYPHS.status.dualPane} ` : ` ${GLYPHS.navigation.collapsed} `,
       prefixFg: blockType === 'diff' ? T.diffAccent : T.toolAccent,
@@ -325,23 +378,28 @@ export function appendConversationMessages(
 ): void {
   const lineNumberMode = context.configManager?.get('display.lineNumbers') ?? 'off';
   const collapseThreshold = context.configManager?.get('display.collapseThreshold') ?? 30;
+  // Derive pending vs done for tool calls from sibling tool-result messages,
+  // unless the caller already supplied the set. (UX-B item 2c.)
+  const renderContext: ConversationRenderContext = context.completedToolCallIds !== undefined
+    ? context
+    : { ...context, completedToolCallIds: collectCompletedToolCallIds(messages) };
 
   for (let msgIdx = 0; msgIdx < messages.length; msgIdx++) {
     const message = messages[msgIdx];
     // absoluteIdx aligns the slice-relative loop counter with the absolute
     // message index used as the key in messageKindRegistry and messageLineRegistry.
     const absoluteIdx = msgIndexOffset + msgIdx;
-    messageLineRegistry[absoluteIdx] = context.history.getLineCount();
+    messageLineRegistry[absoluteIdx] = renderContext.history.getLineCount();
     if (message.role === 'user') {
-      renderConversationUserMessage(context, message, width);
+      renderConversationUserMessage(renderContext, message, width);
     } else if (message.role === 'assistant') {
-      renderConversationAssistantMessage(context, message, width, lineNumberMode, collapseThreshold, absoluteIdx);
+      renderConversationAssistantMessage(renderContext, message, width, lineNumberMode, collapseThreshold, absoluteIdx);
     } else if (message.role === 'system') {
-      renderConversationSystemMessage(context, message, width, absoluteIdx);
+      renderConversationSystemMessage(renderContext, message, width, absoluteIdx);
     } else if (message.role === 'tool') {
-      renderConversationToolMessage(context, message, width, absoluteIdx);
+      renderConversationToolMessage(renderContext, message, width, absoluteIdx);
     }
-    context.history.addLine(createEmptyLine(width));
+    renderContext.history.addLine(createEmptyLine(width));
   }
 }
 
@@ -402,3 +460,21 @@ export function logConversationText(
   const lines = text.split('\n').map((line) => UIFactory.stringToLine(indent + line, width, style));
   context.history.addLines(lines);
 }
+
+/**
+ * logConversationToolResult - Append a single tool-call-style result line to the
+ * display history only, reusing renderToolCallBlock so a display-only render (e.g.
+ * a slash command's subprocess result) is visually indistinguishable from the
+ * model's own tool-call results. Display-only: never touches message history.
+ */
+export function logConversationToolResult(
+  context: Pick<ConversationRenderContext, 'history'>,
+  width: number,
+  toolCall: ToolCall,
+  status: 'done' | 'error',
+  resultSummary: string,
+  durationMs: number,
+  errorMsg?: string,
+): void {
+  context.history.addLines(renderToolCallBlock(toolCall, status, resultSummary, width, durationMs, errorMsg));
+}

package/src/core/conversation.ts

@@ -18,6 +18,7 @@ import {
   addConversationSplashScreen,
   conversationTextToLines,
   logConversationText,
+  logConversationToolResult,
   renderConversationAssistantMessage,
   renderConversationSystemMessage,
   renderConversationToolMessage,
@@ -727,6 +728,23 @@ export class ConversationManager extends SdkConversationManager {
     logConversationText(this.renderingContext(), this._getWidth(), text, style, indent);
   }
 
+  /**
+   * logToolResultBlock - Append a single tool-call-styled result line to the display
+   * history only (never touches the LLM message list), so a slash command's subprocess
+   * result (e.g. /test) renders visually identical to a real tool-call result without
+   * leaking into model context.
+   */
+  public logToolResultBlock(
+    toolCall: ToolCall,
+    status: 'done' | 'error',
+    resultSummary: string,
+    durationMs: number,
+    errorMsg?: string,
+  ): void {
+    logConversationToolResult(this.renderingContext(), this._getWidth(), toolCall, status, resultSummary, durationMs, errorMsg);
+    this.markDirty();
+  }
+
   /**
    * clearDisplay - Clear the visual history buffer without touching the LLM context messages.
    * The next render will show a blank conversation area. Subsequent message additions

package/src/core/focus-tracker.ts

@@ -0,0 +1,41 @@
+/**
+ * focus-tracker — tracks whether the terminal window currently has OS-level
+ * input focus, using the terminal focus-reporting protocol (DECSET ?1004h,
+ * enabled at terminal setup in main.ts). The SDK's InputTokenizer already
+ * parses the resulting `\x1b[I` (focus-in) / `\x1b[O` (focus-out) sequences
+ * into `{ type: 'focus', action }` tokens (platform/core/tokenizer.ts); this
+ * module is the single place those tokens land (consumed in
+ * src/input/handler-feed.ts's feedInputTokens()).
+ *
+ * Honest degradation: a terminal that does not implement focus reporting
+ * (or a multiplexer that swallows the sequences) never sends focus tokens.
+ * In that case `isFocused()` stays `null` forever — "unknown", never a
+ * guessed `true`/`false`. Callers that gate a user-facing behavior on focus
+ * (e.g. the unfocused-alert notifiers in this directory) must treat `null`
+ * the same as "not focused" per the fallback rule: alerts fire when the
+ * terminal is definitely unfocused OR when focus state was never observed.
+ */
+export class FocusTracker {
+  private focused: boolean | null = null;
+
+  /** True/false once at least one focus token has arrived; null if none ever has. */
+  isFocused(): boolean | null {
+    return this.focused;
+  }
+
+  /** Called from the input pipeline on every focus token. */
+  setFocused(value: boolean): void {
+    this.focused = value;
+  }
+
+  /**
+   * The alert-gating rule shared by every unfocused-alert notifier: fire
+   * when the terminal is known to be unfocused, or when focus was never
+   * observed (honest fallback — never silently suppress on an unknown
+   * terminal). Only `isFocused() === true` (a real, observed focus-in with
+   * no observed focus-out since) suppresses an alert.
+   */
+  shouldAlertWhenUnfocused(): boolean {
+    return this.focused !== true;
+  }
+}

package/src/core/long-task-notifier.ts

@@ -18,15 +18,21 @@
  * When neither target is available the function is an honest no-op (debug log
  * only; no user-facing error spam).
  *
- * Focus tracking: terminal focus state is not tracked anywhere in the TUI.
- * Notifications therefore fire regardless of whether the terminal window is
- * focused. A future implementation may suppress notifications when the TUI is
- * in the foreground by reading a focus-state ref. // seam: wire focus ref here.
+ * Focus tracking (W2.3): when `focusTracker` is supplied, notifications are
+ * gated the same way as the other unfocused-user alert classes (see
+ * alert-gating.ts) — they fire when the terminal is unfocused or focus state
+ * was never observed, and are suppressed when it's known to be focused,
+ * unless `behavior.notifyOnlyWhenUnfocused` is turned off. `focusTracker` is
+ * optional and defaults to "always fire" (the pre-W2.3 behavior) when
+ * omitted, so existing callers that don't have a FocusTracker in scope are
+ * unaffected.
  */
 
 import { notifyCompletion } from '@pellux/goodvibes-sdk/platform/utils';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import type { WebhookNotifier } from '@pellux/goodvibes-sdk/platform/integrations';
+import type { FocusTracker } from './focus-tracker.ts';
+import { readNotifyOnlyWhenUnfocused, type ConfigGet } from './alert-gating.ts';
 
 /** Default threshold in seconds. Turns shorter than this do not notify. */
 export const NOTIFY_AFTER_SECONDS_DEFAULT = 60;
@@ -74,6 +80,18 @@ export interface MaybeNotifyLongTaskOptions {
    * skipped silently.
    */
   readonly webhookNotifier?: WebhookNotifier | null;
+
+  /**
+   * Terminal focus tracker (W2.3). When supplied together with `configGet`,
+   * the notification additionally respects behavior.notifyOnlyWhenUnfocused
+   * (default on): suppressed when the terminal is known to be focused, fires
+   * when unfocused or when focus was never observed. Omit both to preserve
+   * pre-W2.3 behavior (always fire once the threshold is met).
+   */
+  readonly focusTracker?: Pick<FocusTracker, 'shouldAlertWhenUnfocused'> | null;
+
+  /** Config reader used only for the notifyOnlyWhenUnfocused gate above. */
+  readonly configGet?: ConfigGet;
 }
 
 /**
@@ -81,13 +99,14 @@ export interface MaybeNotifyLongTaskOptions {
  * exceeds the configured threshold.
  *
  * Returns true when at least one delivery was attempted, false when the
- * call was a no-op (threshold not reached, or off-state).
+ * call was a no-op (threshold not reached, off-state, or focus-gated off —
+ * see `focusTracker`/`configGet` above).
  *
  * PRIVACY: builds message text from structural metadata only (kind, elapsed,
  * status, sessionId). Never includes conversation content.
  */
 export function maybeNotifyLongTask(opts: MaybeNotifyLongTaskOptions): boolean {
-  const { elapsedMs, status, kind, sessionId, thresholdSeconds, webhookNotifier } = opts;
+  const { elapsedMs, status, kind, sessionId, thresholdSeconds, webhookNotifier, focusTracker, configGet } = opts;
 
   // Off-state: 0 disables notifications entirely.
   if (thresholdSeconds === NOTIFY_AFTER_SECONDS_OFF) {
@@ -102,6 +121,14 @@ export function maybeNotifyLongTask(opts: MaybeNotifyLongTaskOptions): boolean {
     return false;
   }
 
+  // Focus gate (W2.3): only applied when both a tracker and a config reader
+  // are supplied. Absent either one, behavior is unchanged from pre-W2.3
+  // (always fire once the threshold is met).
+  if (focusTracker && configGet && readNotifyOnlyWhenUnfocused(configGet) && !focusTracker.shouldAlertWhenUnfocused()) {
+    logger.debug('long-task-notifier: suppressed — terminal focused');
+    return false;
+  }
+
   // Build concise, metadata-only message. No conversation text.
   const statusLabel = status === 'ok' ? 'completed' : 'failed';
   const title = `GoodVibes — ${kind} ${statusLabel}`;

package/src/core/stream-event-wiring.ts

@@ -155,6 +155,20 @@ export interface WireStreamEventMetricsOptions {
    * unavailable for either model, the notice honestly states "cost data unavailable".
    */
   readonly costLookup?: FailoverCostLookup;
+  /**
+   * Optional accessor for whether an approval card is currently waiting on the USER. When it
+   * returns true, the stall watchdog does NOT emit its "Still waiting on <provider>… Ctrl+C to
+   * cancel" hint: the stream is legitimately silent because we asked the user a question, so
+   * blaming the provider (or framing it as a stall) would be dishonest. The approval surface owns
+   * the honest "Waiting for your approval" label instead.
+   */
+  readonly isApprovalPending?: (() => boolean) | undefined;
+  /**
+   * Stall watchdog threshold in ms. Defaults to the watchdog's own default (STALL_THRESHOLD_MS,
+   * 30 000). Exposed only so unit tests can drive the stall path without waiting 30s — production
+   * callers omit it.
+   */
+  readonly stallThresholdMs?: number | undefined;
 }
 
 /** Result of wireStreamEventMetrics. */
@@ -237,6 +251,7 @@ export function wireStreamEventMetrics(
   const {
     events, metrics, orchestrator, providerRegistry,
     systemMessageRouter, render, providerOptimizer, retryTurn, costLookup,
+    isApprovalPending, stallThresholdMs,
   } = options;
 
   const unsubs: Array<() => void> = [];
@@ -364,12 +379,16 @@ export function wireStreamEventMetrics(
   const stallWatchdog = createStreamStallWatchdog({
     events: events.turns,
     onStall: (providerName, episode) => {
+      // Suppress the provider-blaming stall hint while an approval card is waiting on the user: the
+      // stream is silent because WE asked the user a question, not because the provider stalled.
+      if (isApprovalPending?.()) return;
       metrics.stallEpisode = episode;
       systemMessageRouter.low(`Still waiting on ${providerName}… Ctrl+C to cancel`);
       render();
     },
     getProviderName: () => providerRegistry.getCurrentModel().provider,
-    // thresholdMs uses the default 30 000
+    // thresholdMs defaults to 30 000 in the watchdog; only unit tests override it.
+    ...(stallThresholdMs !== undefined ? { thresholdMs: stallThresholdMs } : {}),
   });
   unsubs.push(() => stallWatchdog.dispose());
 

package/src/core/system-message-noise.ts

@@ -0,0 +1,87 @@
+/**
+ * System-message noise policy — decides whether an operational status message
+ * should reach the transcript unchanged, be dropped, or be folded. Every noisy
+ * source these rules catch is emitted (from the SDK) through
+ * SystemMessageRouter, so this one funnel is where first-run plumbing is kept
+ * out of the user's stream while the information stays reachable elsewhere
+ * (fleet panel, /health, /model, activity log). (UX-B item 1.)
+ */
+
+export interface NoiseGateDeps {
+  /**
+   * True when a WRFC chain is terminal (passed/failed) or gone (killed/removed).
+   * Used to suppress stale "[Replay] … transitioned … waiting for action"
+   * re-notifications for chains that can no longer act. Absent → never suppress.
+   */
+  readonly isChainTerminal?: (chainId: string) => boolean;
+}
+
+export type NoiseVerdict =
+  /** Pass through to the transcript unchanged. */
+  | { readonly action: 'emit' }
+  /** Suppress entirely — reachable via another live surface. */
+  | { readonly action: 'drop' }
+  /** Provider "from last session" replay line — buffer and fold to one line. */
+  | { readonly action: 'foldProviderReplay' };
+
+const EMIT: NoiseVerdict = { action: 'emit' };
+const DROP: NoiseVerdict = { action: 'drop' };
+const FOLD: NoiseVerdict = { action: 'foldProviderReplay' };
+
+/** Matches the SDK's per-provider persisted-replay line (1b). */
+const PROVIDER_REPLAY_RE = / — from last session$/;
+
+/** Matches the SDK's 30s periodic running-agents snapshot (1d). */
+const AGENTS_RUNNING_SNAPSHOT_RE = /^\[Agents\] \d+ running:/;
+
+/** Extracts the chain id from a "[Replay]… WRFC chain <id> transitioned …" line (1c). */
+const REPLAY_CHAIN_RE = /WRFC chain (\S+) transitioned .* waiting for action/;
+
+/**
+ * Classify one system message. Pure aside from the injected `isChainTerminal`
+ * lookup, so it is trivially testable.
+ */
+export function classifyNoise(message: string, deps: NoiseGateDeps): NoiseVerdict {
+  // 1b — provider-discovery replay burst ("[Local] … — from last session").
+  if (message.startsWith('[Local]') && PROVIDER_REPLAY_RE.test(message)) {
+    return FOLD;
+  }
+
+  // 1d — periodic "[Agents] N running:" status snapshot. The same live detail
+  // is shown in the fleet panel (per-agent activity) and the footer count, so
+  // the 30-second transcript churn is dropped. Meaningful lifecycle lines
+  // ("[Agents] ✓ …", "[Agents] Cohort …", "[Agents] ✗ …") do not match.
+  if (AGENTS_RUNNING_SNAPSHOT_RE.test(message)) {
+    return DROP;
+  }
+
+  // 1c — stale "[Replay] … waiting for action" for a terminal/killed chain.
+  if (message.startsWith('[Replay]') && deps.isChainTerminal) {
+    const match = REPLAY_CHAIN_RE.exec(message);
+    if (match && deps.isChainTerminal(match[1])) return DROP;
+  }
+
+  return EMIT;
+}
+
+/** Provider name from a "[Local] <name> at host:port (…) — from last session" line. */
+export function providerNameFromReplay(message: string): string {
+  const match = /^\[Local\]\s+(.+?)\s+at\s/.exec(message);
+  if (match) return match[1];
+  // Fallback: first token after the tag.
+  const bare = /^\[Local\]\s+(\S+)/.exec(message);
+  return bare ? bare[1] : 'provider';
+}
+
+/**
+ * Build the single folded summary line for a burst of provider-replay lines.
+ * Names a few providers; the full list stays reachable via /health and /model.
+ */
+export function foldProviderReplayLines(messages: readonly string[]): string {
+  const names = messages.map(providerNameFromReplay);
+  const count = names.length;
+  const noun = count === 1 ? 'provider' : 'providers';
+  const shown = names.slice(0, 3).join(', ');
+  const extra = count > 3 ? `, +${count - 3} more` : '';
+  return `[Local] Restored ${count} ${noun} from last session (${shown}${extra})`;
+}