mixdog 1.0.12 → 1.1.1

package/src/standalone/session-protocol.mjs

@@ -25,6 +25,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getProfile',
   'getProviderSetup',
   'getProviderAccounts',
+  'getQuotaAutoResume',
   'getQuotaHistory',
   'getRecapSettings',
   'getWebSearchRoute',
@@ -95,6 +96,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'deleteSchedule',
   'saveCustomProvider',
   'removeCustomProvider',
+  'updateCustomProviderModel',
   'testCustomProvider',
   'discoverCustomProviderModels',
   'deleteSession',
@@ -115,6 +117,11 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'reloadSkills',
   'rememberPromptHistory',
   'removeMcpServer',
+  'continueSessionInModel',
+  'scheduleQuotaResume',
+  'cancelQuotaResume',
+  'retryFailedTurn',
+  'setQuotaAutoResume',
   'removeNotice',
   'removePlugin',
   'renameSessionTitle',
@@ -177,6 +184,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setTheme',
   'setToolMode',
   'setWebSearchEnabled',
+  'setInstructionFiles',
   'setWebhookConfig',
   'setWebhookEnabled',
   'setWorkflow',
@@ -185,6 +193,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'startMediaJob',
   'switchContext',
   'taskControl',
+  'testWebhook',
   'toggleFast',
   'toggleVoice',
   'claimSetupRequest',

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

@@ -37,6 +37,8 @@ export function createAgentChildFactory({ registry, rehydrateAgentSessions, crea
       effort: preset.effort,
       fast: preset.fast === true,
       modelParameters: preset.modelParameters,
+      contextPercent: spec.contextPercent,
+      selectedContextWindow: spec.selectedContextWindow,
       toolMode: 'full',
       sessionProfile,
     });

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-options.mjs

@@ -8,6 +8,7 @@
 import { theme } from '../theme.mjs';
 import { displayModelName } 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';
 
 export const parsedModelVersion = (id) => {
   const text = String(id || '').toLowerCase();
@@ -167,6 +168,8 @@ const PROVIDER_DISPLAY_NAMES = new Map([
   ['openai-oauth', 'OpenAI OAuth'],
   ['anthropic-oauth', 'Anthropic OAuth'],
   ['grok-oauth', 'Grok OAuth'],
+  ['muse-code-oauth', 'Muse Code'],
+  ['mimo-oauth', 'MiMo'],
   ['cursor-oauth', 'Cursor OAuth'],
   ['antigravity-oauth', 'Antigravity OAuth'],
   ['openai', 'OpenAI API'],
@@ -193,6 +196,8 @@ const PROVIDER_DISPLAY_RANKS = {
   'openai-oauth': 10,
   'anthropic-oauth': 20,
   'grok-oauth': 30,
+  'muse-code-oauth': 33,
+  'mimo-oauth': 34,
   'antigravity-oauth': 31,
   'cursor-oauth': 32,
   'opencode-go': 35,
@@ -233,7 +238,14 @@ export const modelDescription = (m) =>
 
 const modelRecordDisplayName = (model) => displayModelName(model?.id, model?.provider, model?.display || model?.name);
 
-const routeModelDisplayName = (route) => displayModelName(route?.model, route?.provider, route?.modelDisplay || '');
+// Daybreak Blue reads as part of the model ("GPT-6 Sol Blue"), ahead of effort.
+const routeModelDisplayName = (route) =>
+  [
+    displayModelName(route?.model, route?.provider, route?.modelDisplay || ''),
+    route?.provider === DAYBREAK_PROVIDER && daybreakBlueOn(route?.modelParameters) ? 'Blue' : '',
+  ]
+    .filter(Boolean)
+    .join(' ');
 
 const groupModelsByProvider = (models) => {
   const providers = new Map();

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

@@ -4,6 +4,9 @@
 // selected parameters (and the selected effort), and cycling `thinking` can
 // invalidate a Fast selection that the new parameter combination rules out.
 import { modelKey } from './model-key.mjs';
+import { DAYBREAK_PARAMETER_ID } from '../../../../runtime/shared/llm/openai-daybreak.mjs';
+
+const TOGGLE_PARAMETER_IDS = new Set(['thinking', DAYBREAK_PARAMETER_ID]);
 
 export function createFastParameterSelection({ state, currentRoute, isCurrentRoute, isStateRoute, getSelectedEffort }) {
   const selectedFast = new Map();
@@ -82,12 +85,15 @@ export function createFastParameterSelection({ state, currentRoute, isCurrentRou
     return true;
   };
 
-  /** Cycles the 'thinking' parameter to its next option; false when the model
-   *  has none. Fast is dropped when the new parameters rule it out. */
+  /** Cycles the model's toggle parameter ('thinking', or Daybreak Blue's
+   *  on/off) to its next option; false when the model has none. Fast is
+   *  dropped when the new parameters rule it out. */
   const cycleThinking = (model) => {
-    const wanted = 'thinking';
-    const definition = (model.modelParameterOptions || []).find((parameter) => parameter.id === wanted);
+    const definition = (model.modelParameterOptions || []).find((parameter) =>
+      TOGGLE_PARAMETER_IDS.has(parameter.id)
+    );
     if (!definition?.options?.length) return false;
+    const wanted = definition.id;
     const parameters = modelParametersFor(model);
     const current = Math.max(
       0,

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

@@ -127,6 +127,11 @@ function beginInteractiveOAuthLogin(flow, providerItem, login) {
           `browser opened for ${providerName}; paste code/redirect here if callback does not finish`,
           'info'
         );
+      } else if (started?.userCode) {
+        flow.store.pushNotice(
+          `${providerName}: enter code ${started.userCode} in the browser to finish signing in`,
+          'info'
+        );
       } else {
         flow.store.pushNotice(`browser opened for ${providerName}; finish signing in there`, 'info');
       }

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 = {}) => {