@pellux/goodvibes-agent 1.5.5 → 1.5.6

package/src/input/settings-modal.ts

@@ -17,6 +17,12 @@ import {
   type SettingsSecretsManager,
 } from './settings-modal-secrets.ts';
 import { buildSubscriptionEntries } from './settings-modal-subscriptions.ts';
+import {
+  coerceThemeModeSetting,
+  THEME_MODE_CONFIG_KEY,
+  THEME_MODE_DEFAULT,
+  THEME_MODE_SYNTHETIC_SETTING,
+} from '../renderer/theme-mode-config.ts';
 import type { FeatureFlagManager } from '@/runtime/index.ts';
 import type { FeatureFlag, FlagState } from '@/runtime/index.ts';
 import type { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
@@ -634,6 +640,21 @@ export class SettingsModal {
       if (this.groups.has(cat)) this.groups.get(cat)!.push(entry);
     }
 
+    // W4-R4: inject the synthetic display.themeMode enum (auto|dark|light) —
+    // agent-local key stored under the existing `display` section (not in the
+    // SDK ConfigKey union; setDynamic/get round-trip it), the TUI's
+    // settings-modal-data.ts synthetic-setting pattern. Cycles like any other
+    // enum entry; forced modes are applied by the ui-openers change hook.
+    const displayEntries = this.groups.get('display');
+    if (displayEntries && !displayEntries.some((e) => e.setting.key === (THEME_MODE_CONFIG_KEY as ConfigKey))) {
+      const themeModeValue = coerceThemeModeSetting(configManager.get(THEME_MODE_CONFIG_KEY as ConfigKey));
+      displayEntries.push({
+        setting: THEME_MODE_SYNTHETIC_SETTING,
+        currentValue: themeModeValue,
+        isDefault: themeModeValue === THEME_MODE_DEFAULT,
+      });
+    }
+
     const uiEntries = this.groups.get('ui');
     if (uiEntries) {
       const uiPriority: Record<string, number> = {

package/src/main.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env bun
 import { homedir } from 'node:os';
 import { Compositor } from './renderer/compositor.ts';
+import { installStartupThemeProbe } from './renderer/startup-theme-probe.ts';
+import { ThinkingStallClock, buildThinkingOverlay } from './core/thinking-overlay.ts';
 import { UIFactory } from './renderer/ui-factory.ts';
 import { Orchestrator } from './core/orchestrator';
 import { conversationMessagesAsSessionRecords } from './core/conversation-message-snapshot.ts';
@@ -47,6 +49,7 @@ import { wireShellUiOpeners } from './shell/ui-openers.ts';
 import { deriveComposerState } from './core/composer-state.ts';
 import { buildPersistedSessionContext } from '@/runtime/index.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { FOCUS_ENABLE, FOCUS_DISABLE, installFocusModeExitGuard, markFocusModeEnabled, wrapRequestPermissionWithApprovalAlert } from './shell/terminal-focus-mode.ts';
 import { prepareShellCliRuntime } from './cli/entrypoint.ts';
 import { applyInitialTuiCliState, formatFatalStartupErrorForLog, formatFatalStartupErrorForUser, getInteractiveTerminalLaunchError } from './cli/tui-startup.ts';
 import { wireSpokenTurnRuntime } from './audio/spoken-turn-wiring.ts';
@@ -56,6 +59,7 @@ import { buildCommandArgsHint } from './input/command-args-hint.ts';
 import { GOODVIBES_AGENT_PAIRING_SURFACE } from './config/surface.ts';
 import { createAutonomySurfacing, buildCalendarEventsLister, buildSkillDraftProposer } from './shell/autonomy-surfacing.ts';
 import { startHardwareProbe } from './core/hardware-profile.ts';
+import { readApprovalPostureFromConfig } from './permissions/approval-posture.ts';
 
 const ALT_SCREEN_ENTER = '\x1b[?1049h', ALT_SCREEN_EXIT = '\x1b[?1049l', MOUSE_ENABLE = '\x1b[?1000h\x1b[?1002h\x1b[?1006h', MOUSE_DISABLE = '\x1b[?1006l\x1b[?1002l\x1b[?1000l', CURSOR_HIDE = '\x1b[?25l', CURSOR_SHOW = '\x1b[?25h', CLEAR_SCREEN = '\x1b[2J\x1b[3J\x1b[H';
 const KEYBOARD_EXT_ENABLE = '\x1b[>4;2m' + '\x1b[?1u', KEYBOARD_EXT_DISABLE = '\x1b[>4;0m' + '\x1b[?1l', PASTE_ENABLE = '\x1b[?2004h', PASTE_DISABLE = '\x1b[?2004l';
@@ -63,6 +67,7 @@ const KEYBOARD_EXT_ENABLE = '\x1b[>4;2m' + '\x1b[?1u', KEYBOARD_EXT_DISABLE = '\
 async function main() {
   const stdout = process.stdout;
   const stdin = process.stdin;
+  installFocusModeExitGuard(stdout); // W4-R3 — see shell/terminal-focus-mode.ts
   const { cli, configManager, bootstrapWorkingDir, bootstrapHomeDirectory } = await prepareShellCliRuntime(process.argv.slice(2), {
     defaultWorkingDirectory: process.env['GOODVIBES_WORKING_DIR'] ?? process.cwd(),
     homeDirectory: process.env['GOODVIBES_AGENT_HOME'] ?? homedir(),
@@ -154,6 +159,8 @@ async function main() {
 
   let streamTokenSpeed = 0;
 
+  const thinkingClock = new ThinkingStallClock(); // W4-R4 thinking-indicator stall clock
+
   let scrollTop = 0;
   let scrollLocked = true;
 
@@ -265,7 +272,7 @@ async function main() {
     process.removeListener('SIGINT', sigintHandler);
     process.removeListener('unhandledRejection', unhandledRejectionHandler);
     const exitScreen = cli.flags.noAltScreen ? CLEAR_SCREEN : CLEAR_SCREEN + ALT_SCREEN_EXIT;
-    allowTerminalWrite(() => stdout.write(PASTE_DISABLE + KEYBOARD_EXT_DISABLE + MOUSE_DISABLE + CURSOR_SHOW + exitScreen));
+    allowTerminalWrite(() => stdout.write(PASTE_DISABLE + KEYBOARD_EXT_DISABLE + MOUSE_DISABLE + FOCUS_DISABLE + CURSOR_SHOW + exitScreen));
     terminalOutputGuard.dispose();
     stdin.setRawMode(false);
     process.exit(0);
@@ -394,14 +401,11 @@ async function main() {
     sidebarOverride = !(sidebarWidthFor(width) > 0);
     render();
   };
-  permissionPromptRef.requestPermission = (request) =>
-    new Promise((resolve) => {
-      pendingPermission = {
-        ...request,
-        resolve: (approved: boolean, remember = false) => resolve({ approved, remember }),
-      };
-      render();
-    });
+  const rawRequestPermission: typeof permissionPromptRef.requestPermission = (request) => new Promise((resolve) => { // W4-R3: see shell/terminal-focus-mode.ts
+    pendingPermission = { ...request, resolve: (approved: boolean, remember = false) => resolve({ approved, remember }) };
+    render();
+  });
+  permissionPromptRef.requestPermission = wrapRequestPermissionWithApprovalAlert(rawRequestPermission, { focusTracker: ctx.services.focusTracker });
 
   const input: InputHandler = new InputHandler(
     () => render(),
@@ -428,6 +432,7 @@ async function main() {
         tokenAuditor: ctx.services.tokenAuditor,
         replayEngine: ctx.services.replayEngine,
         webhookNotifier: ctx.services.webhookNotifier,
+        focusTracker: ctx.services.focusTracker,
         policyRuntimeState: ctx.services.policyRuntimeState,
         externalServices: uiServices.platform.externalServices,
       },
@@ -531,16 +536,12 @@ async function main() {
       provider: runtime.provider,
       contextWindow: currentModel.contextWindow,
       compactThreshold: configManager.get('behavior.autoCompactThreshold') as number,
-      dangerMode: (() => {
-        if (configManager.get('behavior.autoApprove')) return true;
-        const permMode = configManager.get('permissions.mode');
-        if (permMode === 'allow-all') return true;
-        if (permMode === 'custom') {
-          const tools = configManager.getCategory('permissions').tools;
-          if (Object.values(tools).every(v => v === 'allow')) return true;
-        }
-        return false;
-      })(),
+      // Single source of truth for "will this bypass the approval prompt?" —
+      // computed the same way cli/status.ts and the policy-explain tool
+      // compute it, so the footer can never disagree with them or with the
+      // permission gate itself (behavior.autoApprove first, then
+      // permissions.mode).
+      dangerMode: readApprovalPostureFromConfig(configManager).bypassesPrompts,
       lastInputTokens: orchestrator.lastInputTokens,
       commandArgsHint,
       hitlMode: modeManager.getHITLMode(),
@@ -597,21 +598,11 @@ async function main() {
     scrollTop = conversationViewport.nextScrollTop;
     let viewport = conversationViewport.viewport;
 
-    if (orchestrator.isThinking) {
-      const showSpeed = configManager.get('display.showTokenSpeed') as boolean;
-      const showPreview = configManager.get('display.showToolPreview') as boolean;
-      const partialToolPreview = showPreview ? sessionSnapshot.streamToolPreview : undefined;
-      const thinking = UIFactory.createThinkingFragment(
-        conversationWidth,
-        orchestrator.getSpinner(),
-        orchestrator.thinkingFrame,
-        showSpeed ? streamTokenSpeed : undefined,
-        showPreview ? partialToolPreview : undefined,
-        orchestrator.streamingInputTokens > 0 ? orchestrator.streamingInputTokens : undefined,
-        orchestrator.streamingOutputTokens > 0 ? orchestrator.streamingOutputTokens : undefined,
-      );
-      viewport.push(...thinking);
-    }
+    viewport.push(...buildThinkingOverlay({ // honest waiting state; [] when not thinking
+      orchestrator, configManager, streamTokenSpeed, clock: thinkingClock,
+      streamToolPreview: sessionSnapshot.streamToolPreview,
+      approvalPending: pendingPermission !== null, width: conversationWidth,
+    }));
 
     if (pendingPermission) {
       viewport.push(...PermissionPromptUI.createPromptLines(conversationWidth, pendingPermission));
@@ -699,7 +690,13 @@ async function main() {
   stdin.setRawMode(true);
   stdin.resume();
   stdin.setEncoding('utf8');
-  allowTerminalWrite(() => stdout.write((cli.flags.noAltScreen ? '' : ALT_SCREEN_ENTER) + CLEAR_SCREEN + CURSOR_HIDE + MOUSE_ENABLE + KEYBOARD_EXT_ENABLE + PASTE_ENABLE));
+  allowTerminalWrite(() => { markFocusModeEnabled(); return stdout.write((cli.flags.noAltScreen ? '' : ALT_SCREEN_ENTER) + CLEAR_SCREEN + CURSOR_HIDE + MOUSE_ENABLE + KEYBOARD_EXT_ENABLE + PASTE_ENABLE + FOCUS_ENABLE); });
+
+  // W4-R4: forced dark/light before first paint; auto (TTY) probes + repaints once if light.
+  const themeProbe = installStartupThemeProbe({
+    configManager, stdout, writeAllowed: allowTerminalWrite,
+    resetDiff: () => compositor.resetDiff(), render,
+  });
 
   applyInitialTuiCliState({
     cli,
@@ -710,7 +707,10 @@ async function main() {
     render,
   });
 
-  stdin.on('data', (data: string) => {
+  stdin.on('data', (raw: string) => {
+    // Strip any OSC 11 background-probe reply before the input pipeline sees it.
+    const data = themeProbe.filterInput(raw);
+    if (data.length === 0) return;
     const blocking = handleBlockingShellInput({
       data,
       pendingPermission,

package/src/permissions/approval-posture.ts

@@ -0,0 +1,141 @@
+import { isAutoApproveEnabled } from '@pellux/goodvibes-sdk/platform/config';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+
+/**
+ * ApprovalPosture — the single source of truth for "what will happen when a
+ * tool runs right now", displayed identically everywhere the Agent surfaces
+ * approval posture (cli status, cli doctor, the security policy-explain tool,
+ * and the footer's danger indicator).
+ *
+ * Mirrors PermissionManager.checkDetailed()'s exact precedence (SDK
+ * dist/platform/permissions/manager.js:103-138), which this module does not
+ * modify — the gate is correct; the historical bug was surfaces disagreeing
+ * about what the gate does:
+ *   1. behavior.autoApprove === true -> every tool call is approved
+ *      automatically, before permissions.mode is even read.
+ *   2. permissions.mode === 'allow-all' -> every tool call is approved
+ *      automatically.
+ *   3. permissions.mode === 'custom' -> each tool category is allowed,
+ *      prompted, or denied per its own configured rule; bypassesPrompts is
+ *      true only when EVERY configured tool category resolves to 'allow'
+ *      (the only custom configuration where nothing ever prompts).
+ *   4. permissions.mode === 'prompt' (the default) -> read-only actions are
+ *      auto-allowed; write, execute, and delegate actions prompt.
+ *
+ * Any surface that wants to say "will this prompt me?" must call
+ * computeApprovalPosture (or the config-reading convenience below) rather
+ * than re-deriving the precedence locally — that re-derivation is exactly
+ * how cli/status.ts drifted from the gate (it read permissions.mode alone
+ * and never looked at behavior.autoApprove).
+ */
+
+export type ApprovalPostureKind = 'auto-approve' | 'allow-all' | 'custom' | 'prompt';
+
+export interface ApprovalPostureInput {
+  /** behavior.autoApprove, read via the SDK's isAutoApproveEnabled (or an equivalent duck-typed read). */
+  readonly autoApprove: boolean;
+  /** permissions.mode, as read from config (may be unknown/malformed input from a loose config source). */
+  readonly mode: unknown;
+  /**
+   * permissions.tools, only consulted when mode === 'custom'. Values are the
+   * per-tool-category actions ('allow' | 'prompt' | 'deny'); anything else
+   * (missing/unrecognized) counts as NOT allow for the bypass computation.
+   */
+  readonly customTools?: Readonly<Record<string, unknown>>;
+}
+
+export interface ApprovalPosture {
+  /** Which precedence branch produced this posture. */
+  readonly kind: ApprovalPostureKind;
+  /** The raw permissions.mode value, normalized to a known mode string (defaults to 'prompt'). */
+  readonly mode: 'prompt' | 'allow-all' | 'custom';
+  /** The raw behavior.autoApprove value that drove this posture. */
+  readonly autoApprove: boolean;
+  /**
+   * True when NO tool call will ever hit a Human-in-the-Loop prompt under the
+   * current configuration — mirrors the gate's "auto-approve everything"
+   * branches (autoApprove, allow-all, and custom-all-allow).
+   */
+  readonly bypassesPrompts: boolean;
+  /** A short, honest, human-facing label — always names auto-approve explicitly when it is what is actually gating tool calls. */
+  readonly label: string;
+  /** A one-sentence explanation of the mechanism, suitable for a doctor/status detail line. */
+  readonly detail: string;
+}
+
+function normalizeMode(mode: unknown): 'prompt' | 'allow-all' | 'custom' {
+  if (mode === 'allow-all' || mode === 'custom') return mode;
+  return 'prompt';
+}
+
+/**
+ * Pure precedence computation — no config access. Every display surface
+ * should route its "what is the approval posture" question through this
+ * function so they provably agree with each other and with the gate.
+ */
+export function computeApprovalPosture(input: ApprovalPostureInput): ApprovalPosture {
+  const mode = normalizeMode(input.mode);
+
+  if (input.autoApprove) {
+    return {
+      kind: 'auto-approve',
+      mode,
+      autoApprove: true,
+      bypassesPrompts: true,
+      label: 'Auto-approve ON — powerful actions run without asking',
+      detail: 'behavior.autoApprove is enabled: every tool call is approved automatically, regardless of permissions.mode or any custom per-tool rule.',
+    };
+  }
+
+  if (mode === 'allow-all') {
+    return {
+      kind: 'allow-all',
+      mode,
+      autoApprove: false,
+      bypassesPrompts: true,
+      label: 'Allow everything',
+      detail: 'permissions.mode is allow-all: every tool call is approved automatically.',
+    };
+  }
+
+  if (mode === 'custom') {
+    const values = Object.values(input.customTools ?? {});
+    const allAllow = values.length > 0 && values.every((value) => value === 'allow');
+    return {
+      kind: 'custom',
+      mode,
+      autoApprove: false,
+      bypassesPrompts: allAllow,
+      label: allAllow ? 'Custom rules (every category allows — no prompts)' : 'Custom rules',
+      detail: allAllow
+        ? 'permissions.mode is custom and every configured tool category is set to allow: no tool call prompts.'
+        : 'permissions.mode is custom: each tool category is allowed, prompted, or denied per its own configured rule.',
+    };
+  }
+
+  return {
+    kind: 'prompt',
+    mode: 'prompt',
+    autoApprove: false,
+    bypassesPrompts: false,
+    label: 'Ask before powerful actions',
+    detail: 'permissions.mode is prompt (default): read-only actions are auto-allowed; write, execute, and delegate actions prompt for approval.',
+  };
+}
+
+/**
+ * Convenience for callers holding a real ConfigManager (or any subset
+ * exposing `get` + `getCategory`): reads behavior.autoApprove and
+ * permissions.mode/tools the same way the gate does and computes the posture.
+ */
+export function readApprovalPostureFromConfig(
+  configManager: Pick<ConfigManager, 'get' | 'getCategory'>,
+): ApprovalPosture {
+  const autoApprove = isAutoApproveEnabled(configManager);
+  const permissions = configManager.getCategory('permissions');
+  return computeApprovalPosture({
+    autoApprove,
+    mode: permissions.mode,
+    customTools: { ...permissions.tools },
+  });
+}

package/src/renderer/agent-workspace-context-lines.ts

@@ -28,6 +28,14 @@ function formatMegabytes(bytes: number): string {
   return `${Math.round(bytes / (1024 * 1024))} MB`;
 }
 
+// W4-A6: the memory/routine counts below are re-derived live on every
+// repaint (AgentWorkspace.syncLiveCountersForRender). If that live read
+// fails, liveCountersStale flags it so we say so instead of asserting a
+// number the disk might already contradict.
+function liveCounterStaleSuffix(snapshot: AgentWorkspaceRuntimeSnapshot): string {
+  return snapshot.liveCountersStale ? ' (refreshing...)' : '';
+}
+
 export function compactText(text: string, maxWidth = 104): string {
   const normalized = text.replace(/\s+/g, ' ').trim();
   if (normalized.length === 0) return '';
@@ -546,7 +554,7 @@ export function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspac
       ...snapshot.localRoutines.filter((item) => item.enabled),
     ].filter((item) => item.reviewState !== 'reviewed').length;
     base.push(
-      { text: `Memory: ${snapshot.localMemoryCount}; prompt ${snapshot.localMemoryPromptActiveCount}; queue ${snapshot.localMemoryReviewQueueCount}; session ${snapshot.sessionMemoryCount}.`, fg: PALETTE.info },
+      { text: `Memory: ${snapshot.localMemoryCount}; prompt ${snapshot.localMemoryPromptActiveCount}; queue ${snapshot.localMemoryReviewQueueCount}; session ${snapshot.sessionMemoryCount}.${liveCounterStaleSuffix(snapshot)}`, fg: PALETTE.info },
       { text: `Notes: ${snapshot.localNoteCount}; skills ${snapshot.localSkillCount}/${snapshot.enabledSkillCount}; routines ${snapshot.localRoutineCount}/${snapshot.enabledRoutineCount}; personas ${snapshot.localPersonaCount}.`, fg: PALETTE.info },
       { text: `Learning curator: memory queue ${snapshot.localMemoryReviewQueueCount}; note queue ${snapshot.localNoteReviewQueueCount}; setup gaps ${behaviorNeedsSetup}; injected review ${injectedNeedsReview}.`, fg: behaviorNeedsSetup > 0 || injectedNeedsReview > 0 ? PALETTE.warn : PALETTE.good },
       { text: 'Prompt plan: score reviewed context, show suppressed records, and route review before behavior expands.', fg: PALETTE.good },
@@ -581,7 +589,7 @@ export function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspac
     const needsSetup = routinesNeedingSetup(snapshot);
     const needsReview = routinesNeedingReview(snapshot);
     base.push(
-      { text: `Routines: ${snapshot.localRoutineCount}; enabled: ${snapshot.enabledRoutineCount}`, fg: PALETTE.info },
+      { text: `Routines: ${snapshot.localRoutineCount}; enabled: ${snapshot.enabledRoutineCount}${liveCounterStaleSuffix(snapshot)}`, fg: PALETTE.info },
       { text: `Schedule-ready routines: ${ready.length}; setup gaps: ${needsSetup.length}; review needed: ${needsReview.length}`, fg: needsSetup.length > 0 || needsReview.length > 0 ? PALETTE.warn : PALETTE.good },
       routineNextActionLine(snapshot),
       compactRoutineReceiptLine(snapshot),

package/src/renderer/compositor.ts

@@ -4,6 +4,8 @@ import { type Line, createEmptyCell, createEmptyLine, createStyledCell } from '.
 import { getDisplayWidth } from '../utils/terminal-width.ts';
 import type { SearchManager } from '../input/search.ts';
 import { allowTerminalWrite } from '../runtime/terminal-output-guard.ts';
+import { probeTermCaps, type TermColorCaps } from './term-caps.ts';
+import { activeTheme } from './theme.ts';
 
 export interface SelectionInfo {
   isCellSelected: (col: number, absoluteRow: number) => boolean;
@@ -43,9 +45,24 @@ export class Compositor {
   /** Double-buffer reuse: back is written, front is the last-rendered reference. */
   private frontBuffer: TerminalBuffer | null = null;
   private backBuffer: TerminalBuffer | null = null;
-  private diffEngine = new DiffEngine();
+  private readonly caps: TermColorCaps;
+  private diffEngine: DiffEngine;
+
+  constructor(private stdout: NodeJS.WriteStream) {
+    // Probe terminal color capabilities once at construction time so the
+    // DiffEngine downsamples every emitted SGR to the terminal's real level.
+    // The hardcoded truecolor search-highlight hex below (and any future theme
+    // colors) is therefore cap-gated — no raw #rrggbb leaks on a non-truecolor
+    // terminal. (R4 later replaces the hardcoded hex with live activeTheme()
+    // reads in its tone-read region; this R2 region owns only the caps wiring.)
+    this.caps = probeTermCaps(stdout);
+    this.diffEngine = new DiffEngine(this.caps);
+  }
 
-  constructor(private stdout: NodeJS.WriteStream) {}
+  /** Exposed for unit tests — returns the detected color capability. */
+  public get termCapsForTest(): TermColorCaps {
+    return this.caps;
+  }
 
   /** Exposed for unit tests — returns the last composited buffer. */
   public get lastBufferForTest(): TerminalBuffer | null {
@@ -86,6 +103,12 @@ export class Compositor {
     const lineCount = selection?.lineCount ?? 0;
     const offset = Math.max(0, vHeight - lineCount);
 
+    // R4 tone-read region (the compositor is the pre-ruled R2→R4 shared file;
+    // R2 owns the DiffEngine caps wiring above, R4 owns these live theme reads).
+    // Read the search-highlight tones live per frame so they flip in light mode;
+    // dark is byte-identical (the searchCurrent/searchMatch tones resolve to the
+    // prior hardcoded yellow/gold pair). The separator stays a neutral dim grey.
+    const T = activeTheme();
     const sepFg = '238';
 
     viewport.forEach((line, i) => {
@@ -147,9 +170,9 @@ export class Compositor {
           const isCurrent = search.manager.isCurrentMatch(absoluteRow, match.col);
           for (let x = match.col; x < match.col + match.length && x < leftWidth; x++) {
             if (isCurrent) {
-              newBuffer.setCell(x, screenY, { bg: '#ffff00', fg: '#000000', bold: true, dim: false });
+              newBuffer.setCell(x, screenY, { bg: T.searchCurrentBg, fg: T.searchCurrentFg, bold: true, dim: false });
             } else {
-              newBuffer.setCell(x, screenY, { bg: '#806600', fg: '#ffffff', bold: false, dim: false });
+              newBuffer.setCell(x, screenY, { bg: T.searchMatchBg, fg: T.searchMatchFg, bold: false, dim: false });
             }
           }
         }

package/src/renderer/diff.ts

@@ -1,8 +1,18 @@
 import { TerminalBuffer } from './buffer.ts';
 import { type Cell } from '../types/grid.ts';
+import {
+  type TermColorCaps,
+  downsampleColor,
+  wrapSynced,
+} from './term-caps.ts';
 
 /**
  * DiffEngine - Generates minimal ANSI updates between two buffers.
+ *
+ * Accepts a TermColorCaps probe result so that color sequences are
+ * downsampled to the terminal's actual capability level (truecolor /
+ * ansi256 / basic16 / none), and frames are wrapped in DEC 2026
+ * synchronized-output markers when supported.
  */
 export class DiffEngine {
   private lastFg = '';
@@ -13,6 +23,11 @@ export class DiffEngine {
   private lastItalic = false;
   private lastStrikethrough = false;
   private lastLink = '';
+  private caps: TermColorCaps;
+
+  constructor(caps: TermColorCaps = { capability: 'truecolor', syncedOutput: true }) {
+    this.caps = caps;
+  }
 
   public reset(): void {
     this.lastFg = '';
@@ -56,7 +71,7 @@ export class DiffEngine {
       this.lastLink = '';
     }
 
-    return output;
+    return wrapSynced(output, this.caps);
   }
 
   private isCellDifferent(a: Cell | undefined, b: Cell): boolean {
@@ -66,6 +81,11 @@ export class DiffEngine {
       (a.link ?? '') !== (b.link ?? '');
   }
 
+  /**
+   * Convert a raw color string (hex or r;g;b) to the "r;g;b" form used for
+   * change-detection against lastFg/lastBg. Palette indices pass through as-is.
+   * Capability downsampling happens in applyStyles via downsampleColor.
+   */
   private sanitizeColor(color: string): string {
     if (color.startsWith('#')) {
       const r = parseInt(color.slice(1, 3), 16);
@@ -77,7 +97,7 @@ export class DiffEngine {
   }
 
   private applyStyles(cell: Cell): string {
-    let style = '';
+    // Normalize hex → r;g;b (for change-detection against lastFg/lastBg)
     const fg = this.sanitizeColor(cell.fg);
     const bg = this.sanitizeColor(cell.bg);
     const link = cell.link ?? '';
@@ -87,21 +107,40 @@ export class DiffEngine {
       cell.underline !== this.lastUnderline || cell.italic !== this.lastItalic ||
       cell.strikethrough !== this.lastStrikethrough;
 
+    let style = '';
+
     if (changed) {
-      style += '\x1b[0m'; // Reset all attributes
-      if (cell.bold) style += '\x1b[1m';
-      if (cell.dim) style += '\x1b[2m';
-      if (cell.italic) style += '\x1b[3m';
-      if (cell.underline) style += '\x1b[4m';
-      if (cell.strikethrough) style += '\x1b[9m';
-
-      if (fg) {
-        const isRgb = fg.includes(';');
-        style += isRgb ? `\x1b[38;2;${fg}m` : `\x1b[38;5;${fg}m`;
+      // Reset all attributes first (only when the terminal renders color/SGR).
+      if (this.caps.capability !== 'none') {
+        style += '\x1b[0m';
+        if (cell.bold) style += '\x1b[1m';
+        if (cell.dim) style += '\x1b[2m';
+        if (cell.italic) style += '\x1b[3m';
+        if (cell.underline) style += '\x1b[4m';
+        if (cell.strikethrough) style += '\x1b[9m';
       }
-      if (bg) {
-        const isRgb = bg.includes(';');
-        style += isRgb ? `\x1b[48;2;${bg}m` : `\x1b[48;5;${bg}m`;
+
+      // Foreground color — capability-downsampled (no raw hex leak on a
+      // truecolor-incapable terminal; null → emit nothing).
+      const fgOut = downsampleColor(fg, this.caps, 'fg');
+      if (fgOut !== null) {
+        if (this.caps.capability === 'basic16') {
+          style += `\x1b[${fgOut}m`;
+        } else {
+          const isRgb = fgOut.includes(';');
+          style += isRgb ? `\x1b[38;2;${fgOut}m` : `\x1b[38;5;${fgOut}m`;
+        }
+      }
+
+      // Background color — capability-downsampled
+      const bgOut = downsampleColor(bg, this.caps, 'bg');
+      if (bgOut !== null) {
+        if (this.caps.capability === 'basic16') {
+          style += `\x1b[${bgOut}m`;
+        } else {
+          const isRgb = bgOut.includes(';');
+          style += isRgb ? `\x1b[48;2;${bgOut}m` : `\x1b[48;5;${bgOut}m`;
+        }
       }
 
       this.lastFg = fg;
@@ -113,16 +152,20 @@ export class DiffEngine {
       this.lastStrikethrough = cell.strikethrough;
     }
 
-    // OSC 8 hyperlink: emit open/close/change sequences only when link changes
-    if (link !== this.lastLink) {
+    // OSC 8 hyperlink: emit open/close/change sequences only when link changes.
+    // Suppressed in no-color mode (dumb/no-color terminals cannot render them).
+    if (link !== this.lastLink && this.caps.capability !== 'none') {
       if (link) {
         // Open new hyperlink (close previous if any was open)
         style += `\x1b]8;;${link}\x1b\\`;
       } else {
         // Close hyperlink
-        style += `\x1b]8;;\x1b\\`;
+        style += '\x1b]8;;\x1b\\';
       }
       this.lastLink = link;
+    } else if (link !== this.lastLink) {
+      // capability === 'none': track state but emit nothing
+      this.lastLink = link;
     }
 
     return style;

package/src/renderer/fullscreen-primitives.ts

@@ -1,25 +1,44 @@
 import type { Line } from '../types/grid.ts';
 import { createEmptyLine, createStyledCell } from '../types/grid.ts';
 import { getDisplayWidth } from '../utils/terminal-width.ts';
-import { GLYPHS, UI_TONES } from './ui-primitives.ts';
+import { GLYPHS } from './ui-primitives.ts';
+import { activeUiTones, registerThemeRefresh } from './theme.ts';
 
-export const FULLSCREEN_PALETTE = {
-  border: '#64748b',
-  title: '#67e8f9',
-  subtitle: '#93c5fd',
-  text: '#e2e8f0',
-  muted: '#94a3b8',
-  dim: '#64748b',
-  selectedBg: '#223049',
-  categoryBg: '#141b25',
-  contextBg: '#121923',
-  controlsBg: '#0f141d',
-  footerBg: '#111827',
-  good: UI_TONES.state.good,
-  warn: UI_TONES.state.warn,
-  bad: UI_TONES.state.bad,
-  info: UI_TONES.state.info,
-} as const;
+// Built from the mode-resolved chrome tones (activeUiTones) and rebuilt IN PLACE
+// on a mode flip via the registered refresher (read by reference across the
+// fullscreen workspace surfaces). This is an OPAQUE dark panel: fg/bg roles stay
+// dark in the SDK light tones (only state.* flips), so dark is byte-identical.
+// title / categoryBg / contextBg / controlsBg are agent-local fullscreen values
+// with no shared tone equivalent — kept as-is (opaque dark panel surfaces).
+function buildFullscreenPalette(): Record<string, string> {
+  const t = activeUiTones();
+  return {
+    border: t.border,
+    title: '#67e8f9',
+    subtitle: t.accent.conversation,
+    text: t.fg.primary,
+    muted: t.fg.muted,
+    dim: t.border,
+    selectedBg: t.bg.selected,
+    categoryBg: '#141b25',
+    contextBg: '#121923',
+    controlsBg: '#0f141d',
+    footerBg: t.bg.footer,
+    good: t.state.good,
+    warn: t.state.warn,
+    bad: t.state.bad,
+    info: t.state.info,
+  };
+}
+
+export const FULLSCREEN_PALETTE = buildFullscreenPalette() as {
+  readonly border: string; readonly title: string; readonly subtitle: string;
+  readonly text: string; readonly muted: string; readonly dim: string;
+  readonly selectedBg: string; readonly categoryBg: string; readonly contextBg: string;
+  readonly controlsBg: string; readonly footerBg: string; readonly good: string;
+  readonly warn: string; readonly bad: string; readonly info: string;
+};
+registerThemeRefresh(() => Object.assign(FULLSCREEN_PALETTE as Record<string, string>, buildFullscreenPalette()));
 
 export type FullscreenTextStyle = Partial<Omit<Line[number], 'char'>>;