mixdog 1.2.1 → 1.2.2

package/src/standalone/session-service/agent-tree/agent-cancel.mjs

@@ -1,9 +1,29 @@
 // agent-tree/agent-cancel.mjs
 // Cancelling an agent subtree: descendants first, then a durable canonical
 // close of the session itself. Concurrent cancels of one id share a run.
-import { cancelBackgroundTasks } from '../../../runtime/shared/background-tasks.mjs';
+import {
+  cancelBackgroundTask,
+  cancelBackgroundTasks,
+  listBackgroundTasks,
+} from '../../../runtime/shared/background-tasks.mjs';
 
-export function createAgentCancellation({ registry, rehydrateAgentSessions, sessionOwner, entryForSession, log }) {
+// Cancel the running Agent task(s) bound to this session itself (owned by its
+// parent) BEFORE the session closes, so the owner hears `cancelled` with the
+// turn's partial output instead of the closed turn failing the task.
+function cancelOwnAgentTasks(sessionId, reason) {
+  for (const row of listBackgroundTasks({ surface: 'agent' })) {
+    if (row.status === 'running' && row.sessionId === sessionId) cancelBackgroundTask(row.task_id, reason);
+  }
+}
+
+export function createAgentCancellation({
+  registry,
+  rehydrateAgentSessions,
+  sessionOwner,
+  entryForSession,
+  log,
+  rememberCancelTranscript,
+}) {
   const agentCancelRuns = new Map();
 
   /** The runtime entry that can close this descriptor: the live owner, else a
@@ -39,6 +59,7 @@ export function createAgentCancellation({ registry, rehydrateAgentSessions, sess
       });
       const children = registry.childrenOf(id);
       await Promise.all(children.map((childId) => cancelAgentTree(childId, reason)));
+      cancelOwnAgentTasks(id, reason);
       const descriptor = registry.get(id);
       if (!descriptor) return children.length > 0;
       if (descriptor.closed) return true;
@@ -47,6 +68,16 @@ export function createAgentCancellation({ registry, rehydrateAgentSessions, sess
       if (typeof closeCanonical !== 'function') {
         throw new TypeError('session runtime must implement closeCanonicalSession');
       }
+      // The close clears the transcript: capture a running turn's transcript
+      // first so the cancelled turn still hands off its partial output.
+      if (descriptor.status === 'running') {
+        try {
+          const { messages } = await entry.runtime.readModelMessages(0);
+          rememberCancelTranscript(id, messages);
+        } catch (error) {
+          log(`agent cancel transcript read failed session=${id}: ${error?.message || error}`);
+        }
+      }
       const closed = await closeCanonical.call(entry.runtime, reason);
       if (closed !== true) throw new Error(`agent session ${id} could not be durably closed`);
       descriptor.closed = true;

package/src/standalone/session-service/agent-tree/agent-turns.mjs

@@ -12,16 +12,23 @@ export function createAgentTurns({
   retainUnwatched,
   createSession,
   takeWatchdogStop,
+  takeCancelTranscript,
 }) {
   const createAgentChild = createAgentChildFactory({ registry, rehydrateAgentSessions, createSession });
 
-  // The progress watchdog stopped the turn: rethrow its stall error carrying
-  // the assistant text the turn produced, so the owner still gets a partial
-  // result.
-  async function watchdogStopError(runtime, error, messageStart) {
-    const { messages } = await runtime.readModelMessages(messageStart);
-    const partial = partialHandoffTextFromSession({ messages });
-    if (partial) error.partialHandoff = partial;
+  // The turn was stopped (progress watchdog or cancellation): rethrow its error
+  // carrying the assistant text the turn produced, so the owner still gets a
+  // partial result. A cancel that closed the session captured the transcript
+  // before the close cleared it.
+  async function withPartialHandoff(runtime, sessionId, error, messageStart) {
+    try {
+      const captured = takeCancelTranscript(sessionId);
+      const messages = captured
+        ? captured.slice(messageStart)
+        : (await runtime.readModelMessages(messageStart)).messages;
+      const partial = partialHandoffTextFromSession({ messages });
+      if (partial) error.partialHandoff = partial;
+    } catch {}
     return error;
   }
 
@@ -44,6 +51,7 @@ export function createAgentTurns({
     }
     // A stop left over from an earlier turn must not relabel this one.
     takeWatchdogStop(sessionId);
+    takeCancelTranscript(sessionId);
     // Transcript length before this turn: where a watchdog stop's partial
     // output starts.
     const { messageCount: messageStart } = await entry.runtime.readModelMessages(Number.MAX_SAFE_INTEGER);
@@ -64,9 +72,16 @@ export function createAgentTurns({
         throw new Error(String(detail.error || 'agent session turn failed'));
       }
       if (detail?.status === 'cancelled') {
-        const watchdogStop = takeWatchdogStop(sessionId);
-        if (watchdogStop) throw await watchdogStopError(entry.runtime, watchdogStop, messageStart);
-        throw new Error('agent session turn cancelled');
+        const stop = takeWatchdogStop(sessionId) || new Error('agent session turn cancelled');
+        throw await withPartialHandoff(entry.runtime, sessionId, stop, messageStart);
+      }
+      // Only a completed turn has a result; a rejected submission (session
+      // closing/terminal, steering persist failure) or any unknown status is a
+      // failure, never an empty completion.
+      if (detail?.status !== 'done' && detail?.status !== 'completed') {
+        const status = String(detail?.status || 'unknown');
+        const reason = String(detail?.reason || detail?.error || '').trim();
+        throw new Error(`agent turn ${status}${reason ? `: ${reason}` : ''}`);
       }
       const result = detail?.result || { content: '' };
       descriptor.status = 'idle';
@@ -81,6 +96,7 @@ export function createAgentTurns({
       descriptor.stage = descriptor.status;
       throw error;
     } finally {
+      takeCancelTranscript(sessionId);
       descriptor.updatedAt = Date.now();
       retainUnwatched(entry, 'agent child idle');
     }

package/src/standalone/session-service/agent-tree.mjs

@@ -37,6 +37,16 @@ export function createAgentTree({
     watchdogStops.delete(sessionId);
     return error;
   };
+  // Transcripts of running turns captured by a cancel just before it closes
+  // (and clears) the session, so the cancelled turn still reports the output
+  // it produced.
+  const cancelTranscripts = new Map();
+  const rememberCancelTranscript = (sessionId, messages) => cancelTranscripts.set(sessionId, messages);
+  const takeCancelTranscript = (sessionId) => {
+    const messages = cancelTranscripts.get(sessionId) || null;
+    cancelTranscripts.delete(sessionId);
+    return messages;
+  };
   function getSessionProgressSnapshot(sessionId) {
     const runtime = sessionOwner(sessionId)?.runtime;
     if (typeof runtime?.getTurnLiveness !== 'function') return null;
@@ -58,6 +68,7 @@ export function createAgentTree({
     retainUnwatched,
     createSession,
     takeWatchdogStop,
+    takeCancelTranscript,
   });
   const { cancelAgentTree, cancelAgentDescendants } = createAgentCancellation({
     registry,
@@ -65,6 +76,7 @@ export function createAgentTree({
     sessionOwner,
     entryForSession,
     log,
+    rememberCancelTranscript,
   });
 
   /** The descriptor as callers see it: status from the live runtime when one

package/src/standalone/session-service/quota-resume.mjs

@@ -8,6 +8,8 @@
 // again, and the session's own lane runs the retry under the entry's
 // generation. Overdue entries run as soon as the scheduler starts.
 
+import { isAgentOnlySession } from '../../runtime/shared/quota-resume-store.mjs';
+
 /** A still-exhausted reading is re-taken once, this much later. */
 export const QUOTA_RESUME_RETRY_MS = 5 * 60_000;
 /** A busy session is re-checked this much later, without spending an attempt. */
@@ -30,6 +32,12 @@ async function resumeDueEntry(entry, { store, materializeSession, readQuotaUsabl
     return 'unavailable';
   }
   if (!isCurrent(store, entry)) return 'cancelled';
+  // A delegated agent child never owns a resume (the Lead decides retries), so
+  // an entry persisted for one never fires, whatever wrote it.
+  if (isAgentOnlySession({ id: sessionId, ...runtime?.session })) {
+    store.cancelQuotaResumeEntry(sessionId, { generation });
+    return 'agent-session';
+  }
   let usable = false;
   try {
     usable = await readQuotaUsable(entry.provider, entry.model);

package/src/standalone/session-service/retention/busy.mjs

@@ -28,6 +28,12 @@ export function createBusyTracker({ sessions, currentSessionId }) {
     // reaches a terminal state and its completion can be delivered back into
     // this session.
     if (sessionId && hasActiveBackgroundTasks({ callerSessionId: sessionId })) return true;
+    return sessionTurnBusy(entry);
+  }
+
+  // A turn is running (provider stream / tool call / queued input). Background
+  // tasks are deliberately not counted: they run outside the heap-churning turn.
+  function sessionTurnBusy(entry) {
     if (typeof entry?.busy === 'boolean') return entry.busy;
     try {
       return updateEntryBusy(entry, entry.runtime.getState?.() || {});
@@ -46,5 +52,13 @@ export function createBusyTracker({ sessions, currentSessionId }) {
     return count;
   }
 
-  return { stateBusy, updateEntryBusy, sessionBusy, liveBusyCount };
+  function liveTurnBusyCount() {
+    let count = 0;
+    for (const entry of sessions) {
+      if (sessionTurnBusy(entry)) count += 1;
+    }
+    return count;
+  }
+
+  return { stateBusy, updateEntryBusy, sessionBusy, liveBusyCount, liveTurnBusyCount };
 }

package/src/standalone/session-service-api.mjs

@@ -29,6 +29,7 @@ export function createSessionServiceApi({
   methods,
   getSize,
   getBusyCount,
+  getTurnBusyCount,
   getStatus,
   getExternalClientCount,
 }) {
@@ -46,6 +47,10 @@ export function createSessionServiceApi({
     get busyCount() {
       return getBusyCount();
     },
+    /** Sessions with a running turn; background-task-only sessions excluded. */
+    get turnBusyCount() {
+      return getTurnBusyCount();
+    },
     get status() {
       return getStatus();
     },

package/src/standalone/session-service.mjs

@@ -296,6 +296,7 @@ export function createSessionService({
     },
     getSize: () => sessions.size,
     getBusyCount: retention.liveBusyCount,
+    getTurnBusyCount: retention.liveTurnBusyCount,
     getStatus,
     getExternalClientCount: () => desktopServices.externalClientCount,
   });

package/src/tui/app/app-view.jsx

@@ -235,6 +235,7 @@ export function renderAppView(ctx) {
           model={state.model}
           effort={state.effort}
           fast={state.fast}
+          ultra={state.fast === true && state.modelParameters?.serviceTier === 'ultrafast'}
           cwd={state.cwd}
           stats={statuslineStats}
           contextWindow={state.contextWindow}

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

@@ -88,6 +88,8 @@ export function createAppPickers({
   const {
     openMcpServersPicker,
     openMcpPicker,
+    loginMcpServer,
+    logoutMcpServer,
     openProjectSkillsPicker,
     openSkillsPicker,
     openSkillDetailPicker,
@@ -219,6 +221,8 @@ export function createAppPickers({
     enterProject: (...a) => enterProject(...a),
     openProjectPicker: (...a) => openProjectPicker(...a),
     openMcpPicker: (...a) => openMcpPicker(...a),
+    loginMcpServer,
+    logoutMcpServer,
     openSkillsPicker: (...a) => openSkillsPicker(...a),
     openPluginsPicker: (...a) => openPluginsPicker(...a),
     openProviderSetupPicker: (...a) => openProviderSetupPicker(...a),

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

@@ -0,0 +1,107 @@
+// extension-pickers/mcp-login.mjs
+// `/mcp login <name>` and `/mcp logout <name>`. The sign-in URL is always
+// printed (and kept in the live prompt); the runtime may open the browser. The
+// flow is polled while a paste prompt (the shared 'oauth-code' provider prompt)
+// accepts the final redirect address. Pasted text is never echoed.
+const POLL_MS = 1500;
+
+export function createMcpLogin({ store, setProviderPrompt, pollMs = POLL_MS }) {
+  let active = null;
+
+  const stop = (flow) => {
+    flow.finished = true;
+    clearTimeout(flow.timer);
+    if (active === flow) active = null;
+  };
+
+  const closePrompt = (flow) => setProviderPrompt((prompt) => (prompt === flow.prompt ? null : prompt));
+
+  const showPrompt = (flow) => {
+    if (flow.finished) return;
+    const prompt = {
+      kind: 'oauth-code',
+      providerName: `MCP ${flow.name}`,
+      // The shared prompt pushes the one completion notice; no provider picker follows.
+      successReturn: () => {},
+      label: `MCP sign-in · ${flow.name}`,
+      hint: 'If the browser page fails to load, paste its address here.',
+      detail: flow.url,
+      login: {
+        completeCode: async (text) => {
+          const result = await store.completeMcpOAuthLogin(flow.id, text);
+          if (result?.state !== 'complete') throw new Error(result?.error || 'sign-in did not complete');
+          stop(flow);
+        },
+        cancel: () => {
+          if (flow.finished) return;
+          stop(flow);
+          void Promise.resolve(store.cancelMcpOAuthLogin(flow.id)).catch(() => {});
+          store.pushNotice(`MCP sign-in cancelled for ${flow.name}`, 'info');
+        },
+      },
+      failureReturn: () => showPrompt(flow),
+    };
+    flow.prompt = prompt;
+    setProviderPrompt(prompt);
+  };
+
+  const poll = (flow) => {
+    flow.timer = setTimeout(async () => {
+      if (flow.finished) return;
+      let status;
+      try {
+        status = await store.getMcpOAuthLoginStatus(flow.id);
+      } catch (e) {
+        if (flow.finished) return;
+        stop(flow);
+        closePrompt(flow);
+        store.pushNotice(`MCP sign-in failed for ${flow.name}: ${e?.message || e}`, 'error');
+        return;
+      }
+      if (flow.finished) return;
+      if (status?.state === 'pending') {
+        poll(flow);
+        return;
+      }
+      stop(flow);
+      closePrompt(flow);
+      if (status?.state === 'complete') store.pushNotice(`MCP sign-in complete for ${flow.name}`, 'info');
+      else if (status?.state === 'cancelled') store.pushNotice(`MCP sign-in cancelled for ${flow.name}`, 'info');
+      else store.pushNotice(`MCP sign-in failed for ${flow.name}${status?.error ? `: ${status.error}` : ''}`, 'error');
+    }, pollMs);
+  };
+
+  const loginMcpServer = async (name) => {
+    if (active) {
+      const previous = active;
+      stop(previous);
+      closePrompt(previous);
+      void Promise.resolve(store.cancelMcpOAuthLogin(previous.id)).catch(() => {});
+    }
+    try {
+      const started = await store.beginMcpOAuthLogin(name, { openBrowser: true });
+      if (started?.state === 'complete') {
+        store.pushNotice(`MCP sign-in complete for ${name}`, 'info');
+        return;
+      }
+      const flow = { id: started.flowId, name, url: started.url || '', finished: false, timer: null, prompt: null };
+      active = flow;
+      if (flow.url) store.pushNotice(`Sign in to ${name}: ${flow.url}`, 'info');
+      showPrompt(flow);
+      poll(flow);
+    } catch (e) {
+      store.pushNotice(`MCP sign-in failed for ${name}: ${e?.message || e}`, 'error');
+    }
+  };
+
+  const logoutMcpServer = async (name) => {
+    try {
+      await store.signOutMcpServer(name);
+      store.pushNotice(`MCP signed out of ${name}`, 'info');
+    } catch (e) {
+      store.pushNotice(`MCP sign-out failed for ${name}: ${e?.message || e}`, 'error');
+    }
+  };
+
+  return { loginMcpServer, logoutMcpServer };
+}

package/src/tui/app/extension-pickers/mcp-servers-picker.mjs

@@ -8,8 +8,9 @@ const serverDescription = (server, pending, optimistic) => {
   const transport = server.transport || 'unknown';
   if (pending) return `${optimistic.enabled ? 'enabling' : 'disabling'}… · ${transport}`;
   const error = server.error ? ` · ${server.error}` : '';
+  const signIn = server.authRequired ? ` · sign-in required: /mcp login ${server.name}` : '';
   return withScope(
-    `${server.source || 'config'} · ${server.status || 'unknown'} · ${transport} · ${server.toolCount || 0} tools${error}`,
+    `${server.source || 'config'} · ${server.status || 'unknown'} · ${transport} · ${server.toolCount || 0} tools${error}${signIn}`,
     server
   );
 };

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

@@ -7,6 +7,7 @@
  * store state, so they can't be pure. openMcpPicker is exposed for the
  * plugin-detail enable-mcp path (also aliased on the App body).
  */
+import { createMcpLogin } from './extension-pickers/mcp-login.mjs';
 import { createMcpServersPicker } from './extension-pickers/mcp-servers-picker.mjs';
 import { createPluginsPickers } from './extension-pickers/plugins-pickers.mjs';
 import { createSkillsPickers } from './extension-pickers/skills-pickers.mjs';
@@ -43,5 +44,5 @@ export function createExtensionPickers({
     setSettingsPrompt,
     openMcpPicker: mcp.openMcpPicker,
   });
-  return { ...mcp, ...skills, ...plugins };
+  return { ...mcp, ...createMcpLogin({ store, setProviderPrompt }), ...skills, ...plugins };
 }

package/src/tui/app/model-options.mjs

@@ -6,7 +6,7 @@
  * displayModelName formatter.
  */
 import { theme } from '../theme.mjs';
-import { displayModelName } from '../../runtime/shared/model-display.mjs';
+import { displayModelName, effortDisplayLabel } from '../../runtime/shared/model-display.mjs';
 import { isRollingModelAlias } from '../../runtime/shared/model-alias.mjs';
 import { DAYBREAK_PROVIDER, daybreakBlueOn } from '../../runtime/shared/llm/openai-daybreak.mjs';
 
@@ -248,18 +248,7 @@ const PROVIDER_DISPLAY_RANKS = {
 
 export const providerDisplayRank = (provider) => PROVIDER_DISPLAY_RANKS[String(provider || '').toLowerCase()] ?? 900;
 
-const titleCaseOption = (value) =>
-  String(value || '')
-    .split(/([\s_-]+)/)
-    .map((part) => (/^[\s_-]+$/.test(part) ? part : `${part.charAt(0).toUpperCase()}${part.slice(1).toLowerCase()}`))
-    .join('');
-
-export const effortDisplayLabel = (value) => {
-  const text = String(value || '').trim();
-  if (!text) return '';
-  if (text.toLowerCase() === 'xhigh') return 'XHigh';
-  return titleCaseOption(text);
-};
+export { effortDisplayLabel };
 
 export const fastDisplayLabel = (enabled = true) => `Fast ${enabled ? 'On' : 'Off'}`;
 
@@ -330,9 +319,15 @@ export const buildProviderModelItems = (models, provider, currentRoute = null) =
   }));
 };
 
-// Model · Effort · Fast, dropping the empty parts.
+// The configured speed tier: Ultrafast when the fast route asks for it.
+const routeSpeedLabel = (route) => {
+  if (!route?.fast) return '';
+  return route.modelParameters?.serviceTier === 'ultrafast' ? 'Ultrafast' : 'Fast';
+};
+
+// Model · Effort · Fast/Ultrafast, dropping the empty parts.
 const routeModelDetails = (route) =>
-  [routeModelDisplayName(route), route.effort ? effortDisplayLabel(route.effort) : '', route.fast ? 'Fast' : '']
+  [routeModelDisplayName(route), route.effort ? effortDisplayLabel(route.effort) : '', routeSpeedLabel(route)]
     .filter(Boolean)
     .join(' · ');
 
@@ -348,7 +343,7 @@ export const agentModelProfile = (route) => (route?.model ? routeModelDetails(ro
 export const agentModelParts = (route) => [
   { text: route?.model ? routeModelDisplayName(route) : '', width: 17 },
   { text: route?.effort ? effortDisplayLabel(route.effort) : '', width: 6 },
-  { text: route?.fast ? 'Fast' : '', width: 4 },
+  { text: routeSpeedLabel(route), width: 9 },
 ];
 
 export const routeFromModel = (model, effort = null) => ({

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

@@ -50,8 +50,13 @@ export const SLASH_COMMANDS = [
   { name: 'theme', usage: '/theme', params: '[id]', description: 'Change the TUI color theme' },
   { name: 'agents', usage: '/agents', params: '[refresh]', description: 'Show available workflow agents' },
   { name: 'effort', usage: '/effort', params: '[level]', description: 'Set reasoning effort for the current model' },
-  { name: 'fast', usage: '/fast', params: '[on|off|ultra]', description: 'Set Fast or Ultrafast mode for the current model' },
-  { name: 'mcp', usage: '/mcp', description: 'Manage MCP servers and tools' },
+  {
+    name: 'fast',
+    usage: '/fast',
+    params: '[on|off|ultra]',
+    description: 'Set Fast or Ultrafast mode for the current model',
+  },
+  { name: 'mcp', usage: '/mcp', params: '[login|logout <name>]', description: 'Manage MCP servers and tools' },
   { name: 'skills', usage: '/skills', description: 'Choose a skill for the next request' },
   { name: 'memory', usage: '/memory', params: '[status|core ...]', description: 'List and edit core memories' },
   { name: 'plugins', usage: '/plugins', description: 'Manage local plugin integrations' },

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

@@ -14,6 +14,8 @@ const desktopOnlyNotice = (ctx) => {
   return true;
 };
 
+const openMcpPanel = panelCommand('mcp', 'MCP Servers', (deps) => deps.openMcpPicker());
+
 const openSettings = panelCommand('settings', 'Settings', (deps) => deps.openSettingsPicker());
 
 export const panelCommands = {
@@ -26,7 +28,20 @@ export const panelCommands = {
     ctx.openSlashPanel('project', 'Projects', () => ctx.deps.openProjectPicker());
     return true;
   },
-  mcp: panelCommand('mcp', 'MCP Servers', (deps) => deps.openMcpPicker()),
+  mcp(ctx, arg) {
+    const [sub, ...rest] = arg.trim().split(/\s+/);
+    const action = sub?.toLowerCase();
+    if (action === 'login' || action === 'logout') {
+      const name = rest.join(' ');
+      if (!name) {
+        ctx.store.pushNotice(`usage: /mcp ${action} <name>`, 'warn');
+        return true;
+      }
+      void (action === 'login' ? ctx.deps.loginMcpServer(name) : ctx.deps.logoutMcpServer(name));
+      return true;
+    }
+    return openMcpPanel(ctx);
+  },
   skills: panelCommand('skills', 'Skills', (deps) => deps.openSkillsPicker()),
   plugins: panelCommand('plugins', 'Plugins', (deps) => deps.openPluginsPicker()),
   providers: panelCommand('providers', 'Providers', (deps) => deps.openProviderSetupPicker()),

package/src/tui/components/StatusLine.jsx

@@ -19,6 +19,7 @@ function StatusLineView({
   model,
   effort,
   fast,
+  ultra = false,
   cwd,
   stats,
   contextWindow,
@@ -42,6 +43,7 @@ function StatusLineView({
     model,
     effort,
     fast,
+    ultra,
     cwd,
     stats,
     contextWindow,

package/src/tui/components/status-line/local-line.mjs

@@ -4,7 +4,7 @@
  */
 import { rgbSgr } from '../../../runtime/shared/statusline/ansi.mjs';
 import { measuredContextUsage, contextMeasurementLabel } from '../../../runtime/shared/context-measurement.mjs';
-import { displayModelName, shortenModelName } from '../../../runtime/shared/model-display.mjs';
+import { displayModelName, effortDisplayLabel, shortenModelName } from '../../../runtime/shared/model-display.mjs';
 import { theme } from '../../theme.mjs';
 import { normalizeStatuslineAnsi } from '../../statusline-ansi-bridge.mjs';
 // Cache-only synchronous read (never touches fs on the render path), so the
@@ -160,6 +160,7 @@ export function localBootStatusLine(args = {}) {
     model = '',
     effort = '',
     fast = false,
+    ultra = false,
     stats = null,
     contextWindow = 0,
     displayContextWindow = 0,
@@ -168,7 +169,9 @@ export function localBootStatusLine(args = {}) {
   const raw = String(model || '').trim();
   const { STATUS, SUBTLE } = statusColors();
   const display = shortenModelName(displayModelName(raw, provider, ''), terminalColumns());
-  const flags = [effort ? String(effort).toUpperCase() : '', fast === true ? 'FAST' : ''].filter(Boolean);
+  let speedLabel = '';
+  if (fast === true) speedLabel = ultra === true ? 'Ultrafast' : 'Fast';
+  const flags = [effort ? effortDisplayLabel(effort) : '', speedLabel].filter(Boolean);
   const modelBits = [display, ...flags].join(` ${SUBTLE}·${RESET} `);
   const ctxPct = measuredContextUsage({
     stats,

package/src/tui/components/status-line/use-statusline-text.mjs

@@ -29,6 +29,7 @@ export function useStatusLineText({
   model,
   effort,
   fast,
+  ultra,
   cwd,
   stats,
   contextWindow,
@@ -52,6 +53,7 @@ export function useStatusLineText({
           model,
           effort,
           fast,
+          ultra,
           stats,
           contextWindow,
           displayContextWindow,
@@ -83,6 +85,7 @@ export function useStatusLineText({
     model,
     effort,
     fast,
+    ultra,
     cwd,
     stats,
     contextWindow,
@@ -180,7 +183,8 @@ export function useStatusLineText({
       prevImmediate.provider !== args.provider ||
       prevImmediate.model !== args.model ||
       prevImmediate.effort !== args.effort ||
-      prevImmediate.fast !== args.fast;
+      prevImmediate.fast !== args.fast ||
+      prevImmediate.ultra !== args.ultra;
     // A theme switch must re-tone the footer immediately: the stored `line`
     // holds already-normalized ANSI with the OLD palette, so re-running
     // normalizeStatusLine on it is a no-op. Force a fresh local rebuild (new
@@ -218,6 +222,7 @@ export function useStatusLineText({
       model: args.model,
       effort: args.effort,
       fast: args.fast,
+      ultra: args.ultra,
       contextWindow: args.contextWindow,
       displayContextWindow: args.displayContextWindow,
       rawContextWindow: args.rawContextWindow,
@@ -299,6 +304,7 @@ export function useStatusLineText({
     model,
     effort,
     fast,
+    ultra,
     cwd,
     statsSignature,
     contextWindow,