mixdog 0.9.21 → 0.9.23

package/src/tui/engine/session-api.mjs

@@ -286,17 +286,27 @@ export function createEngineApiA(bag) {
       }
     },
     setMcpServerEnabled: async (name, enabled) => {
-      if (getState().commandBusy) return null;
-      set({ commandBusy: true });
-      try {
-        const status = await runtime.setMcpServerEnabled?.(name, enabled);
+      // No global commandBusy: the runtime adopts config synchronously and
+      // serializes the heavy connect/close/recreate per server name, so rapid
+      // re-toggles converge instead of being dropped. This awaits the
+      // background chain purely to settle the picker on completion/failure.
+      const status = await runtime.setMcpServerEnabled?.(name, enabled);
+      // The context re-estimate is a full-transcript token count; defer it off
+      // the interactive frame so it never runs inside the toggle key handler.
+      setImmediate(() => {
         resetStatsAndSyncContext();
         set({ ...routeState(), stats: { ...getState().stats } });
+      });
+      // A connect failure resolves as a status object (not a throw), so inspect
+      // this server's row before claiming success: enabling can fail on spawn/
+      // handshake. Disabling never spawns, so it is always a success.
+      const row = status?.servers?.find((s) => s.name === name);
+      if (enabled && row && (row.status === 'failed' || row.error)) {
+        pushNotice(`mcp enable failed: ${name}${row.error ? ` — ${row.error}` : ''}`, 'error');
+      } else {
         pushNotice(`mcp ${enabled ? 'enabled' : 'disabled'}: ${name}`, 'info');
-        return status;
-      } finally {
-        set({ commandBusy: false });
       }
+      return status;
     },
     getDisabledSkills: () => runtime.getDisabledSkills?.() || { disabled: [] },
     setDisabledSkills: (disabled) => runtime.setDisabledSkills?.(disabled) || { disabled: [] },

package/src/tui/engine/session-flow.mjs

@@ -15,6 +15,12 @@ export function createSessionFlow(bag) {
   // runtime.clear() resolve only after compaction finishes; without a bound a
   // stalled compaction wedges autoClearRunning/commandBusy forever, which
   // suppresses the input drain. On timeout we abandon this attempt.
+  // NOTE: this bounds how long the INPUT stays blocked (commandBusy), not the
+  // compaction itself — the clear path's worst case (recall cold retries ~38s
+  // + size-scaled semantic up to 120s) may exceed it, and that is fine: the
+  // abandoned promise keeps running and the late-fulfillment path below
+  // (autoClearInFlight / pendingClearedSessionUi) applies the clear when it
+  // settles. Do NOT raise this to cover compaction worst cases.
   const AUTO_CLEAR_COMPACT_TIMEOUT_MS = 60_000;
 
     const leadSessionId = () => runtime.id;

package/src/tui/engine.mjs

@@ -21,6 +21,7 @@ import {
   isModelVisibleToolCompletionWrapper,
   isLikelyToolCompletionWrapper,
 } from '../runtime/shared/tool-execution-contract.mjs';
+import { isLateToolAnnouncement, summarizeLateToolAnnouncement } from '../session-runtime/session-text.mjs';
 import { presentErrorText } from '../runtime/shared/err-text.mjs';
 import { listThemes, getThemeSetting, setThemeSetting } from './theme.mjs';
 import { resetAllStreamingMarkdownStablePrefixes } from './markdown/streaming-markdown.mjs';
@@ -386,6 +387,13 @@ export async function createEngineSession({
     // detector only, same as before this change.
     if (origin === 'injected' && isLikelyToolCompletionWrapper(text)) return;
     if (isModelVisibleToolCompletionWrapper(text)) return;
+    // Late-MCP deferred-tool announcement (model-visible <system-reminder>):
+    // keep it in model context, but never render the raw block here. Collapse
+    // to one muted notice line, e.g. "MCP tools available: UnityMCP (12 tools)".
+    if (isLateToolAnnouncement(text)) {
+      pushItem({ kind: 'notice', id, text: summarizeLateToolAnnouncement(text), tone: 'info' });
+      return;
+    }
     if (upsertSyntheticToolItem(text, id)) return;
     pushItem({ kind: 'user', id, text });
   };

package/src/tui/index.jsx

@@ -10,19 +10,30 @@ import { closeSync, constants as fsConstants, createWriteStream, mkdirSync, open
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { performance } from 'node:perf_hooks';
+import { format } from 'node:util';
 import { App } from './App.jsx';
 import { createEngineSession } from './engine.mjs';
 import { installProcessSignalCleanup } from '../runtime/shared/process-shutdown.mjs';
-import { touchUiHeartbeat } from '../runtime/channels/lib/runtime-paths.mjs';
 import { emitTerminalBackground, loadThemeSettingFromConfig, theme } from './theme.mjs';
 import { POP_KITTY, DISABLE_MODIFY_OTHER_KEYS } from './keyboard-protocol.mjs';
 import { displayWidth } from './display-width.mjs';
 import { rotateBoundedLog, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../lib/mixdog-debug.cjs';
 
-const TERMINAL_MODE_RESET = '\x1b[?1006l\x1b[?1005l\x1b[?1015l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?2004l\x1b[?25h';
+// Trailing `\x1b[>0s` restores XTSHIFTESCAPE (shift-to-select-extend) to its
+// terminal default; MOUSE_TRACKING_ON opts into `\x1b[>1s`, so every mouse/alt
+// screen teardown that emits this reset also undoes that opt-in.
+const TERMINAL_MODE_RESET = '\x1b[?1006l\x1b[?1005l\x1b[?1015l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?2004l\x1b[>0s\x1b[?25h';
 const TERMINAL_OSC_RESET_BG = '\x1b]111\x07';
 const TERMINAL_MODE_RESET_HIDDEN_CURSOR = TERMINAL_MODE_RESET.replace('\x1b[?25h', '\x1b[?25l');
-const MOUSE_TRACKING_ON = '\x1b[?1000h\x1b[?1002h\x1b[?1006h';
+// Trailing `\x1b[>1s` is XTSHIFTESCAPE: terminals that support it forward
+// shift+click/drag to the app so our shift-extend selection paths work.
+// Windows Terminal half-honors it — it forwards the shift events AND still
+// paints its own native selection, so the user sees two overlapping
+// highlights. Gate on WT_SESSION: in WT shift stays fully native (single
+// highlight, native copy); ctrl+click/right-click remain the app-side
+// extend triggers there. Restored via `\x1b[>0s` in TERMINAL_MODE_RESET.
+const XTSHIFTESCAPE_ON = process.env.WT_SESSION ? '' : '\x1b[>1s';
+const MOUSE_TRACKING_ON = `\x1b[?1000h\x1b[?1002h\x1b[?1006h${XTSHIFTESCAPE_ON}`;
 // Keyboard-protocol teardown. App.jsx enables kitty + modifyOtherKeys
 // synchronously at raw-mode-on (no query); here we just pop/disable them on
 // exit. POP_KITTY / DISABLE_MODIFY_OTHER_KEYS come from keyboard-protocol.mjs.
@@ -366,6 +377,36 @@ function installTuiStderrGuard() {
   };
 }
 
+/**
+ * Route console.* to the guarded stderr (→ mixdog-tui.stderr.log) while the
+ * fullscreen TUI owns the terminal, and mount ink with patchConsole:false.
+ *
+ * Why: ink's patchConsole path (writeToStdout/writeToStderr) handles an
+ * intercepted console line by erasing the whole frame (log.clear()), writing
+ * the line, then re-writing the last frame RELATIVE to the cursor. On a
+ * fullscreen alt-screen frame that relative rewrite overflows the bottom row
+ * by exactly the stray line's height, so the terminal scrolls one line and
+ * the next incremental frame snaps it back — the visible "+1 line / -1 line"
+ * bounce during streaming (reproduced in a VT harness: one console.log mid-
+ * stream = scrollDelta 1, with or without the spinner). The stray text itself
+ * was already invisible (stderr guard files it), so the only user-visible
+ * effect of the whole dance WAS the bounce. Routing console output straight
+ * to the guarded stderr keeps the diagnostics AND skips ink's repaint dance.
+ */
+function installTuiConsoleGuard() {
+  const methods = ['log', 'info', 'warn', 'error', 'debug', 'trace'];
+  const original = new Map();
+  for (const m of methods) {
+    original.set(m, console[m]);
+    console[m] = (...args) => {
+      try { process.stderr.write(`[console.${m}] ${format(...args)}\n`); } catch { /* ignore */ }
+    };
+  }
+  return () => {
+    for (const [m, fn] of original) console[m] = fn;
+  };
+}
+
 export async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {}) {
   const startedAt = performance.now();
   bootProfile('run:start', { provider, model, toolMode, remote });
@@ -380,6 +421,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
   }
 
   const restoreStderr = installTuiStderrGuard();
+  const restoreConsole = installTuiConsoleGuard();
   const stopPerfProbe = installTuiPerfProbe();
   const stopLoopProbe = installTuiLoopProbe();
   const restorePrimedInput = () => drainStdin(process.stdin);
@@ -438,6 +480,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     stopLoopProbe();
     restoreTerminal();
     try { process.off('exit', restoreTerminal); } catch { /* ignore */ }
+    restoreConsole();
     restoreStderr();
     process.stderr.write(`mixdog: ${error?.message || error}\n`);
     return 1;
@@ -449,7 +492,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
   // Keep mouse handling app-owned by default: native terminal selections are
   // cleared by the fullscreen redraws that happen while a turn streams. Users
   // who prefer their terminal's native mouse behavior can opt out with
-  // MIXDOG_TUI_MOUSE=0.
+  // MIXDOG_TUI_MOUSE=0 (mouse capture stays off at boot, no runtime toggle).
   const mouseTracking = !/^(0|false|no|off)$/i.test(String(process.env.MIXDOG_TUI_MOUSE || '1'));
   if (mouseTracking) {
     process.stdout.write(MOUSE_TRACKING_ON);
@@ -469,22 +512,11 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     afterCleanup: (reason) => {
       restoreTerminal();
       dumpActiveHandles(`after-${reason}`);
+      restoreConsole();
       restoreStderr();
     },
   });
 
-  // Zombie-Lead repro (2026-07-02): the render loop can wedge (all owning
-  // PIDs still alive) leaving active-instance.json's pid-only staleness
-  // check unable to detect it. Heartbeat every 30s so runtime-paths.mjs can
-  // fall back to a ui_heartbeat_at staleness check when pids look fine.
-  // Best-effort: a failed/late write just means the next tick catches up,
-  // and the timer is unref'd so it never keeps the process alive on its own.
-  const uiHeartbeatTimer = setInterval(() => {
-    try { touchUiHeartbeat(); } catch { /* ignore */ }
-  }, 30_000);
-  if (typeof uiHeartbeatTimer.unref === 'function') uiHeartbeatTimer.unref();
-  try { touchUiHeartbeat(); } catch { /* ignore */ }
-
   // Zombie-Lead repro (2026-07-02): stdio can die (TTY hangup, EPIPE on a
   // detached/piped stdout) without the process ever receiving SIGHUP/SIGTERM,
   // leaving a zombie renderer looping forever with nothing left to draw to.
@@ -527,7 +559,12 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     // [render] incrementalRendering: line-diff repaint (only changed rows are
     // rewritten) instead of erase-all+rewrite per frame — removes the whole-
     // frame flash on surface transitions and slash palette open/close.
-    const instance = render(<App store={store} forceOnboarding={forceOnboarding === true} />, { exitOnCtrlC: false, maxFps: 60, incrementalRendering: true, onRender: makeRenderProfiler() });
+    // patchConsole:false — console.* is already routed to the stderr log by
+    // installTuiConsoleGuard above. Letting ink intercept it instead triggers
+    // its clear-frame → write → relative re-render dance, which scrolls the
+    // alt screen one line per stray console line (the streaming newline
+    // bounce). See installTuiConsoleGuard.
+    const instance = render(<App store={store} forceOnboarding={forceOnboarding === true} />, { exitOnCtrlC: false, maxFps: 60, incrementalRendering: true, patchConsole: false, onRender: makeRenderProfiler() });
     bootProfile('render:mounted', { ms: (performance.now() - startedAt).toFixed(1) });
     const { waitUntilExit } = instance;
     // [mixdog fork] Hand the ink renderer's drag-selection setter to the store so
@@ -550,11 +587,17 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     if (mouseTracking && typeof instance.getSelectionRows === 'function') {
       store.getRenderSelectionRows = instance.getSelectionRows;
     }
+    // [mixdog] One-shot full clear+repaint. The app's mouse handler fires it on
+    // every button press under Windows Terminal to dismiss WT's persistent
+    // NATIVE (shift+drag) selection overlay, which survives incremental
+    // repaints and would otherwise sit on top of the app-drawn selection.
+    if (mouseTracking && typeof instance.forceFullRepaint === 'function') {
+      store.forceRenderRepaint = instance.forceFullRepaint;
+    }
     await waitUntilExit();
   } finally {
     stopPerfProbe();
     stopLoopProbe();
-    clearInterval(uiHeartbeatTimer);
     for (const [stream, event, handler] of stdioDeathListeners.splice(0)) {
       try { stream.off(event, handler); } catch { /* ignore */ }
     }
@@ -566,6 +609,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     }
     restoreTerminal();
     dumpActiveHandles('after-restore');
+    restoreConsole();
     restoreStderr();
   }
   scheduleHardExit(0);

package/src/tui/paste-attachments.mjs

@@ -1,4 +1,5 @@
 import { execFile } from 'node:child_process';
+import { Buffer } from 'node:buffer';
 import { randomBytes } from 'node:crypto';
 import { existsSync, unlinkSync } from 'node:fs';
 import { readFile as readFileAsync, stat as statAsync } from 'node:fs/promises';
@@ -223,3 +224,28 @@ export async function readClipboardImageAttachment() {
     try { unlinkSync(file); } catch {}
   }
 }
+
+// Cross-platform OS-clipboard TEXT read. Mirrors the per-OS command pattern in
+// clipboard.mjs (writes) and readClipboardImageAttachment (reads). Returns '' on
+// any miss/error so callers can cleanly fall through to the image path. Windows
+// round-trips through base64 so non-ASCII survives the console codepage.
+export async function readClipboardText() {
+  if (process.platform === 'win32') {
+    const ps = '$t=Get-Clipboard -Raw; if ($null -eq $t) { exit 2 }; [Console]::Out.Write([Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($t)))';
+    const r = await execFileBuffer('powershell.exe', ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', ps], { timeout: 3000 });
+    if (!r.ok || !r.stdout?.length) return '';
+    try { return Buffer.from(r.stdout.toString('ascii').trim(), 'base64').toString('utf8'); } catch { return ''; }
+  }
+  if (process.platform === 'darwin') {
+    const r = await execFileBuffer('pbpaste', [], { timeout: 3000 });
+    return r.ok && r.stdout?.length ? r.stdout.toString('utf8') : '';
+  }
+  if (process.platform === 'linux') {
+    const wl = await execFileBuffer('wl-paste', ['--no-newline'], { timeout: 3000 });
+    if (wl.ok && wl.stdout?.length) return wl.stdout.toString('utf8');
+    const xc = await execFileBuffer('xclip', ['-selection', 'clipboard', '-o'], { timeout: 3000 });
+    if (xc.ok && xc.stdout?.length) return xc.stdout.toString('utf8');
+    return '';
+  }
+  return '';
+}

package/src/ui/statusline.mjs

@@ -90,6 +90,28 @@ function rememberNonEmptyQuotaSegments(key, segments) {
     _lastNonEmptyQuotaSegmentsByKey.delete(oldestKey);
   }
 }
+
+// Monotonic hysteresis for the quota/usage segment. Once a value has rendered
+// (held), a new non-empty result replaces it ONLY when it is at least as fresh
+// or is confirmed own-instance live data. This stops the 5H/7D values flapping
+// when another mixdog instance overwrites the shared active-instance/usage cache
+// with an OLDER snapshot: metricsMatch flips false, the source alternates to a
+// provider-wide cache snapshot captured at a different time, and without this
+// gate the two sources would oscillate tick-to-tick.
+//   - nothing displayed yet .................. accept
+//   - incoming is own-instance live data ..... accept (always wins)
+//   - either side lacks a comparable asOf .... accept (preserves prior behavior)
+//   - displayed value is own live data ....... accept only a STRICTLY newer snapshot
+//   - both shared-cache snapshots ............ accept same-or-newer asOf
+export function acceptQuotaSnapshot(held, incoming) {
+  if (!held) return true;
+  if (incoming && incoming.owned) return true;
+  const incomingAsOf = num(incoming && incoming.asOf);
+  const heldAsOf = num(held.asOf);
+  if (!incomingAsOf || !heldAsOf) return true;
+  if (held.owned) return incomingAsOf > heldAsOf;
+  return incomingAsOf >= heldAsOf;
+}
 // Option A boot gate: the L1 usage/quota segment stays fully empty until THIS
 // process has captured its FIRST confirmed (current-process) OAuth usage
 // snapshot for THAT provider. The latch is monotonic PER PROVIDER — once a
@@ -310,10 +332,21 @@ function renderNativeStatusline({
   if (usageReady && _oauthUsageArmedProviders.has(normalizedHoldProvider)) {
     const holdKey = quotaSegmentsHoldKey({ provider, model, effort, fast, sessionId, clientHostPid });
     if (quotaSegments.length) {
-      rememberNonEmptyQuotaSegments(holdKey, quotaSegments);
+      // Monotonic replace: keep the currently displayed value unless the new
+      // one is same-or-newer, or is confirmed own-instance live data.
+      const incoming = {
+        asOf: num(quotaStatus?.quotaWindowsAsOf),
+        owned: quotaStatus?.quotaWindowsOwned === true,
+      };
+      const held = _lastNonEmptyQuotaSegmentsByKey.get(holdKey);
+      if (acceptQuotaSnapshot(held, incoming)) {
+        rememberNonEmptyQuotaSegments(holdKey, { segments: quotaSegments, asOf: incoming.asOf, owned: incoming.owned });
+      } else if (held?.segments?.length) {
+        quotaSegments = held.segments;
+      }
     } else {
       const held = _lastNonEmptyQuotaSegmentsByKey.get(holdKey);
-      if (held && held.length) quotaSegments = held;
+      if (held?.segments?.length) quotaSegments = held.segments;
     }
   }
   for (const seg of quotaSegments) addL1(seg);
@@ -530,6 +563,10 @@ function fallbackQuotaStatus({ provider, model } = {}) {
             value = {
               ...routeInfo,
               quotaWindows: limits.quotaWindows || [],
+              // Shared provider-wide OAuth usage cache snapshot: not owned by
+              // this instance. asOf = the snapshot's cachedAt for hysteresis.
+              quotaWindowsAsOf: num(usageSnapshot?.cachedAt),
+              quotaWindowsOwned: false,
               balance: limits.balance || null,
               routeSpend: limits.routeSpend || null,
             };
@@ -556,12 +593,15 @@ function providerKindForQuota(provider) {
 function mergeQuotaStatus(primary, fallback) {
   if (!primary) return fallback || null;
   if (!fallback) return primary;
+  const usePrimaryWindows = Array.isArray(primary.quotaWindows) && primary.quotaWindows.length;
   return {
     ...fallback,
     ...primary,
-    quotaWindows: Array.isArray(primary.quotaWindows) && primary.quotaWindows.length
-      ? primary.quotaWindows
-      : (fallback.quotaWindows || []),
+    quotaWindows: usePrimaryWindows ? primary.quotaWindows : (fallback.quotaWindows || []),
+    // Keep asOf/owned aligned with whichever windows won, so the hysteresis gate
+    // compares against the timestamp of the value actually being rendered.
+    quotaWindowsAsOf: usePrimaryWindows ? num(primary.quotaWindowsAsOf) : num(fallback.quotaWindowsAsOf),
+    quotaWindowsOwned: usePrimaryWindows ? primary.quotaWindowsOwned === true : fallback.quotaWindowsOwned === true,
     balance: primary.balance || fallback.balance || null,
     routeSpend: primary.routeSpend || fallback.routeSpend || null,
     providerKind: primary.providerKind || fallback.providerKind || providerKindForQuota(primary.provider || fallback.provider),

package/src/ui/tool-card.mjs

@@ -9,6 +9,7 @@
  * malformed argument objects (the engine hands us `{ name, arguments, id }`).
  */
 import { bold, cyan, gray } from './ansi.mjs';
+import { parseMcpToolName, isSelfMcpToolName } from '../runtime/shared/tool-primitives.mjs';
 
 const MAX_SUMMARY = 72;
 
@@ -38,13 +39,19 @@ export function renderToolCard(call) {
 
   const summary = safeSummary(name, args);
   const bullet = cyan('>');
-  const label = bold(name);
+  const label = bold(mcpCardLabel(name));
   if (!summary) return `  ${bullet} ${label}`;
   return `  ${bullet} ${label} ${gray(truncate(summary, MAX_SUMMARY))}`;
 }
 
 // --- helpers -----------------------------------------------------------------
 
+function mcpCardLabel(name) {
+  const mcp = parseMcpToolName(name);
+  if (!mcp || isSelfMcpToolName(name)) return name;
+  return `MCP ${mcp.server}.${mcp.tool}`;
+}
+
 function safeSummary(name, args) {
   try {
     const fn = SUMMARIZERS[name];

package/src/vendor/statusline/bin/statusline-route.mjs

@@ -343,27 +343,30 @@ function cachedQuotaWindowsFallback(provider, model) {
   // OAuth quota is provider/account-scoped, not model-scoped. Prefer the
   // current route key, then provider-wide cache, then the freshest same-provider
   // route entry so a model switch keeps showing quota before the next live fetch.
-  if (!provider || !model) return [];
+  // Returns the chosen entry's cachedAt alongside the windows so the caller can
+  // apply monotonic hysteresis (never displace a displayed value with an older
+  // shared-cache snapshot written by a different instance).
+  if (!provider || !model) return { quotaWindows: [], cachedAt: 0 };
   try {
     const cachePath = path.join(pluginDataDir(), 'gateway-oauth-usage-cache.json');
     const cache = readJson(cachePath);
     const routes = cache && typeof cache.routes === 'object' ? cache.routes : null;
-    if (!routes) return [];
+    if (!routes) return { quotaWindows: [], cachedAt: 0 };
     const routeKey = `${String(provider).toLowerCase()}
${String(model)}`;
     const providerOnlyKey = String(provider).toLowerCase();
     const routePrefix = `${providerOnlyKey}
`;
     const entry = routes[routeKey] || routes[providerOnlyKey] || Object.entries(routes)
       .filter(([key, value]) => key.startsWith(routePrefix) && Array.isArray(value?.quotaWindows))
       .sort((a, b) => (Number(b[1]?.cachedAt) || 0) - (Number(a[1]?.cachedAt) || 0))[0]?.[1];
-    if (!Array.isArray(entry?.quotaWindows)) return [];
+    if (!Array.isArray(entry?.quotaWindows)) return { quotaWindows: [], cachedAt: 0 };
     // Boot guard: do not render previous-launch usage before the current runtime
     // has captured at least one snapshot. Once captured in this process, hold it
     // instead of blanking it during idle/network gaps.
     const cachedAt = Number(entry.cachedAt);
-    if (!Number.isFinite(cachedAt) || cachedAt < STATUSLINE_PROCESS_STARTED_AT_MS) return [];
-    return entry.quotaWindows;
+    if (!Number.isFinite(cachedAt) || cachedAt < STATUSLINE_PROCESS_STARTED_AT_MS) return { quotaWindows: [], cachedAt: 0 };
+    return { quotaWindows: entry.quotaWindows, cachedAt };
   } catch {
-    return [];
+    return { quotaWindows: [], cachedAt: 0 };
   }
 }
 
@@ -499,11 +502,18 @@ function configuredGatewayStatus(options = {}) {
 
 export function loadGatewayStatus(options = {}) {
   const configured = configuredGatewayStatus(options);
+  const quotaFallback = configured
+    ? cachedQuotaWindowsFallback(configured.provider, configured.model)
+    : { quotaWindows: [], cachedAt: 0 };
   const configuredStatus = configured ? {
     ...configured,
     contextUsedPct: pctOf(options.activeContextTokens, compactBoundaryForStatus(configured)),
     lastUsage: null,
-    quotaWindows: cachedQuotaWindowsFallback(configured.provider, configured.model),
+    quotaWindows: quotaFallback.quotaWindows,
+    // Shared provider-wide cache snapshot: not owned by this instance. asOf is
+    // the cache entry's cachedAt so an older snapshot can be rejected downstream.
+    quotaWindowsAsOf: num(quotaFallback.cachedAt, 0),
+    quotaWindowsOwned: false,
     balance: null,
     routeSpend: null,
   } : null;
@@ -609,6 +619,12 @@ export function loadGatewayStatus(options = {}) {
       : null,
     lastUsage,
     quotaWindows: activeQuotaWindows.length ? activeQuotaWindows : (configuredStatus?.quotaWindows || []),
+    // Provenance for monotonic hysteresis: live active-instance windows are
+    // own-instance data timestamped by the advert's updatedAt; otherwise inherit
+    // the shared-cache fallback's (unowned) asOf. Older/unowned snapshots must
+    // not displace a value already rendered from newer/owned data.
+    quotaWindowsAsOf: activeQuotaWindows.length ? (updatedAt || 0) : num(configuredStatus?.quotaWindowsAsOf, 0),
+    quotaWindowsOwned: activeQuotaWindows.length ? metricsMatch : false,
     balance: metricsMatch && active.gateway_balance && typeof active.gateway_balance === 'object' ? active.gateway_balance : (configuredStatus?.balance || null),
     routeSpend: metricsMatch && active.gateway_route_spend && typeof active.gateway_route_spend === 'object' ? active.gateway_route_spend : (configuredStatus?.routeSpend || null),
     providerKind: statusProviderKind,

package/src/workflows/bench/WORKFLOW.md

@@ -0,0 +1,46 @@
+---
+id: bench
+name: Bench
+description: "Autonomous benchmark workflow — loop to completion without user approval."
+hidden: true
+agents: worker, heavy-worker, reviewer, debugger, maintainer
+---
+
+# Bench Workflow
+
+Autonomous run: no user is present. Never wait for approval or ask
+questions — decide and proceed immediately. Loop until the task is verified
+complete or provably blocked.
+
+Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
+- Lead directly: simple 1–2 step work, plus coordination, pre-planning, config
+  changes, and final git deployment.
+- Worker: implementation that takes several steps. Heavy Worker:
+  high-complexity, multi-step implementation.
+- Reviewer: verify implementation scopes (diff, regressions, missing checks).
+- Debugger: very high complexity, or when root-causing has already failed at
+  least once.
+
+1. Plan — form the plan yourself and start executing immediately; no approval
+   step exists.
+2. Delegate — split into the maximum number of independent scopes.
+   - PARALLEL across independent scopes by default (implementation, analysis,
+     review, debugging alike); spawn every scope in the SAME turn. Shared or
+     cross-cutting code does NOT justify merging — split per path and verify
+     the shared parts yourself. The only single scope is a genuinely
+     inseparable dependency; then state it.
+   - SEQUENTIAL within a single complex scope: ordered steps with a
+     build/test-green gate between them, not one shot.
+   - Write briefs per the Lead brief contract.
+   - After spawning async agents, END THE TURN — no polling, guessing, or
+     dependent work until the completion notification resumes you.
+3. Review — pair one reviewer 1:1 with each implementation scope, spawned in the
+   same turn, never deferred or batched; wait for its result. Fact-check agent
+   responses and cross-check implementation and review results yourself before
+   acting. Send fixes back to the original scope and loop verify -> fix ->
+   re-verify until clean. Skip review only for simple, low-risk tasks. If a bug
+   survives 2+ fix cycles, have the debugger investigate first instead of
+   another fix round.
+4. Finish — verify the final state yourself; only stop when the task is
+   complete and verified, or a hard blocker makes progress impossible. State
+   the outcome and evidence in the final message.

package/src/workflows/default/WORKFLOW.md

@@ -7,7 +7,13 @@ agents: worker, heavy-worker, reviewer, debugger, maintainer
 
 # Default Workflow
 
+HARD APPROVAL GATE — before the user gives an explicit go-ahead ("do it",
+"proceed", "ㄱㄱ"), NO edits, apply_patch, state-changing shell commands, or
+agent spawns. Read-only exploration only. Agreeing with a diagnosis or
+pointing out a problem is NOT approval.
+
 Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
+(routing applies only AFTER approval)
 - Lead directly: simple 1–2 step work, plus coordination, pre-planning, config
   changes, and final git deployment.
 - Worker: implementation that takes several steps. Heavy Worker:

package/src/workflows/solo/WORKFLOW.md

@@ -7,6 +7,11 @@ agents:
 
 # Solo Workflow
 
+HARD APPROVAL GATE — before the user gives an explicit go-ahead ("do it",
+"proceed", "ㄱㄱ"), NO edits, apply_patch, or state-changing shell commands.
+Read-only exploration only. Agreeing with a diagnosis or pointing out a
+problem is NOT approval.
+
 1. Plan — Lead discusses the request with the user, forms a plan, and waits for
    approval before execution.
    Only an explicit go-ahead is approval; diagnosis agreement is not. When

package/vendor/ink/build/ink.js

@@ -225,6 +225,10 @@ export default class Ink {
     // refreshed every render; read back via getSelectionRows() so the app can
     // stitch selections taller than the viewport. null when no selection.
     lastSelectionRows = null;
+    // [mixdog fork] One-shot flag: the next interactive frame takes the full
+    // clearTerminal+rewrite path even when nothing changed. Set via
+    // forceFullRepaint(); consumed (and reset) in renderInteractiveFrame.
+    forceClearNextFrame = false;
     constructor(options) {
         autoBind(this);
         this.options = options;
@@ -569,6 +573,19 @@ export default class Ink {
     getSelectionRows = () => {
         return this.lastSelectionRows;
     };
+    // [mixdog fork] Force a one-shot whole-screen clear + rewrite. Windows
+    // Terminal keeps its NATIVE (shift+drag) selection overlay alive across
+    // incremental in-place repaints, so a stale native highlight can sit on top
+    // of the app-drawn selection; a real clearTerminal+full rewrite dismisses
+    // it. The frame is BSU/ESU-wrapped by renderInteractiveFrame, so there is
+    // no visible flash. Called by the app on mouse-press via the render handle.
+    forceFullRepaint = () => {
+        if (this.isUnmounted || this.isUnmounting) {
+            return;
+        }
+        this.forceClearNextFrame = true;
+        this.rootNode.onImmediateRender();
+    };
     restoreLastOutput = () => {
         if (!this.interactive) {
             return;
@@ -1115,7 +1132,11 @@ export default class Ink {
         if (isFullscreen && outputToRender.endsWith('\n')) {
             outputToRender += '\u001B[0m';
         }
-        const shouldClearTerminal = shouldClearTerminalForFrame({
+        // [mixdog fork] One-shot forced clear (see forceFullRepaint): TTY-only,
+        // consumed here so it applies to exactly one frame.
+        const forcedClear = this.forceClearNextFrame && isTty;
+        this.forceClearNextFrame = false;
+        const shouldClearTerminal = forcedClear || shouldClearTerminalForFrame({
             isTty,
             viewportRows,
             previousViewportRows,
@@ -1147,6 +1168,7 @@ export default class Ink {
         // with identical output text but must still force a full clear to
         // avoid ghosting stale cells left outside the new viewport.
         if (shouldClearTerminal &&
+            !forcedClear &&
             !this.isUnmounting &&
             output === this.lastOutput &&
             staticOutput === '' &&