mixdog 1.4.1 → 1.4.3

package/src/tui/app/provider-setup/api-key-actions.mjs

@@ -6,9 +6,13 @@ import { openInBrowser } from '../../../runtime/shared/open-url.mjs';
 import { providerDetailText } from '../app-format.mjs';
 import { forgetProviderAuth, keyConsoleUrl, providerStatusFooter } from './provider-items.mjs';
 
-const setApiKeyPrompt = (flow, providerItem) => {
+const VERTEX_EXPRESS_HINT =
+  'Express mode API keys serve Gemini models on the global location only. Claude and MaaS models need a service-account key or the gcloud login.';
+
+const setApiKeyPrompt = (flow, providerItem, extra = {}) => {
   if (!flow.ownsSurface()) return;
   flow.setProviderPrompt({
+    ...extra,
     kind: 'api-key',
     providerId: providerItem._providerId,
     label: providerItem._providerName,
@@ -51,6 +55,28 @@ function apiKeyActions(providerItem, provider) {
   return { apiActions, keyUrl };
 }
 
+// Vertex AI takes either a service-account key or an express-mode API key.
+function openVertexModePicker(flow, providerItem) {
+  flow.paint({
+    title: `Provider · ${providerItem._providerName}`,
+    description: 'Choose the Vertex AI key type.',
+    help: '↑/↓ Select · Enter Choose · Esc Back',
+    indexMode: 'always',
+    labelWidth: 22,
+    pickerKey: `providers-vertex-mode:${providerItem.value}`,
+    initialIndex: 0,
+    items: [
+      { value: 'service-account', label: 'Service account key', description: 'service-account JSON' },
+      { value: 'api-key', label: 'API key (express mode)', description: 'Gemini only · global location' },
+    ],
+    onSelect: (mode) => {
+      flow.releaseSurface();
+      setApiKeyPrompt(flow, providerItem, mode === 'api-key' ? { authMode: 'api-key', hint: VERTEX_EXPRESS_HINT } : {});
+    },
+    onCancel: () => openApiProviderActions(flow, providerItem),
+  });
+}
+
 export function openApiProviderActions(flow, providerItem) {
   // Reached from acks (a failed forget-key) as well as key presses: prove
   // ownership at the sink so every caller is covered.
@@ -69,6 +95,10 @@ export function openApiProviderActions(flow, providerItem) {
     initialIndex: 0,
     items: apiActions,
     onSelect: (_detailValue, detail) => {
+      if (detail._action === 'set-key' && providerItem._providerId === 'vertex-ai') {
+        openVertexModePicker(flow, providerItem);
+        return;
+      }
       flow.releaseSurface();
       if (detail._action === 'set-key') {
         setApiKeyPrompt(flow, providerItem);

package/src/tui/app/provider-setup/oauth-actions.mjs

@@ -16,11 +16,21 @@ const panelFrame = (providerItem, provider, pickerKey) => ({
   initialIndex: 0,
 });
 
-function showOAuthProgress(flow, providerItem, message, onBack) {
+// Shown with every device code: a code someone else hands you signs THEM in to your account.
+// One row that fits 80 columns: it takes the row the status footer did, so the URL
+// keeps its copy-hint row and the "Enter code" line is never replaced by the copy note.
+const DEVICE_CODE_WARNING = [
+  { glyph: '!', text: 'Continue only if you started this. Never enter a code someone sent you.' },
+];
+
+function showOAuthProgress(flow, providerItem, message, onBack, detail = '', footer = null) {
   const provider = providerItem._provider || {};
+  const frame = panelFrame(providerItem, provider, `providers-oauth-progress:${providerItem.value}`);
   flow.paint({
-    ...panelFrame(providerItem, provider, `providers-oauth-progress:${providerItem.value}`),
+    ...frame,
+    ...(footer ? { footer } : {}),
     description: message,
+    detail,
     help: '↑/↓ Select · Enter Choose · Esc Providers',
     indexMode: 'never',
     items: [
@@ -80,10 +90,11 @@ function oauthCodeHint(manualUrl, loginUrl, providerName) {
   return `Paste the authorization code or full redirect URL for ${providerName}.`;
 }
 
+// The URL goes in the picker's wrapped `detail` block, never the one-line description.
 function pollingLoginMessage(userCode, loginUrl, opened) {
-  if (userCode) return `Enter code ${userCode} at:\n${loginUrl}${opened}`;
-  if (loginUrl) return `Open this URL to sign in:\n${loginUrl}${opened}`;
-  return 'Finish signing in for this provider.';
+  if (userCode) return { message: `Enter code ${userCode} at${opened}:`, detail: loginUrl };
+  if (loginUrl) return { message: `Open this URL to sign in${opened}:`, detail: loginUrl };
+  return { message: 'Finish signing in for this provider.', detail: '' };
 }
 
 /** Login through store.beginOAuthProviderLogin: a code-completing login hands
@@ -148,7 +159,15 @@ function beginInteractiveOAuthLogin(flow, providerItem, login) {
         // Device-code and URL-only polling logins stay in the progress panel,
         // with the code and URL, until the result panel replaces it or Back.
         const opened = openBrowser ? ' (browser opened)' : '';
-        showOAuthProgress(flow, providerItem, pollingLoginMessage(started?.userCode, loginUrl, opened), login.onBack);
+        const { message, detail } = pollingLoginMessage(started?.userCode, loginUrl, opened);
+        showOAuthProgress(
+          flow,
+          providerItem,
+          message,
+          login.onBack,
+          detail,
+          started?.userCode ? () => DEVICE_CODE_WARNING : null
+        );
       }
       started.waitForCallback
         ?.then((result) => {

package/src/tui/app/provider-setup-picker.mjs

@@ -18,6 +18,25 @@ import {
 
 const providerFooter = (item) => providerStatusFooter(item?._provider);
 
+/** The rows of the main provider list: the continue row, one row per provider,
+ *  and the client refresh row. */
+function mainListItems(setup, options, canContinue) {
+  const items = [];
+  if (canContinue && !options.confirmBar) {
+    items.push({
+      value: 'continue-setup',
+      label: options.continueLabel || 'Continue setup',
+      description: options.continueDescription || 'return to setup',
+      _type: 'continue',
+    });
+  }
+  items.push(...buildProviderItems(setup));
+  if (setup.managedByClient === true) {
+    items.push({ value: 'refresh-client-providers', label: 'Refresh', _type: 'refresh-client-providers' });
+  }
+  return items;
+}
+
 export function createProviderSetupPicker({
   store,
   surface,
@@ -87,19 +106,7 @@ export function createProviderSetupPicker({
       if (!setup) return;
     }
 
-    const items = [];
-    if ((returnTo || onContinue) && !options.confirmBar) {
-      items.push({
-        value: 'continue-setup',
-        label: options.continueLabel || 'Continue setup',
-        description: options.continueDescription || 'return to setup',
-        _type: 'continue',
-      });
-    }
-    items.push(...buildProviderItems(setup));
-    if (setup.managedByClient === true) {
-      items.push({ value: 'refresh-client-providers', label: 'Refresh', _type: 'refresh-client-providers' });
-    }
+    const items = mainListItems(setup, options, Boolean(returnTo || onContinue));
 
     const flow = {
       store,

package/src/tui/app/settings-picker.mjs

@@ -13,6 +13,16 @@ import { settingsHandoffPanel, createSettingsNavigation } from './settings-picke
 import { buildSettingsItems, readSettingsView } from './settings-picker/settings-rows.mjs';
 import { createSettingsToggles } from './settings-picker/settings-toggles.mjs';
 
+// The factory is rebuilt every render, so the heavy-read gate lives beside the
+// App-owned cache ref it protects: `running` is the one heavy read in flight,
+// `queued` the single follow-up owed to changes that arrived meanwhile, and
+// `freshWrites` counts heavy reads that wrote the cache.
+const heavyGates = new WeakMap();
+const heavyGateOf = (cacheRef) => {
+  if (!heavyGates.has(cacheRef)) heavyGates.set(cacheRef, { running: false, queued: false, freshWrites: 0 });
+  return heavyGates.get(cacheRef);
+};
+
 export function createSettingsPicker({
   store,
   state,
@@ -21,6 +31,7 @@ export function createSettingsPicker({
   setSettingsPrompt,
   settingsHeavyCacheRef,
   settingsRequestRef,
+  settingsLiveRefreshRef,
   formatDuration,
   displayModelName,
   routeModelLabel,
@@ -51,16 +62,31 @@ export function createSettingsPicker({
     // destination synchronously before the daemon snapshot so the empty-chat
     // welcome logo cannot appear between the old panel and Settings.
     if (!light && !own.paint(settingsHandoffPanel())) return;
-    const heavyCache = light ? settingsHeavyCacheRef.current : null;
+    // `heavy` re-reads MCP/plugin/skill status even on a light (no handoff
+    // paint) build: the cached values would otherwise win over a fresh snapshot.
+    const heavyCache = light && opts.heavy !== true ? settingsHeavyCacheRef.current : null;
     // ONE round-trip for the whole panel: on a daemon-backed store each getter
     // below is a serialized remote call, and reading them synchronously handed
     // back promises (every row rendered its default). getSettingsSnapshot runs
     // the same getters engine-side and answers once.
+    const gate = heavyGateOf(settingsHeavyCacheRef);
+    const freshWritesAtStart = gate.freshWrites;
     const snapshot = (await store.getSettingsSnapshot?.({ heavy: !heavyCache })) || {};
-    const view = readSettingsView({ snapshot, heavyCache, state });
+    const view = readSettingsView({ snapshot, heavyCache, state }); // A superseded build (newer open/refresh) or one whose panel was already
+    // closed with Esc must never paint, clear prompts or write the cache: an
+    // older response settling late would otherwise roll the cache back for
+    // every later light refresh.
+    if (!isCurrentSettingsRequest(requestId)) {
+      // Its fresh heavy rows were dropped; unless a newer heavy read already
+      // refreshed the cache, owe the still-open panel one follow-up read.
+      if (!heavyCache && own.owns() && gate.freshWrites === freshWritesAtStart) gate.queued = true;
+      return;
+    }
+    if (!own.owns()) return;
     // Refresh the cache every build (light or full) so the next light
     // refresh reuses whatever was most recently known.
     settingsHeavyCacheRef.current = { mcp: view.mcp, plugins: view.plugins, skills: view.skills };
+    if (!heavyCache) gate.freshWrites += 1;
     const toggles = createSettingsToggles({
       store,
       view,
@@ -85,10 +111,6 @@ export function createSettingsPicker({
       routeModelLabel,
       workflowDisplayName,
     });
-    // A superseded build (newer open/refresh) or one whose panel was already
-    // closed with Esc must never paint or clear prompts.
-    if (!isCurrentSettingsRequest(requestId)) return;
-    if (!own.owns()) return;
     setProviderPrompt(null);
     setSettingsPrompt(null);
     own.paint({
@@ -116,6 +138,11 @@ export function createSettingsPicker({
         own.close();
       },
     });
+    // A settings change from elsewhere re-reads this panel while it is still
+    // the one on screen (the claim's epoch guards a closed or replaced panel).
+    // The change names no section (MCP servers, plugins and skills may have
+    // moved), so unlike a post-write refresh it re-reads the heavy rows too.
+    if (settingsLiveRefreshRef) settingsLiveRefreshRef.current = own.defer(() => refreshSettings({ heavy: true }));
   };
 
   // Public entry point. NEVER rejects: callers fire it detached
@@ -130,8 +157,26 @@ export function createSettingsPicker({
       store.pushNotice(`settings unavailable: ${error?.message || error}`, 'error');
     }
   };
-  const refreshSettings = () => {
-    void openSettingsPicker({ light: true });
+  // One heavy read at a time; changes arriving meanwhile share a single
+  // follow-up, which goes through the live-refresh callback so it is a no-op
+  // once the panel was closed or replaced.
+  const refreshHeavy = () => {
+    const gate = heavyGateOf(settingsHeavyCacheRef);
+    if (gate.running) {
+      gate.queued = true;
+      return;
+    }
+    gate.running = true;
+    void openSettingsPicker({ light: true, heavy: true }).finally(() => {
+      gate.running = false;
+      if (!gate.queued) return;
+      gate.queued = false;
+      settingsLiveRefreshRef?.current?.();
+    });
+  };
+  const refreshSettings = ({ heavy = false } = {}) => {
+    if (heavy) refreshHeavy();
+    else void openSettingsPicker({ light: true });
   };
   const navigation = createSettingsNavigation({ openers, openSettingsPicker, setSettingsPrompt });
 

package/src/tui/app/shell-layout/row-budgets.mjs

@@ -4,8 +4,9 @@
  * welcome banner, floating panel, and the layout signature that names them.
  */
 import { isLiveSpinnerMetaVisible } from '../live-spinner-visibility.mjs';
-import { promptContentRows, wrappedDetailRows, queuedBandRows } from '../text-layout.mjs';
+import { promptContentRows, queuedBandRows } from '../text-layout.mjs';
 import { questionPanelRows, questionsOf } from '../../components/question-panel-model.mjs';
+import { signInUrlLayout } from '../../components/sign-in-url-layout.mjs';
 import { CORE_MULTILINE_TEXT_ENTRY_KINDS } from '../panel-signature.mjs';
 import { btwPanelRows } from '../btw-controller.mjs';
 
@@ -49,24 +50,25 @@ function promptBoxBudget(inputBoxHidden, promptLayoutValueRef, promptContentColu
 
 // TextEntryPanel content is one prompt line (chrome + 1) for single-line
 // prompts, or up to PANEL_MAX_VISIBLE wrapped rows for core memory add/edit.
-// PLUS an optional wrapped detail block (blank spacer + N wrapped rows — e.g.
-// the manual OAuth URL). The floating container clips from the TOP (flex-end +
+// PLUS an optional borderless sign-in URL block under the panel (the manual
+// OAuth URL). The floating container clips from the TOP (flex-end +
 // overflow hidden), so under-reserving here pushed the bordered title off
-// the top of the panel. Width matches the panel interior: frame − 2 border
-// − 2 paddingX, same wrap-ansi math ink uses for wrap="wrap".
-function textEntryBudget(textEntryPrompt, textEntryLayoutRows, frameColumns) {
+// the top of the panel. The block gets only the rows the terminal leaves
+// (maxFloatingPanelRows minus chrome and content) and TextEntryPanel degrades
+// it to fit, using the same sign-in-url-layout math.
+function textEntryBudget(textEntryPrompt, textEntryLayoutRows, frameColumns, maxFloatingPanelRows) {
   const textEntryKind = String(textEntryPrompt?.kind || '');
   const textEntryMultiline = CORE_MULTILINE_TEXT_ENTRY_KINDS.has(textEntryKind);
   const textEntryDetailText = String(textEntryPrompt?.detail || '').trim();
-  const textEntryDetailRows = textEntryDetailText
-    ? 1 + wrappedDetailRows(textEntryDetailText, Math.max(1, frameColumns - 4))
-    : 0;
   const textEntryContentRows = textEntryMultiline ? textEntryLayoutRows : 1;
+  const textEntryUrlMaxRows = Math.max(0, maxFloatingPanelRows - PANEL_CHROME_ROWS - textEntryContentRows);
+  const textEntryDetailRows = signInUrlLayout(textEntryDetailText, frameColumns, textEntryUrlMaxRows).rows;
   return {
     textEntryKind,
     textEntryMultiline,
     textEntryDetailText,
     textEntryDetailRows,
+    textEntryUrlMaxRows,
     textEntryContentRows,
     TEXT_ENTRY_ROWS: PANEL_CHROME_ROWS + textEntryContentRows + textEntryDetailRows,
   };
@@ -137,8 +139,8 @@ function floatingPanelBudget({
   else if (btwPanel) desiredFloatingPanelRows = btwPanelRows(btwPanel, frameColumns);
   const floatingPanelRows = desiredFloatingPanelRows > 0 ? Math.min(desiredFloatingPanelRows, maxFloatingPanelRows) : 0;
   // Give the list every content row the panel exposes. The panel already grew
-  // by OPTION_PANEL_EXTRA_ROWS; previously that growth was subtracted back out
-  // here, so the rows leaked into an empty flexGrow gap instead of the list.
+  // by OPTION_PANEL_EXTRA_ROWS; subtracting that growth back out would leak the
+  // rows into an empty flexGrow gap instead of the list.
   // Reserving only PICKER_CHROME_ROWS lets the list occupy the full interior
   // (the footer's own reservation is handled inside Picker).
   const pickerVisibleRows = picker ? Math.max(1, floatingPanelRows - PICKER_CHROME_ROWS) : PANEL_MAX_VISIBLE;
@@ -187,7 +189,6 @@ export function computeRowBudgets({
   const { textEntryPrompt, hasTextEntryPrompt, hasFloatingPanel, expandedOptionPanel, inputBoxHidden } = surfaces;
   const { liveSpinner, liveSpinnerIsCommand, latestTranscriptItem, inputHint } = hints;
   const prompt = promptBoxBudget(inputBoxHidden, promptLayoutValueRef, promptContentColumns);
-  const textEntry = textEntryBudget(textEntryPrompt, textEntryLayoutRows, frameColumns);
   const OPTION_PANEL_EXTRA_ROWS = expandedOptionPanel ? 3 : 0;
   const queuedVisible = !hasFloatingPanel && !inputBoxHidden && state.queued?.length > 0;
   // While the slash palette is open it owns the area above the prompt, so the
@@ -214,6 +215,7 @@ export function computeRowBudgets({
   const baseReserve =
     welcome.WELCOME_ROWS + SCROLL_HINT_ROWS + LIVE_STATUS_ROWS + INPUT_BOX_ROWS + STATUSLINE_ROWS + queued.queuedRows;
   const maxFloatingPanelRows = Math.max(0, resizeState.rows - baseReserve - 1);
+  const textEntry = textEntryBudget(textEntryPrompt, textEntryLayoutRows, frameColumns, maxFloatingPanelRows);
   const panel = floatingPanelBudget({
     toolApproval,
     picker,

package/src/tui/app/slash-commands.mjs

@@ -24,7 +24,7 @@ export const SLASH_COMMANDS = [
   {
     name: 'goal',
     usage: '/goal',
-    params: '[objective --time 1h --time-mode max|status|pause|resume|edit|stop]',
+    params: '[objective --time 1h|status|pause|resume|edit|stop]',
     description: 'Run and manage a durable session Goal',
   },
   {
@@ -41,6 +41,7 @@ export const SLASH_COMMANDS = [
     params: '[release <task_id> [--confirm]]',
     description: 'List shells; release one whose termination is unconfirmed',
   },
+  { name: 'stop', usage: '/stop', description: 'Stop every background shell of this session' },
   {
     name: 'fork',
     usage: '/fork',

package/src/tui/app/slash-dispatch/route-commands.mjs

@@ -139,7 +139,7 @@ export const routeCommands = {
 
   effort(ctx, arg) {
     const { state, store, openSlashPanel, deps } = ctx;
-    // A running turn no longer blocks the switch: the in-flight turn keeps
+    // A running turn does not block the switch: the in-flight turn keeps
     // the effort it started with, and the new level applies from the next
     // turn. Same for /fast below.
     const pendingTurn = state.busy ? ' (applies from the next turn)' : '';

package/src/tui/app/slash-dispatch/session-commands.mjs

@@ -4,6 +4,7 @@
 // while a turn or session command is running.
 import { presentErrorText } from '../../../runtime/shared/err-text.mjs';
 import { BTW_USAGE_HINT } from '../btw-controller.mjs';
+import { theme } from '../../theme.mjs';
 
 function compactFailureNotice(error) {
   if (error == null || String(error).trim() === '') return 'Compact failed.';
@@ -84,7 +85,7 @@ export const sessionCommands = {
           store.pushNotice('Goal is unavailable.', 'warn');
           return;
         }
-        store.pushNotice(result.message || 'Goal updated.', 'info');
+        store.pushNotice(result.message || 'Goal updated.', result.ok === false ? 'warn' : 'info');
       })
       .catch((error) => store.pushNotice(`Goal failed: ${error?.message || error}`, 'error'));
     return true;
@@ -168,6 +169,51 @@ export const sessionCommands = {
     return true;
   },
 
+  // /stop — stop every background shell of this session (never the running
+  // foreground command, agents or other sessions) after one confirmation.
+  stop(ctx) {
+    const { store, surface } = ctx;
+    const stopAll = () =>
+      Promise.resolve(store.stopShellJobs?.())
+        .then((result) => {
+          const stopped = result?.stopped || 0;
+          const stopping = result?.stopping || 0;
+          store.pushNotice(
+            stopping
+              ? `Stopped background shells: ${stopped} · still stopping: ${stopping}`
+              : `Stopped background shells: ${stopped}`,
+            stopping ? 'warn' : 'info'
+          );
+        })
+        .catch((error) => store.pushNotice(String(error?.message || error), 'error'));
+    void Promise.resolve(store.listStoppableShellJobs?.())
+      .then((result) => {
+        const jobs = Array.isArray(result?.jobs) ? result.jobs : [];
+        if (!jobs.length) {
+          store.pushNotice('No background shells are running.', 'info');
+          return;
+        }
+        const own = surface.claim();
+        own.paint({
+          title: `Stop background shells (${jobs.length})?`,
+          indexMode: 'always',
+          labelWidth: 12,
+          items: [
+            { value: 'cancel', label: 'Cancel' },
+            { value: 'stop', label: 'Stop' },
+          ],
+          footer: jobs.map((job) => ({ glyph: '·', color: theme.warning, text: job.command })),
+          onSelect: (value) => {
+            own.close();
+            if (value === 'stop') void stopAll();
+          },
+          onCancel: () => own.close(),
+        });
+      })
+      .catch((error) => store.pushNotice(String(error?.message || error), 'error'));
+    return true;
+  },
+
   doctor(ctx) {
     const { state, store, deps } = ctx;
     if (state.commandBusy) {

package/src/tui/app/slash-dispatch.mjs

@@ -17,7 +17,7 @@ import { createSlashPanelOpener } from './slash-dispatch/slash-panel.mjs';
 const commands = { ...routeCommands, ...sessionCommands, ...panelCommands };
 
 export function createSlashDispatch({ state, store, normalizeSlashCommandName, surface, closeUsagePanel, ...deps }) {
-  const ctx = { state, store, deps, openSlashPanel: createSlashPanelOpener({ surface, store }) };
+  const ctx = { state, store, deps, surface, openSlashPanel: createSlashPanelOpener({ surface, store }) };
   const runSlashCommand = (cmd, arg = '') => {
     const rawName = String(cmd || '').toLowerCase();
     cmd = normalizeSlashCommandName(cmd);

package/src/tui/app/use-btw-panel.mjs

@@ -0,0 +1,29 @@
+/*
+ * app/use-btw-panel.mjs — the /btw side-question panel: its state, the
+ * controller that fills it, and the controller's session/unmount lifecycle.
+ */
+import { useEffect, useRef, useState } from 'react';
+import { createBtwController } from './btw-controller.mjs';
+
+export function useBtwPanel({ store, sessionId }) {
+  const [btwPanel, setBtwPanel] = useState(null);
+  const btwRef = useRef(null);
+  const sessionIdRef = useRef('');
+  sessionIdRef.current = sessionId || '';
+  if (!btwRef.current) {
+    btwRef.current = createBtwController({
+      getStore: () => store,
+      setPanel: setBtwPanel,
+      getSessionId: () => sessionIdRef.current,
+    });
+  }
+  const btw = btwRef.current;
+  // A side answer belongs to the conversation it was asked in: drop it on a
+  // session change (new/resume/clear/switch) and cancel it on unmount.
+  // biome-ignore lint/correctness/useExhaustiveDependencies(sessionId): session-change trigger; the controller reads the id through its getter
+  useEffect(() => {
+    btw.sync();
+  }, [btw, sessionId]);
+  useEffect(() => () => btw.dispose(), [btw]);
+  return { btwPanel, btw };
+}

package/src/tui/app/use-context-panel-refresh.mjs

@@ -0,0 +1,31 @@
+/*
+ * app/use-context-panel-refresh.mjs — keeps an open /context breakdown panel
+ * current: it is rebuilt whenever one of the session fields it summarizes
+ * changes.
+ */
+import { useEffect } from 'react';
+
+export function useContextPanelRefresh({ contextPanelKind, state, openContextPicker }) {
+  // The deps are the refresh triggers (the fields the breakdown summarizes),
+  // not the reads; openContextPicker is rebuilt by its factory every render
+  // and must not re-trigger the rebuild.
+  // biome-ignore lint/correctness/useExhaustiveDependencies: trigger-keyed refresh over the summarized session fields
+  useEffect(() => {
+    if (contextPanelKind === 'context') openContextPicker();
+  }, [
+    contextPanelKind,
+    state.stats,
+    state.contextWindow,
+    state.rawContextWindow,
+    state.sessionId,
+    state.toolMode,
+    state.agentWorkers,
+    state.agentJobs,
+    state.provider,
+    state.model,
+    state.effort,
+    state.fast,
+    state.cwd,
+    state.clientHostPid,
+  ]);
+}

package/src/tui/app/use-model-catalog-cache.mjs

@@ -20,16 +20,19 @@ export function useModelCatalogCache({ store, onboardingRef }) {
   // provider-scope cache clear (e.g. after auth) so a stale in-flight
   // listProviderModels() cannot repopulate the ref after invalidation.
   const onboardingPrefetchSeqRef = useRef(0);
-  const clearModelCaches = useCallback((scope = 'all') => {
-    if (scope === 'all' || scope === 'provider') {
-      providerModelsCacheRef.current = { models: null, at: 0 };
-      onboardingRef.current.providerModels = [];
-      onboardingPrefetchSeqRef.current += 1;
-    }
-    if (scope === 'all' || scope === 'webSearch') {
-      webSearchModelsCacheRef.current = { models: null, at: 0 };
-    }
-  }, []);
+  const clearModelCaches = useCallback(
+    (scope = 'all') => {
+      if (scope === 'all' || scope === 'provider') {
+        providerModelsCacheRef.current = { models: null, at: 0 };
+        onboardingRef.current.providerModels = [];
+        onboardingPrefetchSeqRef.current += 1;
+      }
+      if (scope === 'all' || scope === 'webSearch') {
+        webSearchModelsCacheRef.current = { models: null, at: 0 };
+      }
+    },
+    [onboardingRef]
+  );
   // Boot-time catalog prefetch: warm the /model & /agents provider catalog and
   // the /websearch catalog once at startup so those pickers open instantly from
   // cache (openModelPicker still TTL-refreshes stale rows in the background).

package/src/tui/app/use-mouse-input.mjs

@@ -316,6 +316,17 @@ export function useMouseInput({
     isRawModeSupported,
     store,
     stdout,
+    dragRef,
+    lastClickRef,
+    slashPaletteRef,
+    scrollFocusRef,
+    promptMouseSelectionRef,
+    frameRowsRef,
+    promptBoxRectRef,
+    transcriptViewportRef,
+    scrollTargetRef,
+    setSlashIndex,
+    setMeasuredRowsVersion,
     passthroughCtrlWheelZoom,
     frameColumns,
     statuslineBandRows,

package/src/tui/app/use-onboarding-start.mjs

@@ -1,7 +1,7 @@
 /*
  * app/use-onboarding-start.mjs — first-run onboarding gate + wizard launch.
  */
-import { useEffect } from 'react';
+import { useEffect, useRef } from 'react';
 
 // First-run gate. The daemon-backed engine store answers any method it does
 // not implement locally with an async remote call, so a synchronous
@@ -25,10 +25,15 @@ export function useOnboardingStart({
   store,
   forceOnboarding,
   onboardingCompleted,
-  onboardingStartedRef,
   setOnboardingActive,
   openOnboardingAuthStep,
 }) {
+  // Latches the launch so the wizard opens at most once per mount.
+  const onboardingStartedRef = useRef(false);
+  // openOnboardingAuthStep is rebuilt by the picker factory every render;
+  // depending on it would re-run this launch (and cancel its deferred open)
+  // on every commit. The launch keys on the gate inputs only.
+  // biome-ignore lint/correctness/useExhaustiveDependencies(openOnboardingAuthStep): per-render factory callback; launch keys on gate inputs
   useEffect(() => {
     if (onboardingStartedRef.current) return undefined;
     if (resolveOnboardingCompleted(store, onboardingCompleted) && !forceOnboarding) return undefined;
@@ -41,5 +46,5 @@ export function useOnboardingStart({
     return () => {
       canceled = true;
     };
-  }, [store, forceOnboarding, onboardingCompleted]);
+  }, [store, forceOnboarding, onboardingCompleted, setOnboardingActive]);
 }

package/src/tui/app/use-panel-transition.mjs

@@ -30,7 +30,16 @@ export function usePanelTransition({
     if (!hadTransitionClearance) return undefined;
     const timer = setTimeout(() => setPanelTransitionEpoch((epoch) => epoch + 1), 0);
     return () => clearTimeout(timer);
-  }, [panelLayoutSignature, bottomClusterRows, panelTransitionClearRows, panelTransitionGuardRows]);
+  }, [
+    panelTransitionRef,
+    panelCloseInkMaskRowsRef,
+    panelLayoutSignature,
+    bottomClusterRows,
+    panelTransitionClearRows,
+    panelTransitionGuardRows,
+    setPanelInkMaskEpoch,
+    setPanelTransitionEpoch,
+  ]);
   // Record the transcript tail id AFTER every commit so the next render's
   // spinner-meta-collapse gate (doneTailAppendedThisCommit) can tell a freshly
   // appended done row from a stale one that was already at the tail.