mixdog 1.2.4 → 1.2.6

package/src/standalone/desktop-service-registry.mjs

@@ -165,6 +165,8 @@ export class DesktopServiceRegistry {
         moduleUrl: requestedModule,
         instance,
         subscribers: new Set(),
+        visibilityEpochs: new Map(),
+        nextVisibilityEpoch: 0,
       };
       this.#servicesById.set(requestedId, record);
       this.#servicesByModule.set(requestedModule, record);
@@ -187,7 +189,14 @@ export class DesktopServiceRegistry {
     const service = await this.#initialize(params);
     if (this.#closed) throw new Error('session service is closed');
     const token = subscriberToken(ctx);
-    if (token) service.subscribers.add(token);
+    if (token) {
+      service.subscribers.add(token);
+      // The adapter outlives desktop processes, whose request counters restart.
+      // Allocate the ordering namespace here, not from a client's wall clock.
+      if (!service.visibilityEpochs.has(token)) {
+        service.visibilityEpochs.set(token, ++service.nextVisibilityEpoch);
+      }
+    }
     this.#syncModelProxyPresence();
     return { desktopId: service.desktopId };
   }
@@ -215,14 +224,23 @@ export class DesktopServiceRegistry {
   }
 
   async invoke({ desktopId, method, args = [] } = {}, ctx = null) {
-    const { service } = this.#requireSubscribed(desktopId, ctx);
+    const { service, token } = this.#requireSubscribed(desktopId, ctx);
     const name = String(method || '');
     if (!name) throw new TypeError('desktop service method is required');
+    let callArgs = Array.isArray(args) ? args : [];
+    if (name === 'setVisibleSessions' && token) {
+      const epoch = service.visibilityEpochs.get(token);
+      if (epoch === undefined) {
+        service.subscribers.delete(token);
+        throw new Error('desktop service client is not initialized');
+      }
+      callArgs = [callArgs[0], callArgs[1], epoch];
+    }
     // `[slow-op] desktop.invoke` names the call it timed: a desktop operation
     // (Git reads) or a session capability, not only the generic route.
     const target = name === 'invokeDesktopOperation' || name === 'invokeCapability' ? String(args?.[0] || '') : '';
     annotateSpan(target ? `${name}:${target}` : name);
-    return sanitizeForWire(await service.instance.invoke(name, Array.isArray(args) ? args : [])) ?? null;
+    return sanitizeForWire(await service.instance.invoke(name, callArgs)) ?? null;
   }
 
   async control({ desktopId, message } = {}, ctx = null) {
@@ -241,7 +259,7 @@ export class DesktopServiceRegistry {
   async unsubscribe({ desktopId } = {}, ctx = null) {
     const service = this.#require(desktopId);
     const token = subscriberToken(ctx);
-    if (token) service.subscribers.delete(token);
+    if (token) await this.#releaseSubscriber(service, token);
     this.#syncModelProxyPresence();
     return { ok: true, unsubscribed: true };
   }
@@ -250,11 +268,20 @@ export class DesktopServiceRegistry {
     const token = String(clientToken || '');
     if (!token) return;
     for (const service of this.#servicesById.values()) {
-      service.subscribers.delete(token);
+      void this.#releaseSubscriber(service, token).catch((error) => {
+        this.#log(`desktop visibility release failed: ${error?.message || error}`);
+      });
     }
     this.#syncModelProxyPresence();
   }
 
+  async #releaseSubscriber(service, token) {
+    service.subscribers.delete(token);
+    const epoch = service.visibilityEpochs.get(token);
+    service.visibilityEpochs.delete(token);
+    if (epoch !== undefined) await service.instance.releaseClient?.(epoch);
+  }
+
   notifySessionRuntimeReleased(sessionId, reason) {
     // An evicted session has NO session subscribers. Its desktop resources
     // still belong to the desktop service and must be notified on that lane.

package/src/standalone/session-call-cache.mjs

@@ -85,6 +85,10 @@ export function createSessionCallCache({
     // Identity cannot be removed inside the promised retry TTL.
     for (const [key, record] of records) {
       if (records.size <= maxEntries && retainedBytes <= maxBytes) return;
+      // Insertion order is `at` order and settledAt >= at, so no later record
+      // can have left its TTL: stop instead of rescanning every live entry on
+      // each new call while a burst holds the cache above its budget.
+      if (at - record.at < ttlMs) break;
       if (!record.settled || !record.settledAt) continue;
       if (at - record.settledAt < ttlMs) continue;
       remove(key, record);
@@ -120,6 +124,8 @@ export function createSessionCallCache({
       bytes: 0,
       timer: null,
     };
+    // Re-insert at the tail so Map order stays `at` order (prune relies on it).
+    remove(key);
     records.set(key, record);
     prune();
     promise

package/src/standalone/session-protocol.mjs

@@ -118,6 +118,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'saveCustomProvider',
   'removeCustomProvider',
   'updateCustomProviderModel',
+  'setModelPreferences',
   'testCustomProvider',
   'checkCustomProviderKeyEnv',
   'discoverCustomProviderModels',
@@ -166,7 +167,6 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'saveAgentDefinition',
   'saveMcpServer',
   'saveOpenAIUsageSessionKey',
-  'saveOpenCodeGoUsageAuth',
   'saveProviderApiKey',
   'saveSchedule',
   'saveSkill',

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

@@ -6,7 +6,7 @@
  * cannot be read is treated as busy rather than risking the loss of a live
  * turn. The eviction sweep that consumes this lives in ../retention.mjs.
  */
-import { hasActiveBackgroundTasks } from '../../../runtime/shared/background-tasks.mjs';
+import { activeBackgroundTaskSessionIds, hasActiveBackgroundTasks } from '../../../runtime/shared/background-tasks.mjs';
 
 export function createBusyTracker({ sessions, currentSessionId }) {
   function stateBusy(state) {
@@ -44,10 +44,15 @@ export function createBusyTracker({ sessions, currentSessionId }) {
     }
   }
 
+  // sessionBusy for every entry, with the background tasks scanned once: the
+  // owner heartbeat, telemetry and status ask this every few seconds, and a
+  // scan per session made it sessions × tasks on the event loop.
   function liveBusyCount() {
+    const withTasks = activeBackgroundTaskSessionIds();
     let count = 0;
     for (const entry of sessions) {
-      if (sessionBusy(entry)) count += 1;
+      const sessionId = currentSessionId(entry);
+      if ((sessionId && withTasks.has(sessionId)) || sessionTurnBusy(entry)) count += 1;
     }
     return count;
   }

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

@@ -57,9 +57,10 @@ export function createTransportRoutes({
 }) {
   // Checked on every register/call, last right before the work is handed on
   // (after the body is read): a daemon that lost (or cannot re-verify) its
-  // owner lease serves nothing.
-  const refuseUnadmitted = (res) => {
-    if (admitWork()) return false;
+  // owner lease serves nothing. `admitWork` may answer asynchronously (a
+  // request arriving during the lease's re-verification waits for it).
+  const refuseUnadmitted = async (res) => {
+    if (await admitWork()) return false;
     sendError(res, 'daemon owner lease is not held', 503);
     return true;
   };
@@ -99,7 +100,7 @@ export function createTransportRoutes({
 
   const register = async (req, res) => {
     const body = await readBody(req);
-    if (refuseUnadmitted(res)) return;
+    if (await refuseUnadmitted(res)) return;
     if (drain.committed) {
       sendError(res, `daemon is draining: ${drain.reason}`, 503);
       return;
@@ -150,7 +151,7 @@ export function createTransportRoutes({
   };
 
   const call = async (req, res) => {
-    if (refuseUnadmitted(res)) return;
+    if (await refuseUnadmitted(res)) return;
     if (drain.committed) {
       sendError(res, `daemon is draining: ${drain.reason}`, 503);
       return;
@@ -158,7 +159,7 @@ export function createTransportRoutes({
     const body = await readBody(req);
     // Again right before dispatch: the lease may have been fenced while the
     // body was still arriving.
-    if (refuseUnadmitted(res)) return;
+    if (await refuseUnadmitted(res)) return;
     await callRoute(body, res);
   };
 

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

@@ -8,6 +8,7 @@
 import { theme } from '../theme.mjs';
 import { displayModelName, effortDisplayLabel } from '../../runtime/shared/model-display.mjs';
 import { isRollingModelAlias } from '../../runtime/shared/model-alias.mjs';
+import { describeError } from '../../runtime/shared/error-presentation.mjs';
 import { DAYBREAK_PROVIDER, daybreakBlueOn } from '../../runtime/shared/llm/openai-daybreak.mjs';
 
 export const parsedModelVersion = (id) => {
@@ -183,7 +184,7 @@ const PROVIDER_DISPLAY_NAMES = new Map([
   ['xai-api', 'xAI API'],
   ['deepseek', 'DeepSeek API'],
   ['deepseek-api', 'DeepSeek API'],
-  ['opencode-go', 'OpenCode Go API'],
+  ['opencode-go-oauth', 'OpenCode Go OAuth'],
   ['openrouter', 'OpenRouter'],
   ['mixdog-local', 'Local Provider'],
   ['default', 'Default'],
@@ -220,6 +221,42 @@ export const loadProviderDisplayNames = async (store) => {
   return names;
 };
 
+/** `{ id, text }` for each provider whose model list failed, with the reason
+ *  (the setup row's `catalogError`) and what to do about it. */
+export const loadProviderCatalogFailures = async (store) => {
+  let setup = null;
+  try {
+    setup = await store?.getProviderSetup?.();
+  } catch {
+    return [];
+  }
+  const failures = [];
+  for (const group of ['api', 'oauth', 'local']) {
+    for (const entry of Array.isArray(setup?.[group]) ? setup[group] : []) {
+      const failure = entry?.catalogError;
+      if (!failure?.message) continue;
+      const { summary, recovery } = describeError({ message: failure.message, errorKind: failure.errorKind });
+      failures.push({ id: String(entry.id || '').trim(), text: [summary, recovery].filter(Boolean).join(' ') });
+    }
+  }
+  return failures;
+};
+
+/** Provider-list rows for failed providers that have no model rows, so an
+ *  empty provider says why instead of being absent. */
+export const buildCatalogFailureItems = (failures, models, providerNames = null) =>
+  failures
+    .filter(({ id }) => id && !models.some((model) => model.provider === id))
+    .map(({ id, text }) => ({
+      value: `provider-failed:${id}`,
+      label: resolveProviderDisplayName(id, providerNames),
+      marker: '!',
+      markerColor: theme.error,
+      description: text,
+      _action: 'catalog-failed',
+      _failure: text,
+    }));
+
 const PROVIDER_DISPLAY_RANKS = {
   default: 0,
   'openai-oauth': 10,
@@ -230,7 +267,7 @@ const PROVIDER_DISPLAY_RANKS = {
   'mimo-oauth': 34,
   'antigravity-oauth': 31,
   'cursor-oauth': 32,
-  'opencode-go': 35,
+  'opencode-go-oauth': 34.5,
   openai: 40,
   'openai-api': 40,
   anthropic: 50,

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

@@ -10,7 +10,13 @@
  * state (getState) is read through a getter so it always reflects the current
  * render.
  */
-import { normalizeModelOptions, buildModelProviderItems, loadProviderDisplayNames } from './model-options.mjs';
+import {
+  normalizeModelOptions,
+  buildCatalogFailureItems,
+  buildModelProviderItems,
+  loadProviderCatalogFailures,
+  loadProviderDisplayNames,
+} from './model-options.mjs';
 import { createModelCatalog } from './model-picker/catalog-load.mjs';
 import { openProviderModelsPicker, saveSelectedRoute } from './model-picker/provider-models-list.mjs';
 
@@ -78,6 +84,7 @@ export function createModelPicker({
 
     const models = normalizeModelOptions(providerModels);
     const providerNames = await loadProviderDisplayNames(store);
+    const catalogFailures = await loadProviderCatalogFailures(store);
     const activeRoute = options.currentRoute || {
       provider: state.provider,
       model: state.model,
@@ -116,7 +123,10 @@ export function createModelPicker({
         providerListHighlightProvider = renderOptions.highlightProvider;
       }
       const highlightProvider = renderOptions.highlightProvider || providerListHighlightProvider || null;
-      const providerItems = buildModelProviderItems(models, activeRoute, providerNames);
+      const providerItems = [
+        ...buildModelProviderItems(models, activeRoute, providerNames),
+        ...buildCatalogFailureItems(catalogFailures, models, providerNames),
+      ];
       const providerHighlight = highlightProvider || activeRoute?.provider || null;
       const providerInitialIndex = Math.max(
         0,
@@ -133,6 +143,10 @@ export function createModelPicker({
         pickerKey: `model-picker:providers:${providerHighlight || 'default'}`,
         items: providerItems,
         onSelect: (_value, item) => {
+          if (item?._failure) {
+            store.pushNotice(`${item.label}: ${item._failure}`, 'warn');
+            return;
+          }
           if (!item?._provider) return;
           openProviderModelsPicker({
             view,

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

@@ -74,8 +74,7 @@ export function createProviderSetupPicker({
     setSettingsPrompt(null);
     // Close full-panel overlays too: they render ahead of providerPrompt in
     // the floating-panel chain, so a lingering usage/context panel would mask
-    // any text-entry prompt opened from the provider actions (e.g. the
-    // OpenCode Go cookie prompt appeared to do nothing).
+    // any text-entry prompt opened from the provider actions.
     own.context(null);
     closeUsagePanel();
     // Onboarding (and any caller) can pass a preloaded provider setup so we skip