mixdog 0.9.22 → 0.9.24

package/src/standalone/hook-bus.mjs

@@ -352,11 +352,79 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
     return saveRules(rules);
   }
 
+  // --- debounced hooks.json persist ------------------------------------------
+  // Rule state is flipped in the in-memory rulesCache synchronously so the
+  // picker reopen renders from memory (no disk re-read); the heavy file RMW
+  // (saveRules) is deferred so a burst of toggle key presses collapses into one
+  // write. Mirrors config-lifecycle's scheduleSkillsSave pattern.
+  const RULES_SAVE_DEBOUNCE_MS = 400;
+  // Pending flips are tracked as index→enabled patches (not a full snapshot) so
+  // that if hooks.json is edited externally during the debounce window the flush
+  // can reload the current disk rules and reapply only our enabled-flag changes
+  // instead of clobbering the external edit.
+  let pendingRulePatches = null;
+  let rulesBaseMtime = null;
+  let rulesSaveTimer = null;
+
+  function flushRules() {
+    if (rulesSaveTimer) {
+      clearTimeout(rulesSaveTimer);
+      rulesSaveTimer = null;
+    }
+    if (!pendingRulePatches || pendingRulePatches.size === 0) {
+      pendingRulePatches = null;
+      rulesBaseMtime = null;
+      return;
+    }
+    const patches = pendingRulePatches;
+    const base = rulesBaseMtime;
+    pendingRulePatches = null;
+    rulesBaseMtime = null;
+    try {
+      let rules;
+      const diskChanged = rulesPath && existsSync(rulesPath) && statSync(rulesPath).mtimeMs !== base;
+      if (diskChanged) {
+        // External edit during the debounce window: reload from disk and reapply
+        // only our flips so the external change survives.
+        const parsed = JSON.parse(readFileSync(rulesPath, 'utf8'));
+        rules = normalizeRules(parsed).filter((rule) => rule && typeof rule === 'object');
+      } else {
+        rules = [...(rulesCache.rules || [])];
+      }
+      for (const [index, enabled] of patches) {
+        if (index >= 0 && index < rules.length) rules[index] = { ...rules[index], enabled };
+      }
+      saveRules(rules);
+    } catch (error) {
+      emit('hook:error', { error: `debounced hooks save failed: ${error?.message || error}` });
+    }
+  }
+
+  function scheduleRulesSave() {
+    if (rulesSaveTimer) clearTimeout(rulesSaveTimer);
+    rulesSaveTimer = setTimeout(flushRules, RULES_SAVE_DEBOUNCE_MS);
+    rulesSaveTimer.unref?.();
+  }
+
   function setRuleEnabled(index, enabled) {
     const rules = [...loadRules()];
     if (!Number.isInteger(index) || index < 0 || index >= rules.length) throw new Error(`hook rule not found: ${index}`);
-    rules[index] = { ...rules[index], enabled: enabled !== false };
-    return saveRules(rules);
+    const nextEnabled = enabled !== false;
+    rules[index] = { ...rules[index], enabled: nextEnabled };
+    // Adopt in memory immediately: keep the last-known disk mtime so loadRules
+    // returns this flipped cache (disk is untouched until the debounce flushes),
+    // and drop the config cache so a re-read reflects the change.
+    rulesCache = { ...rulesCache, rules };
+    configCache.key = '';
+    if (!pendingRulePatches) {
+      pendingRulePatches = new Map();
+      // mtime the in-memory cache was loaded from; flush compares against it to
+      // detect an external edit made during the debounce window.
+      rulesBaseMtime = rulesCache.mtimeMs;
+    }
+    pendingRulePatches.set(index, nextEnabled);
+    scheduleRulesSave();
+    return listRules();
   }
 
   function deleteRule(index) {
@@ -496,5 +564,5 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
     return rewakeHandler;
   }
 
-  return { addRule, beforeTool, deleteRule, dispatch, emit, listRules, setRewakeHandler, setRuleEnabled, status };
+  return { addRule, beforeTool, deleteRule, dispatch, emit, flushRules, listRules, setRewakeHandler, setRuleEnabled, status };
 }

package/src/tui/App.jsx

@@ -85,7 +85,7 @@ import {
   memoryCoreResultErrorText,
 } from './app/input-parsers.mjs';
 import { copyToClipboard } from './app/clipboard.mjs';
-import { wrappedTextRows, promptContentRows, wrappedDetailRows, textEntryReservedRows } from './app/text-layout.mjs';
+import { wrappedTextRows, promptContentRows, wrappedDetailRows, textEntryReservedRows, queuedBandRows } from './app/text-layout.mjs';
 import stringWidth from 'string-width';
 import { useMouseInput } from './app/use-mouse-input.mjs';
 import { useTranscriptScroll } from './app/use-transcript-scroll.mjs';
@@ -194,6 +194,8 @@ const PANEL_LAYOUT_SIG = {
   // Prompt-wrap/meta row counts (trailing churn tokens, see token order note
   // below). PROMPT_META is the 2-row live-spinner band slot.
   PROMPT_META: 9,
+  // Queued steering band rows (full wrapped height, see queuedBandRows).
+  QUEUED: 10,
 };
 const PROJECT_TEXT_ENTRY_KINDS = new Set(['project-new', 'project-create-confirm', 'project-rename']);
 const CORE_MULTILINE_TEXT_ENTRY_KINDS = new Set(['core-add', 'core-edit']);
@@ -319,7 +321,17 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
   // factory is instantiated (see initialPickerBuiltRef below), which React
   // applies before the first commit — no picker-less flash frame.
   const [picker, setPickerState] = useState(null);
+  // Live handle to the current picker state so async callbacks (e.g. the MCP
+  // toggle settle guard in extension-pickers) read the picker actually on
+  // screen at call time — including pickers opened by other factories — rather
+  // than a stale closure. Updated synchronously in setPicker (below) so a
+  // settle firing before the next render sees the right _kind; render-time
+  // sync further down is a backstop.
+  const livePickerRef = useRef(null);
   const setPicker = useCallback((next) => {
+    // Synchronous ref update so out-of-band setPicker(null/other) is visible to
+    // in-flight async guards immediately, before React commits the next render.
+    livePickerRef.current = typeof next === 'function' ? next(livePickerRef.current) : next;
     setPickerState((prev) => {
       const resolved = typeof next === 'function' ? next(prev) : next;
       if (resolved && typeof resolved === 'object' && pickerOpenedFromEnterRef.current) {
@@ -330,9 +342,22 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
         }
         return resolved.indexMode ? resolved : { ...resolved, indexMode: 'always' };
       }
+      // Same-kind reopen (toggle-driven rebuilds like the MCP ←/→ flip):
+      // carry the previous picker's indexMode so an 'always' injected at
+      // Enter-open time survives the rebuild instead of falling back to
+      // 'auto' and hiding the row indexes.
+      if (
+        resolved && typeof resolved === 'object' && !resolved.indexMode
+        && prev && typeof prev === 'object' && prev.indexMode
+        && prev._kind && prev._kind === resolved._kind
+      ) {
+        return { ...resolved, indexMode: prev.indexMode };
+      }
       return resolved;
     });
   }, []);
+  // Backstop: keep the ref aligned with committed state each render.
+  livePickerRef.current = picker;
   const [contextPanel, setContextPanel] = useState(null);
   const [usagePanel, setUsagePanel] = useState(null);
   const usageRequestRef = useRef(0);
@@ -385,7 +410,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
       onboardingOwnsScreen = status?.completed !== true || forceOnboarding;
     } catch { /* status probe failed → fall through to the project picker */ }
     if (!onboardingOwnsScreen && state.items.length === 0) {
-      setPickerState(projectPicker.buildProjectPickerState({ initialEntry: true }));
+      setPicker(projectPicker.buildProjectPickerState({ initialEntry: true }));
     }
   }
   const {
@@ -465,6 +490,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     clean,
     copyToClipboard,
     setPicker,
+    getPicker: () => livePickerRef.current,
     setProviderPrompt,
     setChannelPrompt,
     setHookPrompt,
@@ -1061,14 +1087,23 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     // The stitch buffer accumulates rows harvested across every scroll position
     // during a transcript drag, so it can reconstruct rows that scrolled out of
     // view entirely (neither renderText nor the last-full-paint remembered text
-    // ever saw them). Prefer it only when it is strictly longer than both.
-    const stitched = getStitchedSelectionText?.() || '';
-    if (stitched.length > text.length) text = stitched;
+    // ever saw them). getStitchedSelectionText now reports a `complete` flag:
+    // prefer the stitch ONLY when it contiguously covers the selection (no
+    // interior gap) AND adds rows. A gapped stitch silently drops a scrolled-off
+    // row, so preferring it purely on length yielded a mangled copy.
+    const stitched = getStitchedSelectionText?.() || { text: '', complete: false };
+    if (stitched.complete && stitched.text.length > text.length) text = stitched.text;
     if ((!text || !text.trim()) && attempt < 4) {
       setTimeout(() => copySelection(attempt + 1), attempt === 0 ? 0 : 24);
       return;
     }
-    if (!text || !text.trim()) return;
+    if (!text || !text.trim()) {
+      // Retries exhausted with nothing to copy: never return silently — the
+      // user pressed Ctrl+C expecting feedback. Surface a hint (and still
+      // swallow the key, which the caller already did).
+      showSelectionCopyHint('nothing to copy · select text first', 'error');
+      return;
+    }
     selectionTextRef.current = text;
     copyToClipboard(text)
       .then(() => {
@@ -2344,12 +2379,12 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
           const cat = v && typeof v === 'object' ? v.category : null;
           const c = Math.max(1, Number(v && typeof v === 'object' ? v.count : 1) || 1);
           if (cat === 'Explore') exploreHits += c;
-          else if (cat === 'Search') searchHits += c;
+          else if (cat === 'Web Research') searchHits += c;
         }
       } else if (it.name) {
         const cat = classifyToolCategory(it.name, it.args || {});
         if (cat === 'Explore') exploreHits = count;
-        else if (cat === 'Search') searchHits = count;
+        else if (cat === 'Web Research') searchHits = count;
       }
       if (exploreHits > 0) {
         exploreCount += exploreHits;
@@ -2532,9 +2567,21 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
   // active.
   const overlayHintRequested = !inputBoxHidden && !hasFloatingPanel && !liveSpinner && !!inputHint && !queuedVisible;
   const overlayHintRows = 0;
-  // QueuedCommands renders one row per queued command, pinned above the prompt
-  // box (no extra top-margin row).
-  const queuedRows = queuedVisible ? state.queued.length : 0;
+  // QueuedCommands renders each queued command at its FULL wrapped height
+  // (same content width the promoted transcript user row wraps at), pinned
+  // above the prompt box with no extra top-margin row. Reserving the true
+  // height keeps promotion from re-expanding the text mid-flight ("row jump").
+  // If the whole queue would eat too much of the frame, fall back to the old
+  // compact 1-row-per-entry truncation so the input box never leaves screen.
+  const queuedFullRows = queuedVisible
+    ? state.queued.reduce(
+      (sum, item) => sum + queuedBandRows(String(item.displayText || item.text || ''), Math.max(1, frameColumns - 4)),
+      0,
+    )
+    : 0;
+  const queuedRowBudget = Math.max(3, Math.floor(resizeState.rows / 3));
+  const queuedCompact = queuedFullRows > queuedRowBudget;
+  const queuedRows = queuedVisible ? (queuedCompact ? state.queued.length : queuedFullRows) : 0;
   const INPUT_BOX_ROWS = promptBoxRows + promptMetaRows + overlayHintRows;
   const baseReserve = WELCOME_ROWS + SCROLL_HINT_ROWS + LIVE_STATUS_ROWS + INPUT_BOX_ROWS + STATUSLINE_ROWS + queuedRows;
   const maxFloatingPanelRows = Math.max(0, resizeState.rows - baseReserve - 1);
@@ -2617,6 +2664,22 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     const spinnerMetaCollapseRows = doneTailAppendedThisCommit
       ? Math.max(0, prevMetaRows - nextMetaRows)
       : 0;
+    // Queued-band promotion: drain() removes the queued band and appends the
+    // promoted user transcript row in the SAME commit (session-flow.mjs drain
+    // → pushUserOrSyntheticItem → runTurn spinner, one microtask flush). The
+    // new user row (full wrapped height + margin) already backfills the
+    // vacated band rows, so masking them blank for one commit only to drop
+    // the mask on the next commit made the whole transcript bounce down.
+    // Exempt exactly the vacated queued rows when a user row landed at the
+    // tail in this commit; queue edits/removals without a tail append (tail
+    // id unchanged, or non-user tail) keep the mask.
+    const prevQueuedSigRows = Number(String(panelTransition.signature).split('|')[PANEL_LAYOUT_SIG.QUEUED]) || 0;
+    const nextQueuedSigRows = Number(String(panelLayoutSignature).split('|')[PANEL_LAYOUT_SIG.QUEUED]) || 0;
+    const userTailAppendedThisCommit = latestTranscriptItem?.kind === 'user'
+      && (latestTranscriptItem?.id ?? null) !== panelTransition.tailId;
+    const queuedPromoteCollapseRows = userTailAppendedThisCommit
+      ? Math.max(0, prevQueuedSigRows - nextQueuedSigRows)
+      : 0;
     const instantPanelClose = panelShrinkRows > 0
       && (promptRowsOnlyChange
         || isInstantPanelCloseTransition(panelTransition.signature, panelLayoutSignature, initialProjectEntryClose));
@@ -2637,8 +2700,9 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
       // the transcript clip instead of inflating bottomReserve + reclaiming on
       // the next tick. Subtract any turn-end spinner-meta rows that the same-
       // commit done tail already backfills (spinnerMetaCollapseRows) so that
-      // transition masks nothing and does not bounce.
-      panelCloseInkMaskRowsRef.current = Math.max(0, panelShrinkRows - spinnerMetaCollapseRows);
+      // transition masks nothing and does not bounce; same for queued-band
+      // rows backfilled by a just-promoted user row (queuedPromoteCollapseRows).
+      panelCloseInkMaskRowsRef.current = Math.max(0, panelShrinkRows - spinnerMetaCollapseRows - queuedPromoteCollapseRows);
       panelTransition.clearRows = 0;
       panelTransition.guardRows = 0;
       panelTransition.epoch = panelTransitionEpoch;
@@ -2695,8 +2759,13 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
   // renderScrollOffset=0. Without this, the stale offset shrinks
   // transcriptContentHeight by one row that never actually gets rendered,
   // producing a one-row bounce that snaps back once state catches up.
-  const scrollGuardNearBottom = followingRef.current || scrollTargetRef.current <= baseGuardRows;
-  const scrollGuardRows = (!scrollGuardNearBottom && scrollOffset > 0 && guardCapacityRows > baseGuardRows) ? 1 : 0;
+  // [2026-07-06] Scroll-time extra guard DISABLED: the widened (2-row) guard
+  // rendered as a visibly empty band between the transcript and the prompt box
+  // whenever the viewport was scrolled up (user-reported "bottom rows look
+  // blank while scrolling"). The base 1-row guard below stays; if the
+  // scrolled-row-over-statusline overpaint resurfaces, fix it in the renderer
+  // diff (clip/erase) instead of carving more blank viewport rows.
+  const scrollGuardRows = 0;
   const transcriptGuardRows = Math.min(guardCapacityRows, baseGuardRows + panelTransitionGuardRows + scrollGuardRows);
   // Welcome prompt hint: a one-row band rendered INSIDE the transcript
   // viewport (as a sibling below the content clip), so it must be part of the
@@ -2724,6 +2793,17 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
   const welcomePromptHintRows = welcomePromptHintVisible
     && (viewportHeight - transcriptGuardRows) >= 2 ? 1 : 0;
   welcomePromptHintVisibleRef.current = welcomePromptHintRows > 0;
+  // Transient hint/error on the EMPTY transcript: the guard row sits directly
+  // above the prompt box, so painting the hint there hugs the textbox one row
+  // below where the live-spinner line renders. Carve one in-viewport row ABOVE
+  // the guard row instead so the hint's baseline matches the spinner row (two
+  // rows above the box, guard row stays blank as the spacer). This is an
+  // in-viewport carve like welcomePromptHintRows — bottomReserve is untouched,
+  // so the prompt box and statusline never move. Non-empty transcripts keep the
+  // existing attach-to-last-item / guard-row fallback placements.
+  const overlayHintBandRows = overlayHintRequested
+    && state.items.length === 0
+    && (viewportHeight - transcriptGuardRows - welcomePromptHintRows) >= 2 ? 1 : 0;
   // Instant panel close (slash palette): the reclaimed rows stay blank for
   // exactly one commit via panelCloseMaskRows. The mask MUST be part of this
   // frame's row accounting — subtract it from the transcript content height
@@ -2734,11 +2814,11 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
   // commit (the "textbox dips when the slash palette closes" bug).
   const panelCloseMaskRows = Math.min(
     panelCloseInkMaskRows,
-    Math.max(0, viewportHeight - transcriptGuardRows - welcomePromptHintRows - 1),
+    Math.max(0, viewportHeight - transcriptGuardRows - welcomePromptHintRows - overlayHintBandRows - 1),
   );
   const transcriptContentHeight = Math.max(
     1,
-    viewportHeight - transcriptGuardRows - panelCloseMaskRows - welcomePromptHintRows,
+    viewportHeight - transcriptGuardRows - panelCloseMaskRows - welcomePromptHintRows - overlayHintBandRows,
   );
   // Bottom-follow / pin semantics must NOT widen with the scroll-time guard, or
   // the "pinned to tail" threshold would drift and streaming could freeze a row
@@ -3049,10 +3129,18 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
             backgroundColor={surfaceBackground()}
           />
         ) : null}
+        {overlayHintBandRows > 0 ? (
+          <Box height={1} flexShrink={0} backgroundColor={surfaceBackground()} flexDirection="row" width="100%" overflow="hidden">
+            <Box flexGrow={1} flexShrink={1} overflow="hidden" />
+            <Box flexShrink={0} width={guardHintWidth || 1} marginLeft={1} marginRight={1} justifyContent="flex-end" overflow="hidden">
+              <Text color={promptStatusColor(inputHintTone)} wrap="truncate">{inputHint}</Text>
+            </Box>
+          </Box>
+        ) : null}
         {transcriptGuardRows > 0 ? (
           <Box height={transcriptGuardRows} flexShrink={0} backgroundColor={surfaceBackground()} flexDirection="row" width="100%" overflow="hidden">
             <Box flexGrow={1} flexShrink={1} overflow="hidden" />
-            {overlayHintFallbackRow ? (
+            {overlayHintFallbackRow && overlayHintBandRows === 0 ? (
               <Box flexShrink={0} width={guardHintWidth || 1} marginLeft={1} marginRight={1} justifyContent="flex-end" overflow="hidden">
                 <Text color={promptStatusColor(inputHintTone)} wrap="truncate">{inputHint}</Text>
               </Box>
@@ -3314,7 +3402,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
             </>
           ) : null}
           {queuedVisible ? (
-            <QueuedCommands queued={state.queued} columns={frameColumns} />
+            <QueuedCommands queued={state.queued} columns={frameColumns} compact={queuedCompact} />
           ) : null}
           <Box
             marginTop={0}

package/src/tui/app/clipboard.mjs

@@ -12,9 +12,17 @@ export function osc52ClipboardSequence(text) {
   return `\x1bPtmux;${raw.replaceAll('\x1b', '\x1b\x1b')}\x1b\\`;
 }
 
+// Base64 of large selections becomes a multi-hundred-KB TTY write. Emitting
+// that as a single OSC 52 sequence blocks the terminal (and our render loop)
+// for a noticeable beat, so skip OSC 52 past this size and rely on the native
+// helper. ~256KB of clipboard text → ~350KB of base64.
+const OSC52_MAX_BYTES = 256 * 1024;
+
 export function writeOsc52Clipboard(text) {
+  const value = String(text ?? '');
+  if (Buffer.byteLength(value, 'utf8') > OSC52_MAX_BYTES) return false;
   try {
-    process.stdout.write(osc52ClipboardSequence(text));
+    process.stdout.write(osc52ClipboardSequence(value));
     return true;
   } catch {
     return false;
@@ -22,27 +30,32 @@ export function writeOsc52Clipboard(text) {
 }
 
 export function nativeClipboardCommand(text) {
+  const value = String(text ?? '');
   if (process.platform === 'win32') {
+    // clip.exe starts in tens of ms (vs 1s+ for powershell.exe). It reads its
+    // stdin as UTF-16LE, so feed plain UTF-16LE bytes for correct Unicode. No
+    // BOM: clip.exe copies a leading FF FE verbatim, leaking U+FEFF as the
+    // first pasted char.
     return {
-      cmd: 'powershell.exe',
-      args: [
-        '-NoLogo',
-        '-NoProfile',
-        '-NonInteractive',
-        '-Command',
-        '$b=[Console]::In.ReadToEnd();$t=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($b));Set-Clipboard -Value $t',
-      ],
-      input: Buffer.from(String(text ?? ''), 'utf8').toString('base64'),
+      cmd: 'clip.exe',
+      args: [],
+      input: Buffer.from(value, 'utf16le'),
     };
   }
-  if (process.platform === 'darwin') return { cmd: 'pbcopy', args: [], input: text };
-  if (process.env.WAYLAND_DISPLAY) return { cmd: 'wl-copy', args: [], input: text };
-  return { cmd: 'xclip', args: ['-selection', 'clipboard'], input: text };
+  if (process.platform === 'darwin') return { cmd: 'pbcopy', args: [], input: value };
+  if (process.env.WAYLAND_DISPLAY) return { cmd: 'wl-copy', args: [], input: value };
+  return { cmd: 'xclip', args: ['-selection', 'clipboard'], input: value };
 }
 
 export function copyToClipboard(text) {
   const value = String(text ?? '');
   const wroteOsc52 = writeOsc52Clipboard(value);
+  // When OSC 52 already wrote the clipboard, fire-and-forget the native helper
+  // and resolve immediately so the TUI never blocks on subprocess startup/exit
+  // (clip.exe/pbcopy/etc. still finish in the background). When OSC 52 was
+  // skipped (payload too large), the native helper is the ONLY writer, so we
+  // must await its exit to report real success/failure instead of a false
+  // "copied" hint.
   return new Promise((resolve, reject) => {
     const { cmd, args, input } = nativeClipboardCommand(value);
     let child;
@@ -54,14 +67,21 @@ export function copyToClipboard(text) {
       return;
     }
     child.on('error', (e) => {
-      if (wroteOsc52) resolve();
-      else reject(e);
-    });
-    child.on('close', (code) => {
-      if (code === 0 || wroteOsc52) resolve();
-      else reject(new Error(`${cmd} exited with code ${code}`));
+      // Surface only if OSC 52 didn't cover us; otherwise the copy still landed.
+      if (!wroteOsc52) reject(e);
     });
+    if (!wroteOsc52) {
+      child.on('close', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`${cmd} exited with code ${code}`));
+      });
+    }
     child.stdin.on('error', () => { /* ignore EPIPE if the helper closed early */ });
     child.stdin.end(input);
+    // OSC 52 covered us: resolve now, don't await the child's exit.
+    if (wroteOsc52) {
+      child.unref?.();
+      resolve();
+    }
   });
 }

package/src/tui/app/doctor.mjs

@@ -14,9 +14,37 @@ import { compareSemver } from '../../runtime/shared/update-checker.mjs';
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { resolvePluginData } from '../../runtime/shared/plugin-paths.mjs';
 
 const GLYPH = { ok: '✓', warn: '⚠', fail: '✗' };
 
+// Windows Defender real-time scanning of the Postgres data dir shows up as
+// pathologically long checkpoint write phases in pg.log (e.g. write=12 s for a
+// <10MB checkpoint). Get-MpPreference needs admin, so we never read the actual
+// exclusion list — we infer interference from checkpoint timings instead.
+const CKPT_WRITE_WARN_S = 10; // any single checkpoint write phase over this = suspicious
+const CKPT_WRITE_MEDIAN_S = 5; // sustained median over this = suspicious
+
+function parseCheckpointWriteSeconds(logText) {
+  const lines = String(logText).split(/\r?\n/).slice(-200);
+  const out = [];
+  for (const line of lines) {
+    const m = /checkpoint complete:.*?\bwrite=([\d.]+)\s*s/i.exec(line);
+    if (m) {
+      const v = Number(m[1]);
+      if (Number.isFinite(v)) out.push(v);
+    }
+  }
+  return out;
+}
+
+function median(nums) {
+  if (!nums.length) return 0;
+  const s = [...nums].sort((a, b) => a - b);
+  const mid = s.length >> 1;
+  return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+}
+
 function readPackageJson() {
   try {
     const dir = dirname(fileURLToPath(import.meta.url));
@@ -171,5 +199,34 @@ export async function buildDoctorReport(runtime = {}, getState = () => ({})) {
     row('ok', `${enabled ? 'enabled' : 'disabled'} · ${events.length} event${events.length === 1 ? '' : 's'}`);
   });
 
+  // 8. defender (win32 only): infer AV real-time-scan interference on the PG
+  //    data dir from checkpoint write timings; report-only, so surface the
+  //    exact elevated exclusion one-liner as copyable fix text.
+  if (process.platform === 'win32') {
+    await check('defender', async (row) => {
+      const dataDir = resolvePluginData();
+      const pgdata = join(dataDir, 'pgdata');
+      let writes;
+      try {
+        writes = parseCheckpointWriteSeconds(readFileSync(join(dataDir, 'pg.log'), 'utf8'));
+      } catch {
+        row('ok', 'pg.log unavailable · check skipped');
+        return;
+      }
+      if (!writes.length) {
+        row('ok', 'no checkpoint timings yet');
+        return;
+      }
+      const max = Math.max(...writes);
+      const med = median(writes);
+      if (max <= CKPT_WRITE_WARN_S && med <= CKPT_WRITE_MEDIAN_S) {
+        row('ok', `checkpoint write median ${med.toFixed(1)}s · max ${max.toFixed(1)}s`);
+        return;
+      }
+      const fix = `Start-Process powershell -Verb RunAs -ArgumentList '-NoProfile','-Command',"Add-MpPreference -ExclusionPath '${pgdata}'"`;
+      row('warn', `slow checkpoints (median ${med.toFixed(1)}s · max ${max.toFixed(1)}s) suggest Defender real-time scan of ${pgdata}. Fix (run in PowerShell): ${fix}`);
+    });
+  }
+
   return ['mixdog doctor — installation health', ...rows].join('\n');
 }

package/src/tui/app/extension-pickers.mjs

@@ -15,6 +15,7 @@ export function createExtensionPickers({
   clean,
   copyToClipboard,
   setPicker,
+  getPicker,
   setProviderPrompt,
   setChannelPrompt,
   setHookPrompt,
@@ -22,6 +23,12 @@ export function createExtensionPickers({
   getDisabledSkills,
   setDisabledSkills,
 }) {
+  // MCP toggle settle-guard state: bumped per toggle (epoch) and armed only
+  // while the MCP picker is on screen (see openMcpServersPicker). The live
+  // picker is read via getPicker() so a stale settle can also detect pickers
+  // opened outside this factory replacing the MCP one.
+  let mcpEpoch = 0;
+  let mcpActive = false;
   const mcpStatus = () => {
     let status;
     try {
@@ -37,6 +44,7 @@ export function createExtensionPickers({
     const status = mcpStatus();
     if (!status) return;
     const servers = status.servers || [];
+    const optimistic = options?.optimistic || null;
     const items = [];
     if (servers.length === 0) {
       items.push({
@@ -47,13 +55,16 @@ export function createExtensionPickers({
       });
     }
     for (const server of servers) {
-      const enabled = server.enabled !== false;
+      const pending = optimistic && optimistic.name === server.name;
+      const enabled = pending ? optimistic.enabled : server.enabled !== false;
       items.push({
         value: `server:${server.name}`,
         label: server.name,
         marker: enabled ? '●' : '○',
         markerColor: enabled ? theme.success : theme.inactive,
-        description: `${server.status || 'unknown'} · ${server.transport || 'unknown'} · ${server.toolCount || 0} tools${server.error ? ` · ${server.error}` : ''}`,
+        description: pending
+          ? `${optimistic.enabled ? 'enabling' : 'disabling'}… · ${server.transport || 'unknown'}`
+          : `${server.status || 'unknown'} · ${server.transport || 'unknown'} · ${server.toolCount || 0} tools${server.error ? ` · ${server.error}` : ''}`,
         _action: 'server',
         _server: server,
         _enabled: enabled,
@@ -65,11 +76,31 @@ export function createExtensionPickers({
     setSettingsPrompt(null);
     const toggleServer = (item) => {
       if (item._action !== 'server' || !item._server?.name) return;
-      void store.setMcpServerEnabled?.(item._server.name, !item._enabled)
-        .then(() => openMcpServersPicker({ highlightValue: `server:${item._server.name}` }))
-        .catch((e) => store.pushNotice(`mcp toggle failed: ${e?.message || e}`, 'error'));
+      const name = item._server.name;
+      const target = !item._enabled;
+      const highlightValue = `server:${name}`;
+      // A settle is only allowed to touch the UI if it is still the newest
+      // toggle (token === mcpEpoch) and the MCP picker is still on screen.
+      const token = ++mcpEpoch;
+      const settle = (fn) => {
+        if (token !== mcpEpoch || !mcpActive || getPicker?.()?._kind !== 'mcp-servers') return;
+        fn();
+      };
+      // Optimistic: instantly reopen with the row flipped + pending status.
+      openMcpServersPicker({ highlightValue, optimistic: { name, enabled: target } });
+      Promise.resolve(store.setMcpServerEnabled?.(name, target))
+        .then(() => {
+          // Per-server serialization in the runtime already converged rapid
+          // re-toggles to the last requested state; just refresh the row.
+          settle(() => openMcpServersPicker({ highlightValue }));
+        })
+        .catch((e) => {
+          store.pushNotice(`mcp toggle failed: ${e?.message || e}`, 'error');
+          settle(() => openMcpServersPicker({ highlightValue }));
+        });
     };
     setPicker({
+      _kind: 'mcp-servers',
       title: 'MCP servers',
       description: 'Enable or disable configured MCP servers.',
       initialIndex: Math.max(0, items.findIndex((entry) => entry.value === options?.highlightValue)),
@@ -78,9 +109,13 @@ export function createExtensionPickers({
       onLeft: (item) => toggleServer(item),
       onRight: (item) => toggleServer(item),
       onCancel: () => {
+        // Leaving the picker invalidates any in-flight settle.
+        mcpActive = false;
+        mcpEpoch++;
         setPicker(null);
       },
     });
+    mcpActive = true;
   };
 
   const openMcpPicker = () => {
@@ -141,9 +176,16 @@ export function createExtensionPickers({
   };
 
   const openSkillsPicker = (options = {}) => {
-    const status = skillsStatus();
-    if (!status) return;
-    const skills = status.skills || [];
+    // Reuse the skills list already fetched by the opening call when a toggle
+    // reopens the picker: avoids a store.skillsStatus() round-trip per keypress.
+    let skills;
+    if (Array.isArray(options.skills)) {
+      skills = options.skills;
+    } else {
+      const status = skillsStatus();
+      if (!status) return;
+      skills = status.skills || [];
+    }
     const disabledSet = options.disabledOverride instanceof Set ? options.disabledOverride : getDisabledSkills();
     const items = [];
     if (skills.length === 0) {
@@ -181,9 +223,10 @@ export function createExtensionPickers({
         `skill ${item._enabled ? 'disabled' : 'enabled'}: ${name} (prompt updates next session /clear)`,
         'info',
       );
-      openSkillsPicker({ highlightValue: name, disabledOverride: next });
+      openSkillsPicker({ highlightValue: name, disabledOverride: next, skills });
     };
     setPicker({
+      _kind: 'skills',
       title: 'Skills',
       description: 'Enable or disable project skills.',
       initialIndex: Math.max(0, items.findIndex((entry) => entry.value === options.highlightValue)),
@@ -482,6 +525,7 @@ export function createExtensionPickers({
       }
     };
     setPicker({
+      _kind: 'hooks',
       title: 'Hooks',
       description: 'Before-tool hook rules; Enter toggles a rule.',
       items,

package/src/tui/app/maintenance-pickers.mjs

@@ -210,8 +210,6 @@ export function createMaintenancePickers({
       const current = readCurrent();
       const enabled = current?.enabled !== false;
       const idleMs = Number(current?.idleMs || HOUR_MS);
-      const custom = current?.custom === true;
-      const providerDefault = Number(current?.providerDefault || HOUR_MS);
       const cacheTtlLabel = !enabled || idleMs >= HOUR_MS ? '1h' : '5m';
       const items = [
         {
@@ -226,9 +224,6 @@ export function createMaintenancePickers({
         {
           value: 'advanced',
           label: 'Advanced',
-          marker: !custom ? '✓' : '',
-          markerColor: theme.success,
-          meta: `${current?.provider || 'current'} · ${formatDuration(providerDefault)}`,
           description: 'Edit provider-paired default idle windows as text.',
           _action: 'advanced',
         },