mixdog 1.0.8 → 1.0.10

package/src/session-runtime/services/agent-tool/render.mjs

@@ -17,13 +17,8 @@ export function abnormalEmptyFinishError(result, agent) {
   if (!reason) return null;
   const iterations = result?.iterations ?? 0;
   const toolCallsTotal = result?.toolCallsTotal ?? 0;
-  const maxLoopIterations = result?.maxLoopIterations ?? 0;
   const stopReason = result?.stopReason ?? result?.stop_reason ?? null;
   switch (reason) {
-    case 'iteration_cap':
-      // Preserve failure reporting for stored results from older runtimes.
-      // Current execution no longer applies a loop iteration ceiling.
-      return `agent '${agent}' hit the loop iteration ceiling (${maxLoopIterations} iterations, ${toolCallsTotal} tool calls) without producing a final answer`;
     case 'truncated':
       return `agent '${agent}' response was truncated (stopReason=${stopReason}) before a final answer (${iterations} iterations, ${toolCallsTotal} tool calls)`;
     case 'empty':

package/src/session-runtime/services/provider-admin.mjs

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import {
   AGENT_PROVIDER_ENV,
   SECRET_ACCOUNTS,
@@ -156,9 +157,14 @@ function availableOAuthProvider(id) {
   return oauth && isOAuthProviderAvailable(id) ? oauth : null;
 }
 
-export function isKnownProvider(provider) {
+export function isKnownProvider(provider, config = {}) {
   const id = String(provider || '').trim();
-  return id !== '' && (API_PROVIDER_IDS.has(id) || BUILTIN_PROVIDER_IDS.has(id) || !!availableOAuthProvider(id));
+  return id !== '' && (
+    API_PROVIDER_IDS.has(id) ||
+    BUILTIN_PROVIDER_IDS.has(id) ||
+    !!availableOAuthProvider(id) ||
+    (isCustomProviderId(id) && isCustomProviderConfig(config.providers?.[id]) && config.providers[id].enabled !== false)
+  );
 }
 
 function updateConfigProvider(cfgMod, providerId, patch) {
@@ -275,11 +281,57 @@ function oauthProviderSetup(p, providers, checkSecrets) {
   };
 }
 
+const CUSTOM_ID_RE = /^custom-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const CUSTOM_TEST_TIMEOUT_MS = 20_000;
+const CUSTOM_DISCOVERY_TIMEOUT_MS = 15_000;
+
+export function isCustomProviderConfig(entry) {
+  return Boolean(entry) && typeof entry === 'object' && entry.type === 'custom';
+}
+
+export function isCustomProviderId(id) {
+  return CUSTOM_ID_RE.test(String(id || ''));
+}
+
+const loadCustomProviderModule = () => import('../../runtime/agent/orchestrator/providers/custom-provider.mjs');
+
+// Secret-free public view of a custom provider. Never carries an API key.
+function customProviderRow(id, entry, checkSecrets = true) {
+  const configuredEnabled = entry.enabled !== false;
+  const stored = checkSecrets ? hasStoredSecret(SECRET_ACCOUNTS.agentApiKey(id)) : false;
+  return {
+    id,
+    name: entry.name,
+    protocol: entry.protocol,
+    baseURL: entry.baseURL,
+    models: Array.isArray(entry.models) ? entry.models.map((m) => ({ ...m })) : [],
+    custom: true,
+    group: 'api',
+    type: 'api-key',
+    enabled: configuredEnabled,
+    authenticated: checkSecrets ? stored : configuredEnabled,
+    stored,
+    env: false,
+    envName: null,
+    status: stored ? 'Set' : configuredEnabled ? 'No Key' : 'Off',
+    detail: stored ? 'stored in keychain' : 'custom endpoint',
+  };
+}
+
+function customProviderRows(providers, checkSecrets) {
+  return Object.entries(providers)
+    .filter(([id, entry]) => isCustomProviderId(id) && isCustomProviderConfig(entry))
+    .map(([id, entry]) => customProviderRow(id, entry, checkSecrets));
+}
+
 export async function providerSetup(config = {}, options = {}) {
   const providers = config.providers || {};
   const checkSecrets = options?.checkSecrets !== false;
   return {
-    api: API_PROVIDERS.map((p) => apiProviderSetup(p, providers, checkSecrets)),
+    api: [
+      ...API_PROVIDERS.map((p) => apiProviderSetup(p, providers, checkSecrets)),
+      ...customProviderRows(providers, checkSecrets),
+    ],
     oauth: availableOAuthProviders().map((p) => oauthProviderSetup(p, providers, checkSecrets)),
     local: [builtInLocalProviderSetup(config, options)],
   };
@@ -322,6 +374,16 @@ function oauthProviderStatusRow(p, config) {
 export function providerStatus(config = {}) {
   return [
     ...API_PROVIDERS.map((p) => apiProviderStatusRow(p, config)),
+    ...customProviderRows(config.providers || {}, true).map((row) => ({
+      id: row.id,
+      type: 'api-key',
+      enabled: row.enabled,
+      authenticated: row.authenticated,
+      stored: row.stored,
+      env: false,
+      envName: null,
+      label: row.name,
+    })),
     ...availableOAuthProviders().map((p) => oauthProviderStatusRow(p, config)),
   ];
 }
@@ -525,6 +587,142 @@ export function saveProviderApiKey(cfgMod, provider, secret) {
   return { provider: id, type: 'api-key', authenticated: true };
 }
 
+function sanitizeCustomError(error, secrets = []) {
+  let text = String(error?.message || error || 'request failed');
+  for (const secret of secrets) if (secret) text = text.split(secret).join('[redacted]');
+  text = text
+    .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Bearer [redacted]')
+    .replace(/\b(?:sk|key|tok)[-_][A-Za-z0-9_-]{8,}/gi, '[redacted]')
+    .replace(/(api[-_]?key|authorization|token)(["']?\s*[:=]\s*["']?)[^\s"',}]+/gi, '$1$2[redacted]')
+    .replace(/[\r\n]+/g, ' ')
+    .trim();
+  if (text.length > 300) text = `${text.slice(0, 300)}…`;
+  return new Error(text || 'request failed');
+}
+
+async function withTimeout(run, ms, label) {
+  const controller = new AbortController();
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`${label} timed out after ${Math.round(ms / 1000)}s`));
+    }, ms);
+  });
+  try {
+    return await Promise.race([run(controller.signal), timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function existingCustomEntry(cfgMod, id) {
+  const entry = cfgMod.loadConfig().providers?.[id];
+  if (!isCustomProviderId(id) || !isCustomProviderConfig(entry)) throw new Error(`unknown custom provider "${id}"`);
+  return entry;
+}
+
+function inputObject(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw new TypeError('custom provider is invalid');
+  return input;
+}
+
+// Validated, secret-free config for `input`; the key (typed, else stored for an
+// existing provider) is resolved separately and never enters the config.
+async function resolveCustomInput(cfgMod, rawInput, options) {
+  const input = inputObject(rawInput);
+  const id = input.id === undefined || input.id === null || input.id === '' ? null : String(input.id);
+  if (id) existingCustomEntry(cfgMod, id);
+  const { normalizeCustomProviderConfig } = await loadCustomProviderModule();
+  const config = normalizeCustomProviderConfig(input, options);
+  const typed = typeof input.apiKey === 'string' ? input.apiKey.trim() : '';
+  const apiKey = typed || (id ? getAgentApiKey(id) || '' : '');
+  return { id, config, typed, apiKey };
+}
+
+export async function saveCustomProvider(cfgMod, rawInput) {
+  const { id: existingId, config, typed, apiKey } = await resolveCustomInput(cfgMod, rawInput, { requireModels: false });
+  if (!apiKey) throw new Error('API key is required');
+  const id = existingId || `custom-${randomUUID()}`;
+  const entry = {
+    type: 'custom',
+    name: config.name,
+    protocol: config.protocol,
+    baseURL: config.baseURL,
+    models: config.models,
+    enabled: true,
+  };
+  const account = SECRET_ACCOUNTS.agentApiKey(id);
+  const previousKey = typed && existingId ? getAgentApiKey(id) : null;
+  if (typed) saveSecret(account, typed);
+  try {
+    const current = cfgMod.loadConfig();
+    cfgMod.saveConfig({ ...current, providers: { ...(current.providers || {}), [id]: entry } }, { baseConfig: current });
+  } catch (error) {
+    if (typed) {
+      if (previousKey) saveSecret(account, previousKey);
+      else deleteSecret(account);
+    }
+    throw error;
+  }
+  return customProviderRow(id, entry);
+}
+
+export function removeCustomProvider(cfgMod, rawId) {
+  const id = String(rawId || '').trim();
+  existingCustomEntry(cfgMod, id);
+  const current = cfgMod.loadConfig();
+  const { [id]: _removed, ...providers } = current.providers || {};
+  cfgMod.saveConfig({ ...current, providers }, { baseConfig: current });
+  deleteSecret(SECRET_ACCOUNTS.agentApiKey(id));
+  return { provider: id, type: 'custom', removed: true };
+}
+
+export async function testCustomProvider(cfgMod, rawInput) {
+  const { id, config, apiKey } = await resolveCustomInput(cfgMod, rawInput, { requireModels: false });
+  try {
+    const models = config.models.length ? config.models : (await discoverCustomProviderModels(cfgMod, rawInput)).models;
+    const model = models[0]?.id;
+    if (!model) throw new Error('No models were found for this provider');
+    const { createCustomProvider } = await loadCustomProviderModule();
+    const provider = await createCustomProvider(id || 'custom-test', { ...config, apiKey });
+    await withTimeout(
+      (signal) => provider.send([{ role: 'user', content: 'Reply with OK.' }], model, [], { signal, maxTokens: 16 }),
+      CUSTOM_TEST_TIMEOUT_MS,
+      'connection test'
+    );
+    return { ok: true };
+  } catch (error) {
+    throw sanitizeCustomError(error, [apiKey]);
+  }
+}
+
+export async function discoverCustomProviderModels(cfgMod, rawInput) {
+  const { id, config, apiKey } = await resolveCustomInput(cfgMod, rawInput, { requireModels: false });
+  try {
+    const { createCustomProvider } = await loadCustomProviderModule();
+    const provider = await createCustomProvider(id || 'custom-discovery', { ...config, models: [], apiKey });
+    const listed = await withTimeout(() => provider.listModels(), CUSTOM_DISCOVERY_TIMEOUT_MS, 'model discovery');
+    const seen = new Set();
+    const models = [];
+    for (const item of Array.isArray(listed) ? listed : []) {
+      const modelId = String(item?.id || '').trim();
+      if (!modelId || seen.has(modelId)) continue;
+      seen.add(modelId);
+      const model = { id: modelId };
+      const name = String(item.name || item.display || '').trim();
+      if (name && name !== modelId) model.name = name;
+      if (Number(item.contextWindow) > 0) model.contextWindow = Math.floor(Number(item.contextWindow));
+      const out = Number(item.maxOutputTokens ?? item.outputTokens);
+      if (out > 0) model.maxOutputTokens = Math.floor(out);
+      models.push(model);
+    }
+    return { models };
+  } catch (error) {
+    throw sanitizeCustomError(error, [apiKey]);
+  }
+}
+
 export function saveOpenAIUsageSessionKey(cfgMod, secret) {
   const value = String(secret || '').trim();
   if (!value) throw new Error('OpenAI usage session key is required for credit lookup');

package/src/session-runtime/settings-builtin-tools-api.mjs

@@ -1,12 +1,9 @@
 // Built-in tool modules: the enable/install toggles (web search, memory, git,
 // office, tidy, local provider), the recap switch and the Code Tidy card.
 import {
-  BRIDGE_FIRST_USE_IDS,
   INSTALLABLE_BUILTIN_IDS,
   builtinFeatureActive,
-  builtinFirstUseApproval,
   builtinInstalled,
-  setBuiltinFirstUseApprovalInConfig,
   setBuiltinInstalledInConfig,
 } from '../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
 import { LOCAL_PROVIDER_ID } from '../runtime/local-provider/managed-runtime.mjs';
@@ -115,19 +112,6 @@ export function createBuiltinToolSettings(
       await refreshEmptySessionToolPolicy?.();
       return this.getToolModuleSettings();
     },
-    /** Once-per-session approval before the first Browser Use or Computer Use
-     *  call. The setting is read at each call, so it applies at once. */
-    async setBridgeFirstUseApproval(name, enabled) {
-      if (!BRIDGE_FIRST_USE_IDS.includes(name)) {
-        throw new TypeError('First-use approval applies to browser or computer.');
-      }
-      saveConfigAndAdopt(setBuiltinFirstUseApprovalInConfig({ ...getConfig() }, name, enabled !== false));
-      return {
-        name,
-        firstUseApproval: builtinFirstUseApproval(getConfig(), name),
-        appliesTo: 'the next first use in any session, including this one',
-      };
-    },
     async setBuiltinToolEnabled(name, enabled) {
       if (name !== 'git' && name !== 'office' && name !== 'tidy' && name !== 'localProvider') {
         throw new TypeError('Built-in tool must be git, office, tidy, or localProvider.');

package/src/session-runtime/setup-tool/executor.mjs

@@ -3,7 +3,7 @@
  *  reconnects, and the empty-session tool-policy refresh all apply exactly as
  *  they do for a UI click. The facade is read lazily because runtime-core
  *  registers the tool executor before it finishes assembling the API object. */
-import { builtinFeatureActive, builtinFirstUseApproval } from '../../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
+import { builtinFeatureActive } from '../../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
 import { ORCHESTRATION_MODES } from '../../runtime/shared/orchestration.mjs';
 import { SETUP_DESKTOP_DOMAINS, SETUP_HANDOFFS } from './settings-contract.mjs';
 import { executeExtendedSetupAction, publicAutomation, validateMcpInput } from './extended-actions.mjs';
@@ -253,14 +253,8 @@ const SETUP_STATUS_READERS = {
     const config = getConfig();
     return {
       ...featureFlags(rt),
-      browser: {
-        active: builtinFeatureActive(config, 'browser'),
-        firstUseApproval: builtinFirstUseApproval(config, 'browser'),
-      },
-      computer: {
-        active: builtinFeatureActive(config, 'computer'),
-        firstUseApproval: builtinFirstUseApproval(config, 'computer'),
-      },
+      browser: { active: builtinFeatureActive(config, 'browser') },
+      computer: { active: builtinFeatureActive(config, 'computer') },
     };
   },
   shell: (rt) => rt.getSystemShell?.() || {},
@@ -398,10 +392,6 @@ const SETUP_ACTION_HANDLERS = {
     if (DESKTOP_HOSTED_FEATURES.includes(name)) return requestDesktop(args);
     return rt.setBuiltinToolEnabled(name, requireBoolean(args.enabled));
   },
-  set_first_use_approval: (rt, args) => {
-    const name = requireEnum(args.name, ['browser', 'computer'], 'name');
-    return rt.setBridgeFirstUseApproval(name, requireBoolean(args.enabled));
-  },
   install_builtin: async (rt, args, { requestDesktop }) => {
     const name = requireEnum(args.name, SETUP_INSTALLABLE_FEATURES, 'name');
     if (DESKTOP_HOSTED_FEATURES.includes(name)) return requestDesktop(args);
@@ -596,6 +586,10 @@ export function createSetupToolExecutor({ getApi, getConfig, notifySessionUi, ge
       const result = await execute(args, options);
       if (READ_ONLY_SETUP_ACTIONS.has(args.action)) return JSON.stringify(result ?? {}, null, 2);
       await flushSettings?.();
+      // Attached surfaces re-read what changed instead of waiting for their
+      // next open or cache expiry.
+      const sessionId = clean(getSessionId?.());
+      if (sessionId) notifySessionUi?.(sessionId, 'Settings changed', { kind: 'setup-changed', action: args.action });
       return setupMutationReceipt(args.action, result);
     },
   };

package/src/session-runtime/setup-tool/tool-defs.mjs

@@ -78,7 +78,6 @@ export const SETUP_ACTION_FIELDS = Object.freeze({
   set_recap_enabled: 'enabled',
   set_web_search_enabled: 'enabled',
   set_builtin_enabled: 'name enabled',
-  set_first_use_approval: 'name enabled',
   install_builtin: 'name',
   install_local_model: 'modelId',
   start_local_installation: 'phase modelId?',
@@ -209,11 +208,11 @@ export const SETUP_TOOL_DEFS = Object.freeze([
         enabled: {
           type: 'boolean',
           description:
-            'Boolean setters (set_*_enabled, set_first_use_approval, set_compaction, set_auto_update, set_mcp_enabled, set_plugin_enabled).',
+            'Boolean setters (set_*_enabled, set_compaction, set_auto_update, set_mcp_enabled, set_plugin_enabled).',
         },
         name: {
           type: 'string',
-          description: `set_builtin_enabled: ${SETUP_BUILTIN_TOGGLE_FEATURES.join('|')}; install_builtin also accepts memory. Memory toggles use set_memory_enabled. set_first_use_approval: browser|computer; revoke_linked_device: client id from status connection, not its display name; set_developer_option: option id from status developer; else MCP/plugin/provider id.`,
+          description: `set_builtin_enabled: ${SETUP_BUILTIN_TOGGLE_FEATURES.join('|')}; install_builtin also accepts memory. Memory toggles use set_memory_enabled. revoke_linked_device: client id from status connection, not its display name; set_developer_option: option id from status developer; read_definition/delete_definition: the definition id; else MCP/plugin/provider id.`,
         },
         accountId: {
           type: 'string',

package/src/session-runtime/tool-policy-refresh.mjs

@@ -71,7 +71,6 @@ export function createToolPolicyRefresh({
   getDataDir,
   modelStandaloneTools,
   featureDisallowedTools,
-  memoryToolsEnabled,
   loadCoreMemoryContext,
   activeWorkflowContext,
   invalidatePreSessionToolSurface,
@@ -94,7 +93,6 @@ export function createToolPolicyRefresh({
   }
 
   async function leadCoreMemoryContext() {
-    if (!memoryToolsEnabled()) return '';
     try {
       return await loadCoreMemoryContext();
     } catch {

package/src/session-runtime/webhook-session-run.mjs

@@ -10,12 +10,16 @@ import { createSession } from '../runtime/agent/orchestrator/session/manager/ses
 import { askSession } from '../runtime/agent/orchestrator/session/manager/ask-session.mjs';
 import { modelRouteFields, parseScheduleModelRef } from '../runtime/shared/schedule-model-ref.mjs';
 import { automationWorkflowOpts } from './automation-workflow.mjs';
+import { runAutomationTurns } from './automation-agents.mjs';
 import { automationPromptContent } from '../runtime/shared/automation-attachments.mjs';
 
 // Webhook payloads are authenticated transport data, not trusted user intent.
 // Keep their sessions on the deterministic read-only bundle even when a
-// preset or workflow would otherwise resolve to full tools.
-export const WEBHOOK_SESSION_TOOLS = Object.freeze(['tools:readonly']);
+// preset or workflow would otherwise resolve to full tools. `tools:mcp` adds
+// only the automation scope's internal tools — the agent tool, offered when the
+// user's orchestration mode allows delegation (user decision: automations may
+// delegate); the scope connects no MCP servers.
+export const WEBHOOK_SESSION_TOOLS = Object.freeze(['tools:readonly', 'tools:mcp']);
 
 /** Endpoint model ref wins; the maintenance.webhook route is the fallback. */
 function webhookRoute(modelRef) {
@@ -66,14 +70,9 @@ export async function runWebhookSession({
   // askOpts.signal is the parent-abort link: it is cascaded onto the turn
   // controller, so aborting it stops the in-flight provider/tool work instead
   // of leaving a timed-out delivery's session running with live side effects.
-  const result = await askSession(
-    session.id,
-    content,
-    null,
-    null,
-    projectCwd || undefined,
-    undefined,
-    signal ? { signal } : {}
-  );
+  const ask = (turnContent) =>
+    askSession(session.id, turnContent, null, null, projectCwd || undefined, undefined, signal ? { signal } : {});
+  // Agents the run delegates to report back; each result is the next turn.
+  const result = await runAutomationTurns(session.id, () => ask(content), ask);
   return { sessionId: session.id, result: String(result?.content || '') };
 }

package/src/session-runtime/workflow-agents-api/agent-route.mjs

@@ -73,6 +73,11 @@ export function createAgentRouteApi(deps) {
     const keepOff = requested.disabled === true;
     if (keepOff && !(clean(requested.provider) && clean(requested.model))) {
       saveDisabled(id, true);
+      // An explicitly empty provider still asks to drop the override, as it
+      // does for an agent that stays on: off and inheriting Main.
+      if (hasOwn(requested, 'provider') && !clean(requested.provider)) {
+        return { ...clearOverride(id), id, disabled: true };
+      }
       return { ...stored, id, disabled: true };
     }
     if (requested.disabled === false && Object.keys(requested).length === 1) {

package/src/standalone/daemon-agent-control.mjs

@@ -8,6 +8,8 @@
 // this control exists — the host takes `execute` as a constructor option), and
 // `cwd`. Output: { canonicalAgentTool, execute }.
 
+import { deliverAutomationCompletion } from '../session-runtime/automation-agents.mjs';
+
 export function createCanonicalAgentControl({ getSessionService, getSessionRuntimeHost, cwd }) {
   let canonicalAgentToolPromise = null;
 
@@ -32,7 +34,12 @@ export function createCanonicalAgentControl({ getSessionService, getSessionRunti
           isKeychainPrewarmReady: () => true,
           sessionSurface: sessionService.agentSurface,
           notifySessionCompletion(ownerSessionId, text, meta = {}) {
-            return getSessionRuntimeHost()?.notifySessionCompletion?.(ownerSessionId, text, meta) === true;
+            // A schedule/webhook run owns no session runtime; its own
+            // agent-result waiter takes the completions it is owed.
+            return (
+              getSessionRuntimeHost()?.notifySessionCompletion?.(ownerSessionId, text, meta) === true ||
+              deliverAutomationCompletion(ownerSessionId, text, meta)
+            );
           },
         });
       })

package/src/standalone/daemon.mjs

@@ -71,6 +71,7 @@ import { createLagProfiler } from './daemon-lag-profiler.mjs';
 import { createChannelsRuntimeLoader } from './daemon-channels-loader.mjs';
 import { createDesktopRuntime } from './daemon-desktop-runtime.mjs';
 import { createCanonicalAgentControl } from './daemon-agent-control.mjs';
+import { registerAutomationAgentTool } from '../session-runtime/automation-agents.mjs';
 import {
   compareRuntimeVersions,
   SESSION_CAPABILITY_FINGERPRINT,
@@ -666,6 +667,9 @@ async function main() {
     getSessionRuntimeHost: () => sessionRuntimeHost,
     cwd: CWD,
   });
+  // Schedules and webhooks run headless here; their sessions reach the same
+  // canonical agent control through the automation tool scope.
+  registerAutomationAgentTool(agentControl.execute);
   const requestedRuntimeMode = String(process.env.MIXDOG_SESSION_RUNTIME_MODE || '')
     .trim()
     .toLowerCase();

package/src/standalone/session-protocol.mjs

@@ -93,6 +93,10 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'deleteMediaAsset',
   'deleteMediaAssets',
   'deleteSchedule',
+  'saveCustomProvider',
+  'removeCustomProvider',
+  'testCustomProvider',
+  'discoverCustomProviderModels',
   'deleteSession',
   'deleteWebhook',
   'deleteWorkflow',

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

@@ -7,6 +7,7 @@
  */
 import { theme } from '../theme.mjs';
 import { displayModelName } from '../../runtime/shared/model-display.mjs';
+import { isRollingModelAlias } from '../../runtime/shared/model-alias.mjs';
 
 export const parsedModelVersion = (id) => {
   const text = String(id || '').toLowerCase();
@@ -147,7 +148,15 @@ export const normalizeModelOptions = (models) => {
     const providerModels = [];
     for (const [family, group] of families.entries()) {
       const limit = modelFamilyLimit(provider, family);
-      providerModels.push(...group.slice().sort(compareModelRecency).slice(0, limit));
+      // Version limits must not hide rolling routes, even when several
+      // vendors' "~..." IDs share the fallback family.
+      let versions = 0;
+      providerModels.push(
+        ...group
+          .slice()
+          .sort(compareModelRecency)
+          .filter((model) => isRollingModelAlias(model.id) || versions++ < limit)
+      );
     }
     normalized.push(...providerModels.sort(compareModelRecency));
   }

package/src/tui/dist/index.mjs

@@ -44194,7 +44194,6 @@ import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:pa
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-var DEFAULT_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 var homeBase = null;
 var homePath = null;
 var dataBase = null;
@@ -47687,7 +47686,9 @@ var LITELLM_FLAG_FIELDS = [
   "supports_web_search",
   "supports_websearch",
   "supports_prompt_caching",
-  "supports_reasoning"
+  "supports_reasoning",
+  // Reader: supportsAnthropicFastMode (anthropic-betas.mjs).
+  "supports_fast_mode"
 ];
 var LITELLM_STRING_FIELDS = ["mode", "litellm_provider", "reasoning_content_field"];
 function projectLitellmRow(row) {
@@ -55202,6 +55203,11 @@ function createMaintenancePickers({
   };
 }
 
+// src/runtime/shared/model-alias.mjs
+function isRollingModelAlias(id) {
+  return /-latest$/i.test(String(id || "").trim());
+}
+
 // src/tui/app/model-options.mjs
 var parsedModelVersion = (id) => {
   const text = String(id || "").toLowerCase();
@@ -55321,7 +55327,10 @@ var normalizeModelOptions = (models) => {
     const providerModels = [];
     for (const [family, group] of families.entries()) {
       const limit = modelFamilyLimit(provider, family);
-      providerModels.push(...group.slice().sort(compareModelRecency).slice(0, limit));
+      let versions = 0;
+      providerModels.push(
+        ...group.slice().sort(compareModelRecency).filter((model) => isRollingModelAlias(model.id) || versions++ < limit)
+      );
     }
     normalized.push(...providerModels.sort(compareModelRecency));
   }

package/src/tui/session/agent-job-feed/notification-router.mjs

@@ -15,8 +15,15 @@ export function createNotificationRouter({
   modelNotification,
 }) {
   let uiOpenSeq = 0;
+  let setupChangeSeq = 0;
   const uiActions = {
     'setup-ui': (delivery) => set({ setupUiRequest: { id: delivery.id, at: Date.now() } }),
+    'setup-changed': (delivery) => {
+      // Monotonic like ui-open: consecutive changes by the same action must
+      // each refresh the attached surfaces.
+      setupChangeSeq += 1;
+      set({ setupChanged: { action: delivery.setupAction, seq: setupChangeSeq, at: Date.now() } });
+    },
     'ui-open': (delivery) => {
       // Monotonic seq: the same command requested twice must fire twice, and
       // the consuming App effect keys on the object identity + seq.

package/src/tui/session/live-share.mjs

@@ -13,9 +13,17 @@
  * pipe is down. Ownership/promotion semantics are unchanged — the pipe is a
  * transport, never a second writer.
  */
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
 import { createOwnerLeg } from './live-share/owner.mjs';
 import { createViewerLeg } from './live-share/viewer.mjs';
 
+// A unix socket path is a fixed sun_path buffer: 104 bytes on macOS and the
+// BSDs, 108 on Linux, NUL included. A desktop session id alone is 64 hex, so
+// the path beside its session file runs past the macOS limit and listen()
+// failed there for every desktop session.
+const UNIX_SOCKET_PATH_MAX_BYTES = 103;
+
 // Session entry is latency-sensitive: the owner pipe can be a few event-loop
 // turns behind the viewer resume. Retry locally instead of waiting for the
 // coarse 3s session runtime safety tick.
@@ -23,7 +31,14 @@ const LIVE_CONNECT_RETRY_MIN_MS = 10;
 const LIVE_CONNECT_RETRY_MAX_MS = 160;
 
 export function liveSharePipePath(sessionId, sessionFilePath) {
-  return process.platform === 'win32' ? `\\\\.\\pipe\\mixdog-live-${sessionId}` : `${sessionFilePath}.live.sock`;
+  if (process.platform === 'win32') return `\\\\.\\pipe\\mixdog-live-${sessionId}`;
+  const beside = `${sessionFilePath}.live.sock`;
+  if (Buffer.byteLength(beside) <= UNIX_SOCKET_PATH_MAX_BYTES) return beside;
+  // Owner and viewer derive the same short name from the same session file.
+  // /tmp, not os.tmpdir(): TMPDIR is itself long on macOS and may differ
+  // between the desktop daemon and a terminal, which would split the pair.
+  const digest = createHash('sha256').update(beside).digest('hex').slice(0, 24);
+  return join('/tmp', `mixdog-live-${process.getuid()}-${digest}.sock`);
 }
 
 export function createLiveShare({

package/src/tui/session/notification-plan.mjs

@@ -89,6 +89,10 @@ export function resolveTuiRuntimeNotificationDelivery(event, text) {
   if (meta.kind === 'setup-ui') {
     return meta.id ? { action: 'setup-ui', id: String(meta.id) } : { action: 'ignore' };
   }
+  if (meta.kind === 'setup-changed') {
+    const setupAction = String(meta.action || '').trim();
+    return setupAction ? { action: 'setup-changed', setupAction } : { action: 'ignore' };
+  }
   if (meta.kind === 'ui-open') {
     const command = String(meta.command || '')
       .trim()

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

@@ -159,6 +159,18 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
       pushNotice(`provider api key saved: ${result.provider}`, 'info');
       return true;
     },
+    saveCustomProvider: announced(
+      (input) => runtime.saveCustomProvider(input),
+      (result) => `custom provider saved: ${result.id}`
+    ),
+    removeCustomProvider: async (id) => {
+      const result = await runtime.removeCustomProvider(id);
+      refreshRouteStats();
+      pushNotice(`custom provider removed: ${result.provider}`, 'info');
+      return result;
+    },
+    testCustomProvider: (input) => runtime.testCustomProvider(input),
+    discoverCustomProviderModels: (input) => runtime.discoverCustomProviderModels(input),
     saveOpenCodeGoUsageAuth: (opts) => {
       runtime.saveOpenCodeGoUsageAuth(opts);
       pushNotice('OpenCode Go usage auth saved', 'info');