mixdog 1.0.11 → 1.1.0

package/src/standalone/session-service/entries/lifecycle.mjs

@@ -47,6 +47,8 @@ export function createEntryLifecycle({
       effort: params.effort,
       fast: params.fast,
       modelParameters: params.modelParameters,
+      contextPercent: params.contextPercent,
+      selectedContextWindow: params.selectedContextWindow,
       toolMode: params.toolMode || 'full',
       remote: params.remote === true,
       desktopSession: params.desktopSession ?? null,

package/src/standalone/session-service/entries/session-loads.mjs

@@ -61,6 +61,15 @@ export function createSessionLoads({
       await destroy(entry, 'session load mismatch');
       throw new Error(`session ${sessionId} could not be resumed`);
     }
+    // The loaded conversation is this entry's durable address from now on:
+    // an evicted/unloaded/crashed-restored runtime may resume it again but
+    // never mint another id under this entry.
+    try {
+      await entry.runtime.bindSessionAddress?.(loaded);
+    } catch (err) {
+      await destroy(entry, 'session address bind failed');
+      throw err;
+    }
     // Publish/index the resumed identity before sessionLoads releases its
     // single-flight promise. A second pane arriving in the next microtask must
     // find this owner in O(1), not create a duplicate runtime.

package/src/standalone/session-service/projection/revisions.mjs

@@ -34,6 +34,7 @@ export function frameBody(step, prepend = false) {
 
 /** Response body for the CALLER, which announced the revision it holds. */
 export function bodyForClient(step, baseRevision, prepend = false) {
+  if (step.unavailable) return { revision: step.revision, unavailable: true };
   if (!step.changed && baseRevision === step.revision) return { revision: step.revision };
   if (step.patch && baseRevision === step.previousRevision) return frameBody(step, prepend);
   return { revision: step.revision, full: step.snapshot };
@@ -49,7 +50,7 @@ function headGrowthPatch(previous, snapshot) {
   return patch?.itemsPrepend ? patch : null;
 }
 
-export function createRevisionSteps({ revisionEpoch, index, updateEntryBusy }) {
+export function createRevisionSteps({ revisionEpoch, index, updateEntryBusy, log = () => {} }) {
   // One clock owns every snapshot served by this daemon, including stored
   // views and replacement runtimes. Per-entry counters restarted after idle
   // eviction, so clients retaining the old baseline discarded new turns.
@@ -97,12 +98,35 @@ export function createRevisionSteps({ revisionEpoch, index, updateEntryBusy }) {
   function advance(entry) {
     // Deltas are computed against the WINDOWED snapshot, so a tail-only
     // baseline keeps receiving ordinary suffix patches.
-    const snapshot = windowTranscriptSnapshot(entry, snapshotOf(entry));
-    const projectedSessionId = String(snapshot?.sessionId || '');
+    const current = windowTranscriptSnapshot(entry, snapshotOf(entry));
+    const projectedSessionId = String(current?.sessionId || '');
     const addressedSessionId = String(entry.addressedSessionId || '');
     if (addressedSessionId && projectedSessionId && projectedSessionId !== addressedSessionId) {
-      throw new Error(`session ${addressedSessionId} changed its durable address to ${projectedSessionId}`);
+      // The runtime now reports another conversation. Throwing here failed
+      // every read of this entry (view sync, getSnapshot, push watcher), so
+      // keep serving what this address last published and say so once.
+      if (entry.addressMismatchLogged !== projectedSessionId) {
+        entry.addressMismatchLogged = projectedSessionId;
+        log(
+          `session ${addressedSessionId} changed its durable address to ${projectedSessionId}; serving last snapshot`
+        );
+      }
+      // `current` belongs to ANOTHER conversation and is never served for this
+      // address; with no published snapshot left (retention cleared it) the
+      // step says so and callers answer without a body.
+      const stale = entry.publishedSnapshot ?? null;
+      const staleRevision = entry.revision || 0;
+      return {
+        changed: false,
+        ...(stale ? {} : { unavailable: true }),
+        snapshot: stale,
+        revision: staleRevision,
+        previousRevision: staleRevision,
+        patch: null,
+        prependPatch: null,
+      };
     }
+    const snapshot = current;
     if (!addressedSessionId && projectedSessionId) {
       entry.addressedSessionId = projectedSessionId;
     }

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

@@ -33,6 +33,7 @@ export function createSessionProjection({
     revisionEpoch,
     index,
     updateEntryBusy,
+    log,
   });
   const frames = createFramePublisher({
     index,

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

@@ -0,0 +1,140 @@
+// session-service/quota-resume.mjs
+// The daemon's clock for quota auto-resume. Waiting lives in the durable
+// store (runtime/shared/quota-resume-store.mjs), never in a session runtime,
+// so an evicted or not-yet-loaded session waits exactly like a live one. One
+// timer is armed for the earliest due entry; when it fires, the addressed
+// session is materialized under daemon ownership (the Goal-recovery pattern),
+// a fresh usage reading decides whether its provider can serve the model
+// again, and the session's own lane runs the retry under the entry's
+// generation. Overdue entries run as soon as the scheduler starts.
+
+/** 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. */
+export const QUOTA_RESUME_BUSY_RECHECK_MS = 30_000;
+const MAX_TIMER_MS = 2 ** 31 - 1;
+
+const isCurrent = (store, entry) => store.quotaResumeEntry(entry.sessionId)?.generation === entry.generation;
+
+/** One due entry: load its session, take the fresh reading, then fire,
+ *  re-check later, or clear it. Returns the outcome for the log. */
+async function resumeDueEntry(entry, { store, materializeSession, readQuotaUsable, log, isClosed, now }) {
+  const { sessionId, generation } = entry;
+  let runtime;
+  try {
+    runtime = await materializeSession(sessionId);
+  } catch (error) {
+    if (isClosed()) return 'closed';
+    log(`quota resume could not load session=${sessionId}: ${error?.message || error}`);
+    store.cancelQuotaResumeEntry(sessionId, { generation });
+    return 'unavailable';
+  }
+  if (!isCurrent(store, entry)) return 'cancelled';
+  let usable = false;
+  try {
+    usable = await readQuotaUsable(entry.provider, entry.model);
+  } catch (error) {
+    log(`quota resume usage reading failed provider=${entry.provider}: ${error?.message || error}`);
+  }
+  if (!isCurrent(store, entry)) return 'cancelled';
+  if (!usable) {
+    // One more reading five minutes on; after that the session falls back
+    // to the user's own choice.
+    if (entry.attempts < 1) {
+      store.deferQuotaResumeEntry(sessionId, generation, {
+        resetAt: now() + QUOTA_RESUME_RETRY_MS,
+        attempts: entry.attempts + 1,
+      });
+      return 'exhausted-retry';
+    }
+    store.cancelQuotaResumeEntry(sessionId, { generation });
+    return 'exhausted';
+  }
+  const outcome =
+    typeof runtime?.fireQuotaResume === 'function' ? runtime.fireQuotaResume({ generation }) : 'unsupported';
+  if (outcome === 'busy') {
+    store.deferQuotaResumeEntry(sessionId, generation, {
+      resetAt: now() + QUOTA_RESUME_BUSY_RECHECK_MS,
+      attempts: entry.attempts,
+    });
+  } else if (isCurrent(store, entry)) {
+    // Every other outcome settles the entry; one the session could not
+    // address (it now holds another session id) must not stay due forever.
+    store.cancelQuotaResumeEntry(sessionId, { generation });
+  }
+  return outcome;
+}
+
+export function createQuotaResumeScheduler({
+  store,
+  materializeSession,
+  readQuotaUsable,
+  log = () => {},
+  isClosed = () => false,
+  now = () => Date.now(),
+  setTimer = (task, ms) => setTimeout(task, ms),
+  clearTimer = (timer) => clearTimeout(timer),
+}) {
+  let started = false;
+  let timer = null;
+  let running = null;
+  let unsubscribe = null;
+  const deps = { store, materializeSession, readQuotaUsable, log, isClosed, now };
+
+  function arm() {
+    if (timer) clearTimer(timer);
+    timer = null;
+    if (!started || isClosed() || running) return;
+    const entries = store.listQuotaResumeEntries();
+    if (entries.length === 0) return;
+    const due = Math.min(...entries.map((entry) => entry.resetAt));
+    timer = setTimer(
+      () => {
+        timer = null;
+        void tick();
+      },
+      Math.min(MAX_TIMER_MS, Math.max(0, due - now()))
+    );
+    timer?.unref?.();
+  }
+
+  function tick() {
+    if (running) return running;
+    running = (async () => {
+      for (const entry of store.listQuotaResumeEntries()) {
+        if (isClosed()) return;
+        if (entry.resetAt > now() || !isCurrent(store, entry)) continue;
+        try {
+          const outcome = await resumeDueEntry(entry, deps);
+          log(`quota resume session=${entry.sessionId} outcome=${outcome}`);
+        } catch (error) {
+          log(`quota resume failed session=${entry.sessionId}: ${error?.message || error}`);
+          store.cancelQuotaResumeEntry(entry.sessionId, { generation: entry.generation });
+        }
+      }
+    })().finally(() => {
+      running = null;
+      arm();
+    });
+    return running;
+  }
+
+  return {
+    /** Start the clock; entries already due run right away. */
+    start() {
+      if (started || isClosed()) return;
+      started = true;
+      unsubscribe = store.subscribeQuotaResume(() => arm());
+      arm();
+    },
+    /** Run every due entry now (the timer's own callback). */
+    tick,
+    stop() {
+      started = false;
+      unsubscribe?.();
+      unsubscribe = null;
+      if (timer) clearTimer(timer);
+      timer = null;
+    },
+  };
+}

package/src/standalone/session-service/session-calls/session-action.mjs

@@ -22,7 +22,7 @@ function requireSessionAction(action, allowed) {
 }
 
 export function createSessionActionCalls(ctx) {
-  const { isClosed, log, listSessions, getRemoteSessionState, loadProjectStore, advanceForCaller, readStoredReview } =
+  const { isClosed, log, listSessions, getRemoteSessionState, loadProjectStore, advanceForCaller, readStoredReview, responseSessionId } =
     ctx;
   const { bodyForClient } = ctx.projection;
   const { retainUnwatched } = ctx.retention;
@@ -83,7 +83,7 @@ export function createSessionActionCalls(ctx) {
     retainUnwatched(entry);
     return {
       value: sanitizeForWire(value) ?? null,
-      sessionId: String(entry.runtime.getState?.()?.sessionId || id),
+      sessionId: responseSessionId(entry, id),
       ...bodyForClient(step, Number.isInteger(baseRevision) ? baseRevision : null),
     };
   }

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

@@ -23,10 +23,18 @@ import { createSessionViewCalls } from './session-calls/session-views.mjs';
 export function createSessionCalls(deps) {
   const { advance, currentSessionId, publishStep, bodyForClient } = deps.projection;
 
+  /** The id a response reports: the entry's immutable addressed id (what the
+   *  served snapshot describes), never a runtime id that drifted away from it.
+   *  Before the first advance there is no address yet, so the runtime id (a
+   *  fresh create/resume) is the identity. */
+  function responseSessionId(entry, fallback = '') {
+    return String(entry.addressedSessionId || currentSessionId(entry) || fallback);
+  }
+
   /** `prepend`: the caller announced transcriptPrepend (see frameBody). */
   function sessionResult(entry, step, baseRevision = null, extra = {}, { prepend = false } = {}) {
     return {
-      sessionId: currentSessionId(entry),
+      sessionId: responseSessionId(entry),
       reservedOnly: entry.reservedOnly === true,
       ...extra,
       ...bodyForClient(step, Number.isInteger(baseRevision) ? baseRevision : null, prepend),
@@ -46,7 +54,7 @@ export function createSessionCalls(deps) {
     return step;
   }
 
-  const ctx = { ...deps, sessionResult, advanceForCaller };
+  const ctx = { ...deps, sessionResult, responseSessionId, advanceForCaller };
   const actions = createSessionActionCalls(ctx);
   const views = createSessionViewCalls({ ...ctx, runSessionAction: actions.runSessionAction });
   const turns = createSessionTurnCalls(ctx);

package/src/standalone/session-service/stored-reader.mjs

@@ -10,9 +10,27 @@ export function createStoredSessionReader({
   statStoredSession = null,
   forgetStoredSession = null,
   releaseStoredSession = null,
+  readQuotaResume = null,
   sessionOwner,
   log,
 }) {
+  /** The cold session's queued quota resume (snapshot shape) or null. */
+  const quotaResumeOf = (sessionId) => {
+    if (typeof readQuotaResume !== 'function') return null;
+    try {
+      return readQuotaResume(sessionId) ?? null;
+    } catch (err) {
+      log(`stored quota resume projection failed session=${sessionId}: ${err?.message || err}`);
+      return null;
+    }
+  };
+  // The resume is projected beside the transcript, so its identity is part
+  // of the stamp a cold view is served by: a scheduled, deferred or cleared
+  // resume refreshes the view even while the transcript files are unchanged.
+  const quotaResumeStamp = (sessionId) => {
+    const resume = quotaResumeOf(sessionId);
+    return resume ? `${resume.turnKey}:${resume.resetAt}:${resume.attempts}` : '';
+  };
   // `${sessionId}|${window}` -> { projectionStamp, fileStamp }: the settled
   // file identity each served projection was built from. The 1s cold-view
   // refresh asks again with the stamp it holds; while the files still carry
@@ -78,11 +96,15 @@ export function createStoredSessionReader({
 
   async function fileStampOf(sessionId) {
     if (typeof statStoredSession !== 'function') return null;
+    let stamp;
     try {
-      return (await statStoredSession(sessionId)) || null;
+      stamp = (await statStoredSession(sessionId)) || null;
     } catch {
       return null;
     }
+    if (stamp === null) return null;
+    const resume = quotaResumeStamp(sessionId);
+    return resume ? `${stamp}|quota-resume:${resume}` : stamp;
   }
 
   /** Whether the projection a caller holds (`projectionStamp`, read through
@@ -145,6 +167,9 @@ export function createStoredSessionReader({
       ...wire,
       sessionId,
       ...(typeof readStoredGoal === 'function' ? { goal: sanitizeForWire(goal, 1) ?? null } : {}),
+      ...(typeof readQuotaResume === 'function'
+        ? { quotaResume: sanitizeForWire(quotaResumeOf(sessionId)) ?? null }
+        : {}),
       queued: Array.isArray(snapshot.queued) ? wire.queued : [],
     };
   }

package/src/standalone/session-service.mjs

@@ -22,6 +22,7 @@ import { createSessionRetention } from './session-service/retention.mjs';
 import { createViewerRegistry } from './session-service/viewers.mjs';
 import { createSessionEntries } from './session-service/entries.mjs';
 import { createSessionCalls } from './session-service/session-calls.mjs';
+import { createQuotaResumeScheduler } from './session-service/quota-resume.mjs';
 
 const EXTERNAL_SESSION_ACTIONS = new Set([
   ...SESSION_READ_ACTION_SET,
@@ -56,6 +57,10 @@ export function createSessionService({
   onDesktopReady = () => {},
   idleEvictMs = null,
   evictSweepMs = null,
+  // Quota auto-resume: the durable queue module and the fresh usage reading
+  // (provider, model) => Promise<boolean>. Without a store nothing is scheduled.
+  quotaResumeStore = null,
+  readQuotaUsable = null,
 } = {}) {
   const createRuntime = createSessionRuntime;
   if (typeof createRuntime !== 'function') throw new Error('createSessionRuntime is required');
@@ -165,6 +170,9 @@ export function createSessionService({
     statStoredSession,
     forgetStoredSession,
     releaseStoredSession,
+    readQuotaResume: quotaResumeStore
+      ? (sessionId) => quotaResumeStore.publicQuotaResume(quotaResumeStore.quotaResumeEntry(sessionId))
+      : null,
     sessionOwner: projection.sessionOwner,
     log,
   });
@@ -197,10 +205,21 @@ export function createSessionService({
     retainUnwatched: retention.retainUnwatched,
     createSession: calls.createSession,
   });
+  const quotaUsableReader = typeof readQuotaUsable === 'function' ? readQuotaUsable : async () => false;
+  const quotaResume = quotaResumeStore
+    ? createQuotaResumeScheduler({
+        store: quotaResumeStore,
+        materializeSession: calls.materializeSession,
+        readQuotaUsable: quotaUsableReader,
+        log,
+        isClosed,
+      })
+    : null;
 
   function stop(reason = 'service stop') {
     if (stopPromise) return stopPromise;
     closed = true;
+    quotaResume?.stop();
     stopPromise = Promise.resolve().then(async () => {
       try {
         unsubscribeExternalSessionStates();
@@ -264,6 +283,8 @@ export function createSessionService({
     methods: {
       ...calls,
       stop,
+      startQuotaResume: () => quotaResume?.start(),
+      runDueQuotaResumes: () => quotaResume?.tick() ?? Promise.resolve(),
       releaseClient: viewers.releaseClient,
       agentSurface: agentTree.agentSurface,
       agentManager: agentTree.agentManager,

package/src/standalone/session-transport/routes.mjs

@@ -114,6 +114,7 @@ export function createTransportRoutes({
     const requestedProtocol = Number(body.protocol);
     const requestedRevision = Math.max(0, Number(body.revision) || 0);
     const requestedVersion = String(body.version || '0.0.0');
+    const force = body.force === true;
     const revisionOrder = requestedRevision - SESSION_REVISION;
     const versionOrder = compareRuntimeVersions(requestedVersion, runtimeVersion());
     const newerBuild =
@@ -140,6 +141,7 @@ export function createTransportRoutes({
           protocol: SESSION_PROTOCOL,
           revision: requestedRevision,
           version: requestedVersion,
+          force,
         });
       } catch {}
     });

package/src/tui/app/doctor.mjs

@@ -115,6 +115,7 @@ function reportNode({ version, engines }, row) {
 }
 
 function providerUnusableReason(entry) {
+  if (entry.configError) return `has an invalid configuration (${entry.configError})`;
   if (entry.reauthRequired) return 'requires sign-in again';
   if (entry.enabled === false) return 'is disabled';
   if (entry.type === 'local' && !entry.detected) return 'has no installed runtime/model';
@@ -240,9 +241,7 @@ function reportRegistry(label) {
     const broken = active.filter(
       (entry) => entry.broken || entry.error || entry.invalid || entry.dependencyIssues?.length
     );
-    const missing = Array.isArray(status.missing)
-      ? status.missing.filter((entry) => entry.enabled !== false)
-      : [];
+    const missing = Array.isArray(status.missing) ? status.missing.filter((entry) => entry.enabled !== false) : [];
     let detail = `${active.length}/${entries.length} active${scopeDetail}`;
     const issues = [...broken, ...(label === 'plugins' ? missing : [])];
     if (!issues.length) {
@@ -340,7 +339,8 @@ async function readDataFolder(dataDir) {
 
 function reportDataFolder({ dataDir, writable, missing }, row) {
   if (writable) row('ok', `writable · ${dataDir}`);
-  else if (missing) row('fail', `not found · ${dataDir}`, { hint: 'create the folder or point MIXDOG_DATA_DIR at an existing one' });
+  else if (missing)
+    row('fail', `not found · ${dataDir}`, { hint: 'create the folder or point MIXDOG_DATA_DIR at an existing one' });
   else row('fail', `not writable · ${dataDir}`, { hint: 'check the folder permissions' });
 }
 
@@ -398,15 +398,11 @@ export async function runDoctorChecks(runtime = {}, getState = () => ({}), optio
     [
       'voice',
       'voice',
-      async () => (runtime.getVoiceStatus || (await import('../lib/voice-setup.mjs')).getVoiceStatus)(),
+      async () =>
+        (runtime.getVoiceStatus || (await import('../../runtime/channels/lib/voice-setup.mjs')).getVoiceStatus)(),
       reportVoice,
     ],
-    [
-      'automation',
-      'automation',
-      () => runtime.getChannelSettings?.({ includeStatus: true }),
-      reportChannels(runtime),
-    ],
+    ['automation', 'automation', () => runtime.getChannelSettings?.({ includeStatus: true }), reportChannels(runtime)],
     ['skills', 'skills', () => runtime.skillsStatus?.(), reportRegistry('skills')],
     ['plugins', 'plugins', () => runtime.pluginsStatus?.(), reportRegistry('plugins')],
     ['hooks', 'hooks', () => runtime.hooksStatus?.(), reportHooks],

package/src/tui/app/maintenance-pickers/auto-clear-picker.mjs

@@ -110,11 +110,9 @@ export function createAutoClearPicker({
       const enabled = current?.enabled !== false;
       const idleMs = Number(current?.idleMs || HOUR_MS);
       const cacheTtlLabel = !enabled || idleMs >= HOUR_MS ? '1h' : '5m';
-      const sourceLabel = current?.providerCustom
-        ? `${current.provider} override`
-        : current?.custom
-          ? 'global'
-          : `${current?.provider || 'default'} default`;
+      let sourceLabel = `${current?.provider || 'default'} default`;
+      if (current?.providerCustom) sourceLabel = `${current.provider} override`;
+      else if (current?.custom) sourceLabel = 'global';
       const items = [
         {
           value: 'toggle',

package/src/tui/app/model-picker/model-footer.mjs

@@ -53,11 +53,11 @@ export function modelFooter(selection, model = null) {
     fastLine = {
       glyph: fastOn ? '●' : '○',
       color: fastOn ? theme.fastMode : theme.inactive,
-      text: `${fastDisplayLabel(fastOn)} · Tab Toggle`,
+      text: `${selection.isUltrafast?.(model) ? 'Ultrafast' : fastDisplayLabel(fastOn)} · Tab Toggle`,
     };
   }
   const parameterLines = (model?.modelParameterOptions || [])
-    .filter((parameter) => parameter.id !== 'context')
+    .filter((parameter) => parameter.id !== 'context' && parameter.id !== 'serviceTier')
     .map((parameter) => {
       const value = selection.modelParametersFor(model)[parameter.id] || '';
       return {

package/src/tui/app/model-picker/route-selection/fast-parameters.mjs

@@ -57,9 +57,28 @@ export function createFastParameterSelection({ state, currentRoute, isCurrentRou
     return fast;
   };
   /** Flips Fast; false when the model cannot run Fast at the selected effort. */
+  const ultrafastOffered = (model) =>
+    (model?.modelParameterOptions || []).some(
+      (parameter) => parameter.id === 'serviceTier' && parameter.options?.some((o) => o.value === 'ultrafast')
+    );
+  const isUltrafast = (model) =>
+    ultrafastOffered(model) && getSelectedFast(model) && modelParametersFor(model).serviceTier === 'ultrafast';
+  const setSpeed = (model, fast, tier) => {
+    selectedFast.set(modelKey(model), fast);
+    selectedModelParameters.set(modelKey(model), { ...modelParametersFor(model), serviceTier: tier });
+  };
+  /** Cycles Standard → Fast → Ultrafast → Standard when the model offers
+   *  Ultrafast, else flips Fast; false when the model cannot run Fast at the
+   *  selected effort. */
   const toggleFast = (model) => {
     if (!fastAvailableFor(model)) return false;
-    selectedFast.set(modelKey(model), !getSelectedFast(model));
+    if (!ultrafastOffered(model)) {
+      selectedFast.set(modelKey(model), !getSelectedFast(model));
+      return true;
+    }
+    if (!getSelectedFast(model)) setSpeed(model, true, 'priority');
+    else if (!isUltrafast(model)) setSpeed(model, true, 'ultrafast');
+    else setSpeed(model, false, 'priority');
     return true;
   };
 
@@ -80,5 +99,5 @@ export function createFastParameterSelection({ state, currentRoute, isCurrentRou
     return true;
   };
 
-  return { modelParametersFor, fastAvailableFor, getSelectedFast, toggleFast, cycleThinking };
+  return { modelParametersFor, fastAvailableFor, getSelectedFast, isUltrafast, toggleFast, cycleThinking };
 }

package/src/tui/app/model-picker/route-selection.mjs

@@ -26,6 +26,10 @@ export function createRouteSelection({ providerModels, state, currentRoute }) {
     const coercedEffort = effort.coerceEffort(selected);
     const fastCapable = fast.fastAvailableFor(selected, coercedEffort);
     const contextSelection = context.contextSelectionFor(selected);
+    const { serviceTier, ...otherParameters } = fast.modelParametersFor(selected);
+    const modelParameters = serviceTier && fastCapable && fast.getSelectedFast(selected)
+      ? { ...otherParameters, serviceTier }
+      : otherParameters;
     return {
       effort: coercedEffort,
       routeInput: {
@@ -35,7 +39,7 @@ export function createRouteSelection({ providerModels, state, currentRoute }) {
         ...(contextSelection ? { contextPercent: contextSelection.percent } : {}),
         ...(selected.fastCapable ? { fast: fastCapable && fast.getSelectedFast(selected) } : {}),
         ...((selected.modelParameterOptions || []).length
-          ? { modelParameters: fast.modelParametersFor(selected) }
+          ? { modelParameters }
           : {}),
       },
     };
@@ -51,6 +55,7 @@ export function createRouteSelection({ providerModels, state, currentRoute }) {
     stepContext: context.stepContext,
     fastAvailableFor: fast.fastAvailableFor,
     getSelectedFast: fast.getSelectedFast,
+    isUltrafast: fast.isUltrafast,
     toggleFast: fast.toggleFast,
     cycleEffort: effort.cycleEffort,
     cycleThinking: fast.cycleThinking,

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

@@ -3,7 +3,7 @@
 // concern — routing/model first, then session behavior, integrations, voice,
 // system — and must stay in sync with desktop SETTINGS_ITEMS (tui-parity
 // test, minus system-shell).
-import { isVoiceEnabled } from '../../lib/voice-setup.mjs';
+import { isVoiceEnabled } from '../../../runtime/channels/lib/voice-setup.mjs';
 
 const boolLabel = (enabled) => (enabled ? 'On' : 'Off');
 
@@ -66,11 +66,9 @@ export function buildSettingsItems({
   const { workflow, mcp, plugins, skills } = view;
   const outputStyleLabel =
     outputStyle?.current?.label || outputStyle?.current?.id || outputStyle?.configured || 'Default';
-  const autoClearSource = autoClear.providerCustom
-    ? ` (${autoClear.provider} override)`
-    : autoClear.custom
-      ? ' (global)'
-      : ` (${autoClear.provider || 'default'} default)`;
+  let autoClearSource = ` (${autoClear.provider || 'default'} default)`;
+  if (autoClear.providerCustom) autoClearSource = ` (${autoClear.provider} override)`;
+  else if (autoClear.custom) autoClearSource = ' (global)';
   return [
     {
       value: 'model',

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

@@ -2,7 +2,7 @@
 // The boolean rows of Settings: each write goes through the store, reports the
 // outcome as a notice, and refreshes Settings through the deferred refresh
 // bound to the keypress that started it.
-import { toggleVoice, isVoiceInstallBusy } from '../../../lib/voice-setup.mjs';
+import { toggleVoice, isVoiceInstallBusy } from '../../../../runtime/channels/lib/voice-setup.mjs';
 
 export function createStoreToggles({ store, view, formatDuration, deferredSettingsRefresh }) {
   const applyAutoClear = (patch = {}) => {

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

@@ -50,7 +50,7 @@ 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]', description: 'Toggle Fast mode 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: 'skills', usage: '/skills', description: 'Choose a skill for the next request' },
   { name: 'memory', usage: '/memory', params: '[status|core ...]', description: 'List and edit core memories' },

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

@@ -166,10 +166,11 @@ export const routeCommands = {
       .toLowerCase();
     let setTo = null;
     if (!value) setTo = undefined;
+    else if (['ultra', 'ultrafast'].includes(value)) setTo = 'ultrafast';
     else if (['1', 'true', 'yes', 'on', 'enable', 'enabled'].includes(value)) setTo = true;
     else if (['0', 'false', 'no', 'off', 'disable', 'disabled'].includes(value)) setTo = false;
     if (setTo === null) {
-      store.pushNotice('usage: /fast [on|off]', 'warn');
+      store.pushNotice('usage: /fast [on|off|ultra]', 'warn');
       return true;
     }
     const action = setTo === undefined ? store.toggleFast?.() : store.setFast?.(setTo);
@@ -179,9 +180,10 @@ export const routeCommands = {
           store.pushNotice('Fast mode switch is already running.', 'warn');
           return;
         }
+        const fastModeLabel = enabled ? 'Fast mode on' : 'Fast mode off';
+        const modeLabel = setTo === 'ultrafast' ? 'Ultrafast' : fastModeLabel;
         store.pushNotice(
-          `Fast mode ${enabled ? 'on' : 'off'} for ${state.provider}/${state.model}` +
-            (state.busy ? ' (applies from the next turn)' : ''),
+          `${modeLabel} for ${state.provider}/${state.model}` + (state.busy ? ' (applies from the next turn)' : ''),
           'info'
         );
       })