mixdog 0.9.22 → 0.9.24

package/src/tui/engine/agent-job-feed.mjs

@@ -38,6 +38,7 @@ export function createAgentJobFeed({
   getPending,
   agentStatusState,
   displayedExecutionNotificationKeys,
+  pushNotice,
 }) {
   let executionResumeKickDeferred = false;
 
@@ -92,6 +93,10 @@ export function createAgentJobFeed({
       const notificationKey = notificationQueueKey(event, text, parsed);
       const delivery = resolveTuiRuntimeNotificationDelivery(event, text);
       if (delivery.action === 'ignore') return;
+      if (delivery.action === 'notice') {
+        pushNotice?.(delivery.displayText, delivery.tone || 'info', { transcript: true });
+        return true;
+      }
       if (delivery.action === 'status-only') {
         if (parsed?.taskId) set(agentStatusState({ force: true }));
         return true;

package/src/tui/engine/notification-plan.mjs

@@ -61,6 +61,11 @@ export function resolveTuiRuntimeNotificationDelivery(event, text) {
   if (!trimmed) return { action: 'ignore' };
   const parsed = parseAgentJob(trimmed);
   const meta = event?.meta && typeof event.meta === 'object' ? event.meta : {};
+  // UI-only notices (e.g. boot auto-update outcome): render as a transcript
+  // notice, never enqueue anything model-visible.
+  if (meta.kind === 'update-notice') {
+    return { action: 'notice', displayText: trimmed, tone: meta.tone === 'warn' ? 'warn' : 'info' };
+  }
   if (!isExecutionNotification(event, trimmed, parsed)) {
     return { action: 'enqueue', displayText: trimmed, modelContent: trimmed };
   }

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

@@ -6,6 +6,8 @@ import { toolErrorDisplay } from './tool-result-text.mjs';
 import { isQueuedEntryEditable, promptDisplayText } from './queue-helpers.mjs';
 import { createEngineApiB } from './session-api-ext.mjs';
 import { buildDoctorReport } from '../app/doctor.mjs';
+import { recomputePromptHistory } from './prompt-history.mjs';
+import { buildMergedPromptHistory, loadPromptHistory } from '../prompt-history-store.mjs';
 
 export function createEngineApi(bag) {
   return { ...createEngineApiA(bag), ...createEngineApiB(bag) };
@@ -225,7 +227,10 @@ export function createEngineApiA(bag) {
     },
     setCwd: (path, options = {}) => {
       const next = runtime.setCwd(path);
-      set({ cwd: next });
+      // Republish up-arrow history for the NEW project: current session prompts
+      // merged with the cwd-scoped persisted store for the new cwd.
+      const sessionList = recomputePromptHistory(getState().items);
+      set({ cwd: next, promptHistoryList: buildMergedPromptHistory(sessionList, loadPromptHistory(next)) });
       if (options?.notice !== false) {
         pushNotice(options?.message || `Project set: ${projectNameFromPath(next)}`, 'info');
       }
@@ -286,17 +291,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/tool-card-results.mjs

@@ -10,9 +10,10 @@
  * the factory argument (getters/callbacks) — never stale snapshots. Every body
  * is the original engine.mjs logic verbatim.
  */
-import { summarizeToolResult } from '../../runtime/shared/tool-surface.mjs';
+import { summarizeToolResult, aggregateDoneCategories, classifyToolCategory } from '../../runtime/shared/tool-surface.mjs';
 import { toolResultText, toolErrorDisplay, toolGroupedDisplayFallback } from './tool-result-text.mjs';
 import { toolResultCallId } from './tool-call-fields.mjs';
+import { memoryCoreResultErrorText } from '../app/input-parsers.mjs';
 import { parseAgentJob, agentArgsWithResultMetadata, toolResultStatus, isErrorToolStatus } from './agent-envelope.mjs';
 import {
   withCancelledResultMarker,
@@ -55,13 +56,19 @@ export function createToolCardResults({
     // card in order, so transcript order always matches call order.
     (card.aggregate?.ensureVisible || card.ensureVisible)?.();
     const rawText = toolResultText(message?.content);
-    const isError = message?.isError === true || message?.toolKind === 'error' || /^\s*\[?error/i.test(rawText) || isErrorToolStatus(toolResultStatus(rawText));
-    const text = isError ? toolErrorDisplay(rawText, card?.name || 'tool') : rawText;
-
     // Aggregate card handling — collect semantic summaries per call
     const aggregate = card.aggregate;
+    const callRec = aggregate && callId ? aggregate.calls.get(callId) : null;
+    // Backend "core" memory-op failures are flattened to plain text (isError
+    // dropped upstream — see memoryCoreResultErrorText); recover that signal so
+    // failed memory writes are excluded from the done count. Gated to Memory
+    // calls: the text-matcher's ^(error|failed) catch-all would otherwise
+    // misflag legitimate non-memory success output.
+    const isMemoryCall = classifyToolCategory(callRec?.name || card?.name || '', callRec?.args || {}) === 'Memory';
+    const isError = message?.isError === true || message?.toolKind === 'error' || /^\s*\[?error/i.test(rawText) || isErrorToolStatus(toolResultStatus(rawText)) || (isMemoryCall && memoryCoreResultErrorText(rawText) != null);
+    const text = isError ? toolErrorDisplay(rawText, card?.name || 'tool') : rawText;
+
     if (aggregate && card.itemId === aggregate.itemId) {
-      const callRec = callId ? aggregate.calls.get(callId) : null;
       if (!callRec) return false;
       if (callRec.resolved) {
         card.done = true;
@@ -98,6 +105,7 @@ export function createToolCardResults({
         errorCount: errors,
         count: allCalls.length,
         completedCount: visualCompleted,
+        doneCategories: aggregateDoneCategories(allCalls),
         completedAt: Number(currentItem?.completedAt) || Date.now(),
       });
       card.done = true;
@@ -223,6 +231,7 @@ export function createToolCardResults({
           errorCount: errors,
           count: allCalls.length,
           completedCount: totalCompleted,
+          doneCategories: aggregateDoneCategories(allCalls),
           completedAt: Date.now(),
         });
         for (const sibling of toolCards || []) {

package/src/tui/engine/turn.mjs

@@ -1,13 +1,14 @@
 /**
  * src/tui/engine/turn.mjs - lead TUI turn engine (createRunTurn). Extracted from engine.mjs.
  */
-import { aggregateToolCategoryEntry, classifyToolCategory, formatAggregateDetail, summarizeToolResult } from '../../runtime/shared/tool-surface.mjs';
+import { aggregateToolCategoryEntry, aggregateDoneCategories, classifyToolCategory, formatAggregateDetail, summarizeToolResult } from '../../runtime/shared/tool-surface.mjs';
 import { applyUsageDelta } from './session-stats.mjs';
 import { pickVerb, pickDoneVerb, compactEventLabel, compactEventDetail } from './labels.mjs';
 import { toolResultText, toolErrorDisplay } from './tool-result-text.mjs';
 import { toolCallId, toolResultCallId, toolCallName, toolCallArgs } from './tool-call-fields.mjs';
 import { toolResultStatus, isErrorToolStatus } from './agent-envelope.mjs';
 import { promptDisplayText } from './queue-helpers.mjs';
+import { memoryCoreResultErrorText } from '../app/input-parsers.mjs';
 import { yieldToRenderer } from './render-timing.mjs';
 import { aggregateRawResult, aggregateBucketForCategory, aggregateSummaries, assignAggregateSummaryOrder } from './tool-result-status.mjs';
 
@@ -299,6 +300,7 @@ export function createRunTurn(bag) {
           isError: errors > 0,
           count: allCalls.length,
           completedCount: allCalls.length,
+          doneCategories: aggregateDoneCategories(allCalls),
           completedAt: Date.now(),
         });
       }
@@ -605,7 +607,12 @@ export function createRunTurn(bag) {
         if (!callRec || callRec.resolved || callRec.completedEarly) return;
         aggregate.ensureVisible?.();
         const rawText = toolResultText(message?.content);
-        const isError = message?.isError === true || message?.toolKind === 'error' || /^\s*\[?error/i.test(rawText) || isErrorToolStatus(toolResultStatus(rawText));
+        // Recover flattened memory "core" op failures (isError dropped upstream)
+        // so they are excluded from the done count — see memoryCoreResultErrorText.
+        // Gated to Memory calls: the text-matcher's ^(error|failed) catch-all
+        // would otherwise misflag legitimate non-memory success output.
+        const isMemoryCall = classifyToolCategory(callRec.name, callRec.args) === 'Memory';
+        const isError = message?.isError === true || message?.toolKind === 'error' || /^\s*\[?error/i.test(rawText) || isErrorToolStatus(toolResultStatus(rawText)) || (isMemoryCall && memoryCoreResultErrorText(rawText) != null);
         const text = isError ? toolErrorDisplay(rawText, callRec.name || 'tool') : rawText;
         callRec.summary = !isError ? summarizeToolResult(callRec.name, callRec.args, rawText, isError) : null;
         assignAggregateSummaryOrder(aggregate, callRec);

package/src/tui/engine.mjs

@@ -21,6 +21,7 @@ import {
   isModelVisibleToolCompletionWrapper,
   isLikelyToolCompletionWrapper,
 } from '../runtime/shared/tool-execution-contract.mjs';
+import { isLateToolAnnouncement } 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';
@@ -88,6 +89,11 @@ import {
 } from './engine/tui-steering-persist.mjs';
 import { createContextState } from './engine/context-state.mjs';
 import { recomputePromptHistory } from './engine/prompt-history.mjs';
+import {
+  appendPromptHistory,
+  buildMergedPromptHistory,
+  loadPromptHistory,
+} from './prompt-history-store.mjs';
 import { createSessionFlow } from './engine/session-flow.mjs';
 import { createRunTurn } from './engine/turn.mjs';
 import { createEngineApi } from './engine/session-api.mjs';
@@ -215,7 +221,9 @@ export async function createEngineSession({
     //  - promptHistoryList: newest-first deduped user-prompt history, rebuilt
     //    only when a user item is appended (replaces the per-change rescan).
     activeToolSummary: null,
-    promptHistoryList: [],
+    // Seed from the persisted cwd-scoped store so up-arrow history is available
+    // on a fresh start, before any bulk swap / first submit republishes it.
+    promptHistoryList: buildMergedPromptHistory([], loadPromptHistory(cwd)),
     ...baseRouteState(),
     displayContextWindow: 0,
     compactBoundaryTokens: 0,
@@ -279,7 +287,12 @@ export async function createEngineSession({
     // emit (the accompanying set() diffs the full patch). A bulk swap also
     // discards the old transcript, so drop any tracked active tool calls.
     activeToolCalls.clear();
-    state = { ...state, items: nextItems, promptHistoryList: recomputePromptHistory(nextItems), activeToolSummary: null };
+    state = {
+      ...state,
+      items: nextItems,
+      promptHistoryList: buildMergedPromptHistory(recomputePromptHistory(nextItems), loadPromptHistory(state.cwd)),
+      activeToolSummary: null,
+    };
     return nextItems;
   };
   // --- Prompt-history list (newest-first, deduped) maintained incrementally ---
@@ -305,7 +318,11 @@ export async function createEngineSession({
       if (rec.category === 'Explore') {
         exploreCount += c;
         if (started > 0 && (exploreStart === 0 || started < exploreStart)) exploreStart = started;
-      } else if (rec.category === 'Search') {
+      } else if (rec.category === 'Web Research') {
+        // L2 "Web Searching" segment tracks WEB searches (search/web_fetch —
+        // category 'Web Research'), not local file search ('Search' =
+        // grep/find/glob/list). Local search is routine transcript noise and
+        // is intentionally NOT surfaced on the statusline.
         searchCount += c;
         if (started > 0 && (searchStart === 0 || started < searchStart)) searchStart = started;
       }
@@ -317,7 +334,7 @@ export async function createEngineSession({
     if (next !== prev) set({ activeToolSummary: next || null });
   };
   const markToolCallActive = (callKey, category, count, startedAt) => {
-    if (!callKey || (category !== 'Explore' && category !== 'Search')) return;
+    if (!callKey || (category !== 'Explore' && category !== 'Web Research')) return;
     activeToolCalls.set(callKey, { category, count: Math.max(1, Number(count || 1)), startedAt: Number(startedAt || Date.now()) });
     recomputeActiveToolSummary();
   };
@@ -343,7 +360,7 @@ export async function createEngineSession({
       // publish items + the fresh list in ONE set(). Do NOT pre-assign to state
       // first — set() diffs against the current state, so a pre-assign would make
       // the references identical and skip emit().
-      const promptHistoryList = recomputePromptHistory(items);
+      const promptHistoryList = buildMergedPromptHistory(recomputePromptHistory(items), loadPromptHistory(state.cwd));
       set({ items, promptHistoryList });
     } else {
       set({ items });
@@ -386,7 +403,16 @@ 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 render NOTHING user-facing — not even the
+    // collapsed one-line notice (user request: hide late-tool notices entirely).
+    if (isLateToolAnnouncement(text)) return;
     if (upsertSyntheticToolItem(text, id)) return;
+    // Genuine, directly-typed/pasted user submissions only (never injected or
+    // synthetic paths, which returned above): persist to the cwd-scoped store so
+    // up-arrow history survives across sessions. Runs before pushItem so the
+    // merge in pushItem's user branch (loadPromptHistory) already sees it.
+    if (origin === 'user') appendPromptHistory(state.cwd, text);
     pushItem({ kind: 'user', id, text });
   };
   const pushToast = (text, tone = 'info', ttlMs = 3000) => {
@@ -505,6 +531,7 @@ export async function createEngineSession({
     getPending: () => pending,
     agentStatusState,
     displayedExecutionNotificationKeys,
+    pushNotice,
   });
   lifecycle.unsubscribeRuntimeNotifications = subscribeRuntimeNotifications();
 

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-agents.mjs

@@ -8,6 +8,7 @@
  */
 import { forEachSessionRuntime } from '../runtime/agent/orchestrator/session/manager.mjs';
 import { listHiddenAgentNames } from '../runtime/agent/orchestrator/internal-agents.mjs';
+import { classifyToolCategory } from '../runtime/shared/tool-surface.mjs';
 import { num, GRN, R, B } from './statusline-format.mjs';
 
 const DEFAULT_HIDDEN_STATUSLINE_AGENTS = Object.freeze(['explorer', 'cycle1-agent', 'cycle2-agent', 'cycle3-agent', 'scheduler-task', 'webhook-handler']);
@@ -189,6 +190,41 @@ function isTerminalBridgeStatus(statusText) {
   return /idle|done|complete|success|closed|error|fail|cancel|killed|timeout/.test(String(statusText || '').toLowerCase());
 }
 
+// Agent-side web search activity for the L2 "Web Searching" segment: any live
+// sub-session owned by THIS lead (ownerSessionId / clientHostPid match) whose
+// CURRENT tool call classifies as 'Web Research' (search/web_fetch/...). The
+// lead's own calls are excluded — those arrive via activeTools from the
+// transcript — so counts never double.
+export function agentWebSearchStatus({ sessionId = '', clientHostPid = 0 } = {}) {
+  const ownerPid = positiveInt(clientHostPid);
+  const ownerSessionId = String(sessionId || '').trim();
+  let count = 0;
+  let startedAt = 0;
+  try {
+    for (const [runtimeSessionId, entry] of forEachSessionRuntime() || []) {
+      if (!entry || entry.closed === true) continue;
+      if (String(entry.stage || '').trim().toLowerCase() !== 'tool_running') continue;
+      const session = entry.session || null;
+      if (!session || session.closed === true) continue;
+      const id = session?.id || runtimeSessionId || null;
+      if (ownerSessionId && id === ownerSessionId) continue;
+      const sessionOwnerId = String(session?.ownerSessionId || '').trim();
+      if (sessionOwnerId && ownerSessionId && sessionOwnerId !== ownerSessionId) continue;
+      const pid = positiveInt(session?.clientHostPid);
+      if (ownerPid && pid && pid !== ownerPid) continue;
+      const tool = String(entry.lastToolCall || '').trim();
+      if (!tool) continue;
+      let category = null;
+      try { category = classifyToolCategory(tool); } catch { /* unknown tool -> skip */ }
+      if (category !== 'Web Research') continue;
+      count += 1;
+      const started = num(entry.toolStartedAt);
+      if (started > 0 && (startedAt === 0 || started < startedAt)) startedAt = started;
+    }
+  } catch {}
+  return { count, startedAt };
+}
+
 function timeMs(value) {
   if (typeof value === 'number' && Number.isFinite(value) && value > 0) return value;
   const n = Date.parse(String(value || ''));