mixdog 1.2.1 → 1.2.3

package/src/tui/session/context-state.mjs

@@ -71,8 +71,10 @@ export function createContextState({
     // Lead workspace record (worktrees/contract.mjs SessionWorkspace): the
     // registered Project, the execution root, the worktree binding and its
     // revision. Null while the session has never left its project folder.
-    // Identity-stable until a transition commits.
-    workspace: runtime.getWorkspace?.() ?? null,
+    // Identity-stable until a transition commits. A project-folder session in a
+    // git repository publishes the folder's branch / detached commit too
+    // (getLiveWorkspace reads HEAD without spawning git).
+    workspace: runtime.getLiveWorkspace?.() ?? runtime.getWorkspace?.() ?? null,
     systemShell: runtime.systemShell || { source: 'auto', command: '', effective: '' },
     webSearchRoute: runtime.getWebSearchRoute?.() || runtime.webSearchRoute || null,
     autoClear: autoClearState(),

package/src/tui/session/quota-resume.mjs

@@ -11,6 +11,7 @@
 import {
   cancelQuotaResumeEntry,
   forgetQuotaSuspendedGoal,
+  isAgentOnlySession,
   noteQuotaSuspendedGoal,
   publicQuotaResume,
   quotaAutoResumeEnabled,
@@ -73,6 +74,20 @@ export function latestQuotaFailure(items) {
   return null;
 }
 
+/** The turn key of the failed turndone that ends the transcript, when no
+ *  later turn has begun; '' otherwise. */
+export function latestFailedTurnKey(items) {
+  const transcript = Array.isArray(items) ? items : [];
+  for (let index = transcript.length - 1; index >= 0; index -= 1) {
+    const item = transcript[index];
+    if (item?.kind === 'user' || item?.archived === true) return '';
+    if (item?.kind !== 'turndone') continue;
+    if (String(item.status || '').toLowerCase() !== 'failed') return '';
+    return transcriptTurnKeys(transcript)[index] || '';
+  }
+  return '';
+}
+
 /** What retrying the turn submits: its prompt when it produced no output, the
  *  continuation instruction when it did, null when the prompt carried no text
  *  (a media/attachment-only prompt cannot be replayed). */
@@ -125,6 +140,8 @@ export function createQuotaResumeLane(bag) {
     routeProvider: String(runtime.sessionProvider ?? runtime.provider ?? ''),
     routeModel: String(runtime.sessionModel ?? runtime.model ?? ''),
   });
+  // A delegated agent child never owns a resume: the Lead decides its retries.
+  const agentOnly = () => isAgentOnlySession({ id: currentId(), ...runtime.session });
   const queueResume = (sessionId, failure) =>
     scheduleQuotaResumeEntry({ sessionId, turnKey: failure.turnKey, ...failure.quota, ...sessionRoute() });
 
@@ -141,6 +158,21 @@ export function createQuotaResumeLane(bag) {
     forgetQuotaSuspendedGoal(sessionId);
   };
 
+  // Anything running, settling, closing or queued owns the session first.
+  const retryBlocked = () => {
+    const state = getState();
+    return (
+      flags.disposed ||
+      settlement !== null ||
+      (flags.admission || 'open') !== 'open' ||
+      state.busy ||
+      state.commandBusy ||
+      flags.autoClearRunning ||
+      flags.draining ||
+      pending.length > 0
+    );
+  };
+
   /** The one retry operation. `automatic` is the scheduler's resume: it
    *  enqueues directly, because the hours it waited must not trigger the idle
    *  auto-clear a user submission starts. */
@@ -166,7 +198,7 @@ export function createQuotaResumeLane(bag) {
       settlement = null;
       if (!id || !failure) return null;
       settlement = { sessionId: id, turnKey: failure.turnKey, epoch: cancelEpoch };
-      if (failure.quota.resetAt === null || !quotaAutoResumeEnabled()) return null;
+      if (failure.quota.resetAt === null || !quotaAutoResumeEnabled() || agentOnly()) return null;
       return queueResume(id, failure);
     },
 
@@ -188,6 +220,7 @@ export function createQuotaResumeLane(bag) {
     /** Explicit request to auto-resume the latest quota-failed turn. */
     scheduleQuotaResume(sessionId) {
       requireAddressed(sessionId);
+      if (agentOnly()) throw new Error('agent sessions do not auto-resume; the Lead decides retries');
       const failure = latestQuotaFailure(getState().items);
       if (!failure || failure.quota.resetAt === null) {
         throw new Error('latest turn did not fail on exhausted provider quota with a known reset time');
@@ -207,9 +240,15 @@ export function createQuotaResumeLane(bag) {
       if (sessionId) cancelFor(String(sessionId));
     },
 
+    /** A deferred retry request (the desktop's switch-model flow): checked
+     *  against the session's own state when it arrives, so it runs only while
+     *  `turnKey` is still the latest failed turn and nothing is running,
+     *  settling or queued. False when refused. */
     async retryFailedTurn(sessionId, turnKey) {
       requireAddressed(sessionId);
-      return (await retryFailedTurn(String(turnKey || ''))) === true;
+      const key = String(turnKey || '');
+      if (!key || retryBlocked() || latestFailedTurnKey(getState().items) !== key) return false;
+      return (await retryFailedTurn(key)) === true;
     },
 
     /** Scheduler fire for the entry of `generation`, after a usable reading.
@@ -219,19 +258,12 @@ export function createQuotaResumeLane(bag) {
       const id = currentId();
       const entry = quotaResumeEntry(id);
       if (!id || !entry || entry.generation !== generation) return 'stale';
-      const state = getState();
-      if (
-        flags.disposed ||
-        settlement !== null ||
-        (flags.admission || 'open') !== 'open' ||
-        state.busy ||
-        state.commandBusy ||
-        flags.autoClearRunning ||
-        flags.draining ||
-        pending.length > 0
-      ) {
-        return 'busy';
+      if (agentOnly()) {
+        cancelQuotaResumeEntry(id, { generation });
+        return 'agent-session';
       }
+      const state = getState();
+      if (retryBlocked()) return 'busy';
       const failure = latestQuotaFailure(state.items);
       if (!failure || failure.turnKey !== entry.turnKey) {
         cancelQuotaResumeEntry(id, { generation });

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

@@ -2,6 +2,7 @@
  * commands.mjs — the session object's long-running slash commands: memory
  * control, recall, doctor, and manual compaction (scheduled for turn end when
  * a turn is running). Each shows a command status while it holds the lock.
+ * /btw side questions (askSide/cancelSide) run beside them, lock-free.
  */
 import { compactEventDetail } from '../labels.mjs';
 import { archiveItemsForCompaction, compactionArchivedRows } from '../compaction-view.mjs';
@@ -92,34 +93,43 @@ export function createSessionCommandsApi(bag) {
     };
   };
 
+  // The compaction pass itself, under a lock its caller holds. `quiet` (the
+  // model switch's pre-compaction) asks the compactor to skip a pass that
+  // would not reduce anything and then adds no row for it.
+  async function runCompaction(startedAt, { quiet = false } = {}) {
+    // Give Ink one event-loop turn to paint the compacting spinner before
+    // runtime.compact() starts synchronous session/transcript work (same
+    // yield as the auto-clear path; without it /compact looks frozen with
+    // no spinner until the compact already finished).
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    const result = await runtime.compact({ recoverAgent: true, ...(quiet ? { requireReduction: true } : {}) });
+    const compactChanged = Boolean(result && !result.error && result.changed !== false);
+    syncContextStats({
+      allowEstimated: true,
+      invalidateExact: compactChanged,
+    });
+    set({ ...routeState(), stats: { ...getState().stats } });
+    if (compactChanged) {
+      // The compacted rows stay visible (archived) above the divider.
+      const { items } = archiveItemsForCompaction(getState().items, compactDoneItem(result, startedAt), null, {
+        archived: compactionArchivedRows(result),
+      });
+      set({ items: replaceItems(items, { preserveSpill: true }) });
+    } else if (!quiet || result?.error) {
+      pushItem(compactDoneItem(result, startedAt));
+    }
+    return result;
+  }
+
+  // An in-place model switch compacts first on the current model (routes.mjs
+  // holds the command lock and shows the compacting status meanwhile).
+  bag.compactBeforeModelSwitch = () => runCompaction(Date.now(), { quiet: true });
+
   async function compactCommand() {
     if (getState().commandBusy) return null;
     if (getState().busy) return scheduleCompactForTurnEnd(compactCommand);
     try {
-      return await withCommandStatus('Compacting conversation', 'compacting', async (startedAt) => {
-        // Give Ink one event-loop turn to paint the compacting spinner before
-        // runtime.compact() starts synchronous session/transcript work (same
-        // yield as the auto-clear path; without it /compact looks frozen with
-        // no spinner until the compact already finished).
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        const result = await runtime.compact({ recoverAgent: true });
-        const compactChanged = Boolean(result && !result.error && result.changed !== false);
-        syncContextStats({
-          allowEstimated: true,
-          invalidateExact: compactChanged,
-        });
-        set({ ...routeState(), stats: { ...getState().stats } });
-        if (compactChanged) {
-          // The compacted rows stay visible (archived) above the divider.
-          const { items } = archiveItemsForCompaction(getState().items, compactDoneItem(result, startedAt), null, {
-            archived: compactionArchivedRows(result),
-          });
-          set({ items: replaceItems(items, { preserveSpill: true }) });
-        } else {
-          pushItem(compactDoneItem(result, startedAt));
-        }
-        return result;
-      });
+      return await withCommandStatus('Compacting conversation', 'compacting', (startedAt) => runCompaction(startedAt));
     } finally {
       // A command reply reads the published snapshot, not the draft. Commit
       // completion before the awaiting service constructs that reply.
@@ -166,5 +176,14 @@ export function createSessionCommandsApi(bag) {
       });
     },
     compact: compactCommand,
+    // /btw: answered from the conversation so far while a turn keeps running.
+    // No command lock and no transcript row: the answer is only returned.
+    askSide: (question) => runtime.askSide(question),
+    // `sessionId` names the session the side question was asked in (it may
+    // no longer be the current one after a switch); omitted, the current one.
+    cancelSide: (sessionId) => {
+      if (typeof sessionId === 'string' && sessionId) runtime.cancelSide(sessionId);
+      else runtime.cancelSide();
+    },
   };
 }

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

@@ -91,8 +91,8 @@ export function createSessionControlsApi(bag) {
       );
       return result;
     },
-    setCwd: (path, options = {}) => {
-      const next = runtime.setCwd(path);
+    setCwd: async (path, options = {}) => {
+      const next = await runtime.setCwd(path);
       // 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);

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

@@ -28,6 +28,13 @@ export function createSessionExtensionsApi(bag) {
       { busyError: 'Another command is still running; try again when it finishes.' }
     );
   const pluginLabel = (result, plugin) => result?.plugin?.title || result?.plugin?.name || plugin?.name || plugin;
+  // MCP OAuth sign-in methods the runtime must implement (no silent fallback).
+  const mcpOAuth =
+    (name) =>
+    (...args) => {
+      if (typeof runtime[name] !== 'function') throw new Error('MCP sign-in is unavailable');
+      return runtime[name](...args);
+    };
 
   return {
     mcpStatus: () => {
@@ -55,6 +62,19 @@ export function createSessionExtensionsApi(bag) {
       (name) => runtime.removeMcpServer?.(name),
       (_status, name) => [`mcp removed: ${name}`]
     ),
+    // Explicit OAuth sign-in: no command lock, the flow runs on the server's
+    // own connect lane and the caller polls its status. The caller (TUI app)
+    // owns the sign-in completion notice; the store never posts one.
+    beginMcpOAuthLogin: async (name, options) => {
+      const result = await mcpOAuth('beginMcpOAuthLogin')(name, options);
+      if (result?.state === 'pending') pushNotice(`mcp sign-in started: ${name}`, 'info');
+      return result;
+    },
+    getMcpOAuthLoginStatus: mcpOAuth('getMcpOAuthLoginStatus'),
+    cancelMcpOAuthLogin: mcpOAuth('cancelMcpOAuthLogin'),
+    completeMcpOAuthLogin: mcpOAuth('completeMcpOAuthLogin'),
+    signOutMcpServer: lockedChange(mcpOAuth('signOutMcpServer'), (_status, name) => [`mcp signed out: ${name}`]),
+    probeMcpServerAuth: mcpOAuth('probeMcpServerAuth'),
     setMcpServerEnabled: async (name, enabled) => {
       // No global commandBusy: the runtime adopts config synchronously and
       // serializes the heavy connect/close/recreate per server name, so rapid
@@ -70,6 +90,8 @@ export function createSessionExtensionsApi(bag) {
       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 if (enabled && row?.authRequired) {
+        pushNotice(`mcp enabled: ${name} — sign-in required`, 'warn');
       } else {
         pushNotice(`mcp ${enabled ? 'enabled' : 'disabled'}: ${name}`, 'info');
       }

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

@@ -38,8 +38,8 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
     getQuotaHistory: async (options = {}) => {
       return await runtime.getQuotaHistory?.(options);
     },
-    getSessionUsage: async () => {
-      return await runtime.getSessionUsage?.();
+    getSessionUsage: async (options = {}) => {
+      return await runtime.getSessionUsage?.(options);
     },
     consumeCodexRateLimitResetCredit: async (options = {}) => {
       // Desktop capability parity: without this delegation the session runtime
@@ -52,6 +52,12 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
     getSessionReviewDiff: async () => {
       return (await runtime.getSessionReviewDiff?.()) ?? { supported: false, files: [], patch: '' };
     },
+    getSessionReviewFilePatch: async (file, oldPath) => {
+      return (await runtime.getSessionReviewFilePatch?.(file, oldPath)) ?? { supported: false, patch: '' };
+    },
+    getTurnReviewFilePatch: async (file) => {
+      return (await runtime.getTurnReviewFilePatch?.(file)) ?? { supported: false, patch: '' };
+    },
     revertTurnReview: async (checkpointId) => {
       return await requireRuntimeMethod('revertTurnReview', 'Turn review revert is unavailable')(checkpointId);
     },
@@ -78,6 +84,13 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
         revision
       );
     },
+    clearSessionChangeHistory: async () => {
+      // A queued or running prompt/command may still be about to record changes.
+      if (getState().busy || getState().commandBusy) {
+        throw new Error('Change history cannot be deleted while this session is running a turn');
+      }
+      return await requireRuntimeMethod('clearSessionChangeHistory', 'Change history deletion is unavailable')();
+    },
     getOnboardingStatus: () => {
       return runtime.getOnboardingStatus?.() || { completed: true, workflowRoutes: {} };
     },
@@ -133,6 +146,7 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
       return result;
     },
     testCustomProvider: (input) => runtime.testCustomProvider(input),
+    checkCustomProviderKeyEnv: (name) => runtime.checkCustomProviderKeyEnv(name),
     discoverCustomProviderModels: (input) => runtime.discoverCustomProviderModels(input),
     saveOpenCodeGoUsageAuth: async (opts) => {
       await runtime.saveOpenCodeGoUsageAuth(opts);

package/src/tui/session/session-api/lifecycle/dispose.mjs

@@ -40,6 +40,7 @@ export function createDisposeAction(bag, { oauthFlows }) {
         'unsubscribeAgentStatus',
         'unsubscribeRemoteState',
         'unsubscribeCompletionWakeGate',
+        'unsubscribeGitHeadWatch',
       ]) {
         try {
           lifecycle[key]?.();

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

@@ -8,6 +8,7 @@ import { createSessionResetActions } from './lifecycle/session-reset.mjs';
 import { createInheritanceActions } from './lifecycle/inheritance.mjs';
 import { createResumeAction } from './lifecycle/resume.mjs';
 import { createDisposeAction } from './lifecycle/dispose.mjs';
+import { publishModelSwitch } from './routes.mjs';
 
 export function createSessionLifecycleApi(bag, { restoreTranscriptItems, oauthFlows }) {
   const { runtime, pushNotice, removeNotice, setProgressHint, finishToolApproval } = bag;
@@ -55,7 +56,8 @@ export function createSessionLifecycleApi(bag, { restoreTranscriptItems, oauthFl
         id,
         approved,
         decision?.reason || (approved ? 'approved by user' : 'denied by user'),
-        typeof decision?.device === 'string' ? decision.device : ''
+        typeof decision?.device === 'string' ? decision.device : '',
+        decision?.answers
       );
     },
     pushNotice,
@@ -85,9 +87,12 @@ export function createSessionLifecycleApi(bag, { restoreTranscriptItems, oauthFl
       bag.supersedeQuotaResume?.(sessionId);
       bag.set({ commandBusy: true });
       try {
-        await runtime.continueSessionInModel(sessionId, route);
+        const result = await runtime.continueSessionInModel(sessionId, route);
         bag.set({ ...bag.routeState(), stats: { ...bag.getState().stats } });
         bag.syncContextStats?.({ allowEstimated: true });
+        // The same live divider as a picker switch; IPC and remote callers
+        // see it through the published snapshot.
+        publishModelSwitch(bag, result?.modelSwitch);
         return true;
       } finally {
         bag.set({ commandBusy: false });

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

@@ -3,6 +3,9 @@
  * the serialized optimistic setRoute, web-search route, workflows, agent
  * definitions, output style and orchestration mode.
  */
+import { modelSwitchItem } from '../../../runtime/agent/orchestrator/session/transcript-restore/restore.mjs';
+import { selectedModel, switchesSessionModel } from '../../../session-runtime/model-route/model-switch-target.mjs';
+import { latestQuotaFailure } from '../quota-resume.mjs';
 import { createApiHelpers } from './shared.mjs';
 
 // Optimistic route preview: the requested provider/model/effort/fast are
@@ -47,6 +50,12 @@ function optimisticRoutePatch(requested = {}, current = {}) {
   return patch;
 }
 
+/** The live divider of an in-place model switch (restored from message meta
+ *  after a reload); every switch path publishes it the same way. */
+export function publishModelSwitch(bag, modelSwitch) {
+  if (modelSwitch) bag.pushItem(modelSwitchItem(bag.nextId(), modelSwitch));
+}
+
 export function createSessionRouteApi(bag) {
   const {
     runtime,
@@ -68,32 +77,84 @@ export function createSessionRouteApi(bag) {
   let routeWrite = null;
   let routeSequence = 0;
 
+  // A preset selector previews as the preset's model, never as its id.
+  const previewedRequest = (routeOpts) => {
+    if (routeOpts.provider || !routeOpts.model) return routeOpts;
+    const target = selectedModel(runtime, routeOpts, '', '');
+    return target.provider ? { ...routeOpts, ...target } : routeOpts;
+  };
+
+  // Auto-compact on model change (default on): compact on the CURRENT model,
+  // whose cache and window still hold the history, before the switch. A model
+  // stopped on its quota cannot run it; the next turn's auto-compaction on the
+  // new model fits the history instead. A failure never blocks the switch.
+  const compactBeforeModelSwitch = async () => {
+    if (runtime.getCompactionSettings?.()?.onModelChange === false) return;
+    if (latestQuotaFailure(getState().items)) return;
+    if (typeof bag.compactBeforeModelSwitch !== 'function') return;
+    set({
+      commandStatus: { active: true, verb: 'Compacting conversation', startedAt: Date.now(), mode: 'compacting' },
+    });
+    flushEmitImmediate();
+    try {
+      await bag.compactBeforeModelSwitch();
+    } catch {
+      /* the switch goes ahead; next-turn auto-compaction fits the window */
+    } finally {
+      set({ commandStatus: null });
+    }
+  };
+
   const setRoute = async (opts) => {
     if (getState().commandBusy && !routeWrite) return false;
+    const routeOpts = opts && typeof opts === 'object' ? opts : {};
+    // Every user model choice on this surface (composer picker, /model,
+    // presets, the TUI picker) switches the conversation itself in place.
+    const switchesModel = switchesSessionModel(runtime, routeOpts);
+    // A running turn keeps the route it started on.
+    if (switchesModel && getState().busy) {
+      throw new Error('The model cannot change while a response is running. Try again when it finishes.');
+    }
     // Any route change supersedes waiting for the old route's quota reset.
     bag.supersedeQuotaResume?.(getState().sessionId);
     const token = ++routeSequence;
     const previousWrite = routeWrite;
-    const routeOpts = opts && typeof opts === 'object' ? opts : {};
-    const preview = optimisticRoutePatch(routeOpts, getState());
+    const preview = optimisticRoutePatch(previewedRequest(routeOpts), getState());
     // Preview immediately, serialize persistence without dropping a later
     // click. Earlier completions cannot replace the newest visible choice.
-    set({ commandBusy: true, ...(preview || {}) });
+    // A model switch previews once its pre-compaction (which republishes the
+    // current route) is done.
+    set({ commandBusy: true, ...(switchesModel ? {} : preview || {}) });
     flushEmitImmediate();
     const write = (async () => {
       if (previousWrite) await previousWrite.catch(() => {});
       const previousRoute = routeState();
       try {
-        // Explicit addressing initializes an empty session in place; the
-        // runtime continues to own established-session route policy.
+        // Explicit addressing applies the route to this session: an empty
+        // one is initialized in place. Either way an established
+        // conversation follows the user's choice in place.
         const applyToCurrentSession = routeOpts.applyToCurrentSession === true;
         const keepMainModel = routeOpts.keepMainModel === true;
         const { applyToCurrentSession: _drop, keepMainModel: _keep, ...nextRoute } = routeOpts;
-        const resolvedRoute = await runtime.setRoute(nextRoute, { applyToCurrentSession, keepMainModel });
+        if (switchesModel) {
+          // The destination must be accepted before the history is compacted.
+          await runtime.setRoute(nextRoute, { validateOnly: true });
+          await compactBeforeModelSwitch();
+          if (token === routeSequence && preview) {
+            set(preview);
+            flushEmitImmediate();
+          }
+        }
+        const resolvedRoute = await runtime.setRoute(nextRoute, {
+          applyToCurrentSession,
+          keepMainModel,
+          switchEstablished: true,
+        });
         if (token === routeSequence) {
-          if (applyToCurrentSession) syncContextStats({ allowEstimated: true });
+          if (applyToCurrentSession || resolvedRoute?.modelSwitch) syncContextStats({ allowEstimated: true });
           publishRoute();
         }
+        publishModelSwitch(bag, resolvedRoute?.modelSwitch);
         return resolvedRoute;
       } catch (error) {
         if (token === routeSequence && preview) {
@@ -116,6 +177,9 @@ export function createSessionRouteApi(bag) {
       if (routeWrite === write) routeWrite = null;
     }
   };
+  // The settings surface's setModel (/model, presets) is the same user
+  // model choice and runs through this one path.
+  bag.setSessionRoute = setRoute;
 
   const setWebSearchRoute = async (opts) => {
     if (getState().commandBusy) return null;

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

@@ -28,20 +28,11 @@ export function createSessionSettingsApi(bag) {
   const lockedRuntimeCall = (call) => withCommandLock(async (...args) => await call(...args));
 
   return {
-    // Model changes apply to the NEXT session only (default setRoute behavior)
-    // — never rewrite the live session's provider/model, which would force a
-    // full prompt-cache rewrite mid-conversation. RPC replies read the
-    // published snapshot, not the mutable draft: commit before the caller can
-    // acknowledge an older route.
-    setModel: withCommandLock(
-      async (m) => {
-        bag.supersedeQuotaResume?.(getState().sessionId);
-        await runtime.setRoute({ model: m });
-        publishRoute();
-        return true;
-      },
-      { busyResult: false, onRelease: flushEmitImmediate }
-    ),
+    // A model selector (/model, a preset) is the user's model choice like any
+    // picker selection: the route surface switches an established
+    // conversation in place (pre-compaction, busy refusal, divider). False
+    // while another command holds the lock.
+    setModel: async (m) => (await bag.setSessionRoute({ model: m })) !== false,
     setEffort: withCommandLock(
       async (value) => {
         await runtime.setEffort(value);
@@ -115,6 +106,12 @@ export function createSessionSettingsApi(bag) {
       deferStatsRefresh();
       return next;
     }),
+    getSessionTitleSettings: () => {
+      return runtime.getSessionTitleSettings?.() || { aiSessionTitles: true };
+    },
+    setAiSessionTitles: withCommandLock(async (enabled) => {
+      return await runtime.setAiSessionTitles?.(enabled);
+    }),
     getToolModuleSettings: () => {
       return (
         runtime.getToolModuleSettings?.() || {

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

@@ -33,6 +33,7 @@ export function createSessionApi(bag) {
       autoClear: await read(api.getAutoClear),
       compaction: await read(api.getCompactionSettings),
       recap: await read(api.getRecapSettings),
+      sessionTitles: await read(api.getSessionTitleSettings),
       toolModules: await read(api.getToolModuleSettings),
       channels: await read(api.getChannelSettings, { includeStatus: false }),
       systemShell: await read(api.getSystemShell),

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

@@ -248,6 +248,12 @@ export function createDrainLoop(
       while (pending.length > 0) {
         if (flags.drainEpoch !== drainEpoch) return;
         if (admission() !== 'open') return;
+        // Admission is rechecked before every batch: a command that took the
+        // lock while the previous turn settled (an in-place model switch and
+        // its pre-compaction, a reset) runs before the next turn starts. The
+        // finally below re-enters drain(), which waits on the same gate, and
+        // the commandBusy release re-kicks the queue.
+        if (flags.autoClearRunning || getState().commandBusy) return;
         // Drain one priority/mode bucket at a time (unified command queue):
         // prompt steering stays editable and task notifications stay
         // non-editable but model-visible.
@@ -267,7 +273,7 @@ export function createDrainLoop(
         // after a long idle is compacted first; the wake runs regardless.
         if (autoClearBeforeWake && batch.every((entry) => COMPLETION_WAKE_MODES.has(entry.mode))) {
           await autoClearBeforeWake();
-          if (flags.drainEpoch !== drainEpoch || admission() !== 'open') {
+          if (flags.drainEpoch !== drainEpoch || admission() !== 'open' || getState().commandBusy) {
             queue.requeueEntriesFront(batch);
             return;
           }

package/src/tui/session/session-flow/failed-turn-rewind.mjs

@@ -5,8 +5,12 @@
 // prompt, so a continuation prompt or a merged batch never removes rows.
 const TURN_CHROME_KINDS = new Set(['user', 'turndone', 'notice']);
 
-/** The items with the trailing failed, output-less turn removed, or null
- *  when nothing qualifies. */
+// An in-place model switch made after the stop (the quota "switch model"
+// path) is not the failed turn's output and outlives its rewind.
+const isModelSwitchDivider = (item) => item?.kind === 'statusdone' && item.status === 'model-switched';
+
+/** The items with the trailing failed, output-less turn removed (a later
+ *  model switch divider kept), or null when nothing qualifies. */
 export function rewoundFailedTurnItems(items, text) {
   const list = Array.isArray(items) ? items : [];
   const resubmitted = String(text || '').trim();
@@ -16,6 +20,8 @@ export function rewoundFailedTurnItems(items, text) {
   const tail = list.slice(start + 1);
   const failed = tail.some((item) => item?.kind === 'turndone' && String(item.status || '').toLowerCase() === 'failed');
   if (!failed) return null;
-  if (tail.some((item) => !TURN_CHROME_KINDS.has(String(item?.kind || '')))) return null;
-  return list.slice(0, start);
+  if (tail.some((item) => !TURN_CHROME_KINDS.has(String(item?.kind || '')) && !isModelSwitchDivider(item))) {
+    return null;
+  }
+  return [...list.slice(0, start), ...tail.filter(isModelSwitchDivider)];
 }

package/src/tui/session/tool-approval.mjs

@@ -12,17 +12,20 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
 
   function normalizeToolApprovalRequest(input = {}, id = nextId()) {
     const now = Date.now();
+    const requestTimeoutMs =
+      Number.isFinite(Number(input?.timeoutMs)) && Number(input.timeoutMs) > 0 ? Number(input.timeoutMs) : timeoutMs;
     return {
       id,
       name: String(input?.name || input?.tool_name || 'tool'),
+      kind: typeof input?.kind === 'string' ? input.kind : '',
       args: input?.args ?? input?.tool_input ?? null,
       cwd: input?.cwd || null,
       sessionId: input?.sessionId || input?.session_id || null,
       toolCallId: input?.toolCallId || input?.tool_use_id || null,
       reason: String(input?.reason || input?.message || 'approval requested by hook').trim(),
       requestedAt: now,
-      timeoutMs,
-      expiresAt: now + timeoutMs,
+      timeoutMs: requestTimeoutMs,
+      expiresAt: now + requestTimeoutMs,
     };
   }
   // Every request expires from ITS OWN requestedAt, queued or active. Arming
@@ -39,10 +42,10 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
   // Settle one entry: drop its timeout, then hand the waiter its answer. The
   // resolve stays guarded — a waiter whose caller already went away must never
   // take the rest of the queue down with it.
-  function settleToolApproval(entry, approved, reason) {
+  function settleToolApproval(entry, approved, reason, answers) {
     if (entry?.timer) clearTimeout(entry.timer);
     try {
-      entry.resolve({ approved, reason });
+      entry.resolve(answers === undefined ? { approved, reason } : { approved, reason, answers });
     } catch {}
   }
   function presentNextToolApproval() {
@@ -56,7 +59,7 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
     armToolApprovalTimeout(entry);
     set({ toolApproval: entry.request });
   }
-  function finishToolApproval(id, approved, reason = '', device = '') {
+  function finishToolApproval(id, approved, reason = '', device = '', answers = undefined) {
     const targetId = String(id || '');
     if (activeToolApproval && activeToolApproval.id === targetId) {
       const entry = activeToolApproval;
@@ -67,14 +70,14 @@ export function createToolApproval({ getState, set, nextId, getDisposed, timeout
         ? { id: targetId, approved: approved === true, device: String(device), at: Date.now() }
         : null;
       set({ toolApproval: null, toolApprovalResult });
-      settleToolApproval(entry, approved === true, String(reason || ''));
+      settleToolApproval(entry, approved === true, String(reason || ''), answers);
       presentNextToolApproval();
       return true;
     }
     const index = toolApprovalQueue.findIndex((entry) => entry.id === targetId);
     if (index >= 0) {
       const [entry] = toolApprovalQueue.splice(index, 1);
-      settleToolApproval(entry, approved === true, String(reason || ''));
+      settleToolApproval(entry, approved === true, String(reason || ''), answers);
       return true;
     }
     return false;