mixdog 1.0.8 → 1.0.10

package/src/runtime/shared/plugin-paths.mjs

@@ -10,7 +10,14 @@ import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-const DEFAULT_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+// Resolved on first use, not at load: the desktop service bundle (CJS) carries
+// this module through the model catalog, and import.meta is empty there, so
+// computing it at load crashed the whole bundle before any caller needed it.
+let defaultRoot = null;
+function packagedRoot() {
+  defaultRoot ??= join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+  return defaultRoot;
+}
 
 // The defaults are joins over values that almost never change; they are hot
 // (every session path resolves the data dir), so each default join is reused
@@ -32,7 +39,7 @@ export function mixdogHome() {
 }
 
 export function mixdogRoot() {
-  return process.env.MIXDOG_ROOT || DEFAULT_ROOT;
+  return process.env.MIXDOG_ROOT || packagedRoot();
 }
 
 export function resolvePluginData() {

package/src/runtime/shared/worker-exec-argv.mjs

@@ -0,0 +1,25 @@
+// The parent's flags a worker thread may inherit. A worker rejects any flag that
+// governs the process itself (heap sizes, inspector, TLS, test-runner settings)
+// with ERR_WORKER_INVALID_EXEC_ARGV, and Node 24's test runner hands a child its
+// whole option table in execArgv (--use-system-ca, --tls-cipher-list, ...), so a
+// list of known-bad flags kept failing. Only what loads and resolves modules,
+// and what governs warnings, carries over.
+const INHERITED_FLAG =
+  /^--(?:import|require|loader|experimental-loader|conditions|enable-source-maps|preserve-symlinks(?:-main)?|no-warnings|disable-warning|trace-warnings|no-deprecation|(?:no-)?experimental-[a-z0-9-]+)(?:=|$)/;
+const SHORT_WITH_VALUE = new Set(['-r', '-C']);
+
+export function workerExecArgv(execArgv = process.execArgv) {
+  const source = Array.isArray(execArgv) ? execArgv.map(String) : [];
+  const kept = [];
+  for (let index = 0; index < source.length; index += 1) {
+    const argument = source[index];
+    const short = SHORT_WITH_VALUE.has(argument);
+    if (!short && !INHERITED_FLAG.test(argument)) continue;
+    kept.push(argument);
+    // A flag written apart from its value (`--import tsx`) keeps the value too.
+    const takesValue =
+      short || /^--(?:import|require|loader|experimental-loader|conditions|disable-warning)$/.test(argument);
+    if (takesValue && index + 1 < source.length) kept.push(source[++index]);
+  }
+  return kept;
+}

package/src/runtime/web-search/lib/formatter.mjs

@@ -2,6 +2,16 @@
  * Response formatter — strips metadata, returns human-readable text.
  */
 
+// Whether `text` names exactly this URL: an occurrence that runs on into a
+// longer URL (`…/docs` inside `…/docs/guide`) is a different page.
+function textCitesUrl(text, url) {
+  for (let at = text.indexOf(url); at !== -1; at = text.indexOf(url, at + 1)) {
+    const rest = text.slice(at + url.length, at + url.length + 2);
+    if (!/^(?:[A-Za-z0-9/?#&=%_~-]|\.[A-Za-z0-9])/.test(rest)) return true;
+  }
+  return false;
+}
+
 function formatWebSearchResults(data) {
   // data may be the full jsonText payload: { tool, providers, response, cache, ... }
   const response = data.response || data;
@@ -20,25 +30,40 @@ function formatWebSearchResults(data) {
   const SNIPPET_CAP = 600;
   const ANSWER_CAP = 4000;
   const clip = (text, cap) => (text.length > cap ? `${text.slice(0, cap)}…` : text);
-  if (answer) blocks.push(clip(answer, ANSWER_CAP));
+  const shownAnswer = answer ? clip(answer, ANSWER_CAP) : '';
+  if (shownAnswer) blocks.push(shownAnswer);
   if (!results.length) return blocks.join('\n\n');
-  blocks.push(
-    results
-      .map((r, i) => {
-        const num = i + 1;
-        const title = clip(r.title || '(no title)', TITLE_CAP);
-        const url = r.url || '';
-        const date = r.publishedDate || '';
-        const snippet = clip((r.snippet || '').trim(), SNIPPET_CAP);
-
-        const urlPart = [url, date].filter(Boolean).join(' — ');
-        const lines = [`${num}. ${title}`];
-        if (urlPart) lines.push(`   ${urlPart}`);
-        if (snippet && snippet !== title && snippet !== url) lines.push(`   ${snippet}`);
-        return lines.join('\n');
-      })
-      .join('\n\n')
-  );
+  // A native search route reports the pages a query reached without their
+  // titles, and the adapters label each one with that query. A label shared by
+  // several URLs names the search, not a page, so such a source prints as its
+  // URL alone — and not at all when the answer above already cites that URL.
+  // Measured on stored results: every source had this shape and 66% of their
+  // URLs were already in the answer.
+  const urlsByTitle = new Map();
+  for (const r of results) {
+    if (!r.title || !r.url) continue;
+    if (!urlsByTitle.has(r.title)) urlsByTitle.set(r.title, new Set());
+    urlsByTitle.get(r.title).add(r.url);
+  }
+  const entries = [];
+  for (const r of results) {
+    const url = r.url || '';
+    const date = r.publishedDate || '';
+    const snippet = clip((r.snippet || '').trim(), SNIPPET_CAP);
+    const urlPart = [url, date].filter(Boolean).join(' — ');
+    const queryLabelled =
+      !r.title || r.title === url || r.source === 'web_search_call' || urlsByTitle.get(r.title)?.size > 1;
+    if (url && !snippet && queryLabelled) {
+      if (!textCitesUrl(shownAnswer, url)) entries.push(`${entries.length + 1}. ${urlPart}`);
+      continue;
+    }
+    const title = clip(r.title || '(no title)', TITLE_CAP);
+    const lines = [`${entries.length + 1}. ${title}`];
+    if (urlPart) lines.push(`   ${urlPart}`);
+    if (snippet && snippet !== title && snippet !== url) lines.push(`   ${snippet}`);
+    entries.push(lines.join('\n'));
+  }
+  if (entries.length) blocks.push(entries.join('\n\n'));
   return blocks.join('\n\n');
 }
 

package/src/session-runtime/automation-agents.mjs

@@ -0,0 +1,88 @@
+/**
+ * Agent delegation for automation sessions (schedules, webhooks). They run
+ * headless in the daemon, so no session runtime registers tools for them or
+ * receives their agents' completions. The daemon's canonical agent control is
+ * exposed under a dedicated internal-tool scope instead, and the completions of
+ * the agents a run starts come back here, where the run turns them into the
+ * conversation's next turn — what a Lead in a window does when one arrives.
+ */
+import { setInternalToolsProvider } from '../runtime/agent/orchestrator/internal-tools.mjs';
+import { AGENT_TOOL } from './services/agent-tool/tool-def.mjs';
+
+export const AUTOMATION_TOOL_SCOPE = 'automation';
+// How long a run waits for the next result of an agent it started; past it the
+// run ends with the conversation as it stands.
+const AGENT_RESULT_WAIT_MS = 60 * 60_000;
+
+const runs = new Map(); // sessionId → { pending: Set<taskId>, ready: string[], wake }
+
+function resultText(result) {
+  return typeof result === 'string' ? result : JSON.stringify(result ?? '');
+}
+
+/** Registers the agent tool for automation sessions; returns its disposer. */
+export function registerAutomationAgentTool(executeAgentControl) {
+  return setInternalToolsProvider({
+    scopeId: AUTOMATION_TOOL_SCOPE,
+    tools: [AGENT_TOOL],
+    async executor(_name, args, callerCtx = {}) {
+      const result = await executeAgentControl(args, {
+        callerCwd: callerCtx.callerCwd,
+        invocationSource: 'model-tool',
+        callerSessionId: callerCtx.callerSessionId || null,
+        clientHostPid: process.pid,
+        signal: callerCtx.signal,
+      });
+      // A spawn/send acknowledgement ("agent task: <id>", "status: running")
+      // is a result still to come for this run.
+      const text = resultText(result);
+      const taskId = /agent task: ([\w.:-]+)/.exec(text)?.[1];
+      const run = runs.get(String(callerCtx.callerSessionId || ''));
+      if (run && taskId && /status: running/.test(text)) run.pending.add(taskId);
+      return result;
+    },
+  });
+}
+
+/** Hands an agent completion to the automation run that started the task; false when none did. */
+export function deliverAutomationCompletion(sessionId, text, meta = {}) {
+  const run = runs.get(String(sessionId || ''));
+  const taskId = String(meta?.execution_id || '');
+  if (!run?.pending.has(taskId)) return false;
+  // The header-only preview precedes the body-carrying completion.
+  if (meta?.model_visible === false) return true;
+  run.pending.delete(taskId);
+  run.ready.push(String(text || ''));
+  run.wake?.();
+  return true;
+}
+
+/**
+ * Runs an automation conversation to its end: the first turn, then one more
+ * turn per batch of agent results while agents it started are still out.
+ * Resolves with the last turn's result.
+ */
+export async function runAutomationTurns(sessionId, firstTurn, nextTurn, { waitMs = AGENT_RESULT_WAIT_MS } = {}) {
+  const run = { pending: new Set(), ready: [], wake: null };
+  runs.set(sessionId, run);
+  try {
+    let result = await firstTurn();
+    while (run.pending.size > 0 || run.ready.length > 0) {
+      if (run.ready.length === 0) {
+        const arrived = await new Promise((resolve) => {
+          const timer = setTimeout(() => resolve(false), waitMs);
+          run.wake = () => {
+            clearTimeout(timer);
+            resolve(true);
+          };
+        });
+        run.wake = null;
+        if (!arrived) break;
+      }
+      result = await nextTurn(run.ready.splice(0).join('\n\n'));
+    }
+    return result;
+  } finally {
+    runs.delete(sessionId);
+  }
+}

package/src/session-runtime/automation-workflow.mjs

@@ -10,6 +10,9 @@ import { createWorkflowHelpers } from '../runtime/agent/orchestrator/runtime-cor
 import { STANDALONE_ROOT, STANDALONE_DATA_DIR } from './runtime-paths.mjs';
 import { readMarkdownDocument, normalizeAgentPermissionOrNone } from '../runtime/shared/markdown-frontmatter.mjs';
 import { IMPLICIT_APPROVAL_MODE } from '../runtime/agent/orchestrator/session/approval-mode.mjs';
+import { loadConfig } from '../runtime/agent/orchestrator/config.mjs';
+import { configuredOrchestrationMode } from '../runtime/shared/orchestration.mjs';
+import { AUTOMATION_TOOL_SCOPE } from './automation-agents.mjs';
 
 let _helpers = null;
 function helpers() {
@@ -26,21 +29,31 @@ function helpers() {
 
 /** Non-interactive createSession opts, plus workflow context when the id resolves. */
 export function automationWorkflowOpts(workflowId) {
-  const approvalOpts = { approvalMode: IMPLICIT_APPROVAL_MODE };
+  const config = loadConfig({ secrets: false });
+  // The user's orchestration setting governs an automation exactly as it does a
+  // New task: a workflow id alone never turns delegation on, and the agent
+  // tool reaches the run through the automation tool scope.
+  const baseOpts = {
+    approvalMode: IMPLICIT_APPROVAL_MODE,
+    orchestrationMode: configuredOrchestrationMode(config),
+    mcpScopeId: AUTOMATION_TOOL_SCOPE,
+  };
   const id = String(workflowId || '').trim();
-  if (!id) return approvalOpts;
+  if (!id) return baseOpts;
   try {
     const h = helpers();
     const pack = h.loadWorkflowPack(undefined, id);
-    if (!pack) return approvalOpts;
-    const resolved = h.activeWorkflowContext({ workflow: { active: id } }, undefined);
+    if (!pack) return baseOpts;
+    // The whole config, so disabled agents and the orchestration mode are the
+    // user's, with only the active workflow swapped for the automation's own.
+    const resolved = h.activeWorkflowContext({ ...config, workflow: { ...config.workflow, active: id } }, undefined);
     return {
-      ...approvalOpts,
+      ...baseOpts,
       workflow: resolved.summary,
       workflowContext: resolved.context,
       orchestrationMode: resolved.orchestrationMode,
     };
   } catch {
-    return approvalOpts;
+    return baseOpts;
   }
 }

package/src/session-runtime/boot/apis.mjs

@@ -107,7 +107,6 @@ function wireToolPolicyRefresh(boot) {
     getDataDir: () => dataDirOf(cfgMod),
     modelStandaloneTools: boot.modelStandaloneTools,
     featureDisallowedTools: boot.featureDisallowedTools,
-    memoryToolsEnabled: boot.memoryToolsEnabledFn,
     loadCoreMemoryContext: boot.loadCoreMemoryContext,
     activeWorkflowContext: workflowHelpers.activeWorkflowContext,
     invalidatePreSessionToolSurface: boot.invalidatePreSessionToolSurface,
@@ -274,6 +273,12 @@ function providerAuthApiFor(boot) {
     getUsageDashboard: boot.getUsageDashboard,
     consumeCodexRateLimitResetCredit: boot.consumeCodexRateLimitResetCredit,
     collectProviderModels: boot.collectProviderModels,
+    // A deleted custom provider must not stay reachable through the live route
+    // or the registry; stored routes naming it are filtered by the picker.
+    onCustomProviderRemoved: (id) => {
+      reg.disableProvider?.(id);
+      if (rt.route?.provider === id) rt.route = { ...rt.route, provider: '', model: '', preset: null };
+    },
   });
 }
 

package/src/session-runtime/cwd-plugins/core-memory-context.mjs

@@ -1,9 +1,14 @@
 // cwd-plugins/core-memory-context.mjs — the user-curated core-memory block
 // injected into new sessions, read from the memory runtime's atomic snapshot.
-import { featureEnvOverride, memoryToolsEnabled } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
+import { featureEnvOverride } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { readSessionCoreMemoryPayload } from '../../runtime/memory/lib/core-memory-file.mjs';
 
-export function createCoreMemoryContext({ getCurrentCwd, getConfig, bootProfile, clean, cfgMod, STANDALONE_DATA_DIR }) {
+// Budget for the whole injected block in UTF-8 bytes: bytes track token cost
+// more evenly across scripts than characters do.
+const CORE_MEMORY_MAX_BYTES = 32 * 1024;
+const TRUNCATED_MARK = '\n- ...';
+
+export function createCoreMemoryContext({ getCurrentCwd, bootProfile, clean, cfgMod, STANDALONE_DATA_DIR }) {
   function formatCoreMemoryLines(payload = {}) {
     const seen = new Set();
     const lines = [];
@@ -14,21 +19,18 @@ export function createCoreMemoryContext({ getCurrentCwd, getConfig, bootProfile,
       if (seen.has(key)) continue;
       seen.add(key);
       lines.push(`- ${text}`);
-      if (lines.length >= 40) break;
     }
     const out = lines.join('\n');
-    const maxChars = 6000;
-    return out.length > maxChars ? `${out.slice(0, maxChars).replace(/\s+\S*$/, '')}\n- ...` : out;
+    if (Buffer.byteLength(out, 'utf8') <= CORE_MEMORY_MAX_BYTES) return out;
+    const budget = CORE_MEMORY_MAX_BYTES - Buffer.byteLength(TRUNCATED_MARK, 'utf8');
+    // A byte cut can split a multi-byte character; drop its replacement chars.
+    const head = Buffer.from(out, 'utf8').subarray(0, budget).toString('utf8').replace(/\uFFFD+$/, '');
+    return `${head.replace(/\s+\S*$/, '')}${TRUNCATED_MARK}`;
   }
 
   async function loadCoreMemoryContext() {
-    // User-curated core memory injects into new sessions by default. The
-    // Memory toggle (settings → General) OFF skips ONLY this accumulated
-    // core-memory block — the profile injects regardless.
-    if (!(featureEnvOverride('MIXDOG_FEATURE_MEMORY') ?? memoryToolsEnabled(getConfig(), true))) {
-      bootProfile('core-memory:disabled');
-      return '';
-    }
+    // User-curated core memory always injects into new sessions: the Memory
+    // install marker and toggle gate only the model-facing memory/recall tools.
     // Explicit opt-out (MIXDOG_BOOT_CORE_MEMORY=0/false/no/off) skips this
     // file-backed prompt block. Recall and memory tools remain available.
     if (featureEnvOverride('MIXDOG_BOOT_CORE_MEMORY') === false) {

package/src/session-runtime/internal-tool-executor/bridge-tools.mjs

@@ -1,41 +1,22 @@
-// Browser Use and Computer Use: the environment kill switch, the once-per-
-// session first-use approval, then the bridge client.
+// Browser Use and Computer Use: the environment kill switch, then the bridge
+// client. Neither asks the user before a call.
 import { executeBrowserTool } from '../../runtime/browser-bridge/client.mjs';
 import { executeComputerTool } from '../../runtime/computer-bridge/client.mjs';
-import { createBridgeFirstUseGate } from '../bridge-first-use-gate.mjs';
 import { featureEnvOverride } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { createCallerContextResolvers } from './caller-context.mjs';
 
 export function createBridgeToolHandlers({ rt }) {
-  const bridgeFirstUseGate = createBridgeFirstUseGate({ getConfig: () => rt.config });
   const { sessionIdFor, signalFor } = createCallerContextResolvers(rt);
 
-  // Browser Use and Computer Use ask the user once per session before their
-  // first live call; the answer is the tool result when it is no.
-  const firstUseDenial = async (name, args, callerCtx, callerCwd) => {
-    const denial = await bridgeFirstUseGate({
-      name,
-      args,
-      cwd: callerCwd,
-      sessionId: sessionIdFor(callerCtx),
-      toolCallId: callerCtx?.toolCallId || null,
-      toolApprovalHook: callerCtx?.toolApprovalHook,
-      invocationSource: callerCtx?.invocationSource,
-    });
-    return denial ? { content: [{ type: 'text', text: denial }], isError: true } : null;
-  };
-
   const environmentDisabled = (callerCtx, feature) =>
     callerCtx?.invocationSource === 'model-tool' && featureEnvOverride(feature) === false;
 
   // `browser` and `browser_devtools` are one bridge; the tool name only
   // scopes which actions the validator admits.
-  const browser = async (args, { name, callerCtx, callerCwd }) => {
+  const browser = async (args, { name, callerCtx }) => {
     if (environmentDisabled(callerCtx, 'MIXDOG_FEATURE_BROWSER')) {
       throw new Error('the browser tool is disabled in this environment');
     }
-    const denied = await firstUseDenial(name, args, callerCtx, callerCwd);
-    if (denied) return denied;
     return await executeBrowserTool(args, {
       tool: name,
       sessionId: sessionIdFor(callerCtx),
@@ -44,12 +25,10 @@ export function createBridgeToolHandlers({ rt }) {
     });
   };
 
-  const computer = async (args, { name, callerCtx, callerCwd }) => {
+  const computer = async (args, { callerCtx, callerCwd }) => {
     if (environmentDisabled(callerCtx, 'MIXDOG_FEATURE_COMPUTER')) {
       throw new Error('the computer tool is disabled in this environment');
     }
-    const denied = await firstUseDenial(name, args, callerCtx, callerCwd);
-    if (denied) return denied;
     return await executeComputerTool(args, {
       sessionId: sessionIdFor(callerCtx),
       cwd: callerCwd,

package/src/session-runtime/model-recency.mjs

@@ -2,6 +2,7 @@
 // construction. Pure except for the
 // injected route provider (for sort priority) and webSearchCapableFor predicate.
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { contextWindowRange } from '../runtime/shared/llm/default-context-window.mjs';
 
 function parsedProviderModelVersion(id) {
   const text = clean(id).toLowerCase();
@@ -106,14 +107,21 @@ export function isSelectableLlmModel(model) {
 }
 
 export function providerModelCacheRow(name, m, webSearchCapableFor) {
+  // The pickers read the default window and the slider's range straight off
+  // this row, so a default lowered by range has to be stated here.
+  const range = contextWindowRange({
+    provider: name,
+    contextWindow: m.contextWindow,
+    maxContextWindow: m.maxContextWindow,
+  });
   return {
     id: m.id,
     provider: name,
     display: m.display || m.name || m.id,
     created: typeof m.created === 'number' ? m.created : null,
     releaseDate: m.releaseDate || null,
-    contextWindow: m.contextWindow,
-    maxContextWindow: m.maxContextWindow || null,
+    contextWindow: range.defaultWindow || m.contextWindow,
+    maxContextWindow: range.maxWindow > range.defaultWindow ? range.maxWindow : m.maxContextWindow || null,
     outputTokens: m.outputTokens || null,
     family: m.family || null,
     tier: m.tier || null,

package/src/session-runtime/model-route/set-route.mjs

@@ -13,6 +13,7 @@ import {
 } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { getModelMetadataSync } from '../../runtime/agent/orchestrator/providers/model-catalog.mjs';
 import { workflowPresetId } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
+import { resolveRouteContextState } from '../route-state.mjs';
 import { writeStatuslineRoute } from '../statusline-route.mjs';
 import { sessionHasRouteHistory, shouldRecreateEmptySessionForRouteChange } from '../../runtime/agent/orchestrator/runtime-core/session-route-policy.mjs';
 import { rebuildDeferredToolSurfaceForProvider } from '../../runtime/agent/orchestrator/runtime-core/tool-catalog.mjs';
@@ -52,7 +53,12 @@ async function resolveSelectedRoute(deps, next) {
     selectedRoute.modelParameters
   );
   return {
-    selectedRoute: { ...selectedRoute, fast: fastCapable ? selectedRoute.fast === true : false },
+    selectedRoute: {
+      ...selectedRoute,
+      fast: fastCapable ? selectedRoute.fast === true : false,
+      // Lets the saved model settings tell a chosen window from the default.
+      contextDefaultPercent: resolveRouteContextState(selectedRoute, modelMeta).contextDefaultPercent,
+    },
     fastCapable,
     modelMeta,
   };

package/src/session-runtime/provider-auth/login.mjs

@@ -8,9 +8,13 @@ import {
   saveOpenAIUsageSessionKey,
   saveOpenCodeGoUsageAuth,
   saveProviderApiKey,
+  saveCustomProvider,
+  removeCustomProvider,
+  testCustomProvider,
+  discoverCustomProviderModels,
 } from '../services/provider-admin.mjs';
 
-export function createLoginApi({ cfgMod, awaitKeychainPrewarm, reloadFullConfig }, refresh) {
+export function createLoginApi({ cfgMod, awaitKeychainPrewarm, reloadFullConfig, onCustomProviderRemoved }, refresh) {
   async function completeOAuthLogin(login) {
     return {
       ...login,
@@ -69,6 +73,27 @@ export function createLoginApi({ cfgMod, awaitKeychainPrewarm, reloadFullConfig
       refresh.afterUsageAuthChange();
       return result;
     },
+    async saveCustomProvider(input) {
+      await awaitKeychainPrewarm();
+      const result = await saveCustomProvider(cfgMod, input);
+      refresh.afterCredentialChange();
+      return result;
+    },
+    async removeCustomProvider(providerId) {
+      await awaitKeychainPrewarm();
+      const result = removeCustomProvider(cfgMod, providerId);
+      onCustomProviderRemoved?.(result.provider);
+      refresh.afterCredentialChange();
+      return result;
+    },
+    async testCustomProvider(input) {
+      await awaitKeychainPrewarm();
+      return await testCustomProvider(cfgMod, input);
+    },
+    async discoverCustomProviderModels(input) {
+      await awaitKeychainPrewarm();
+      return await discoverCustomProviderModels(cfgMod, input);
+    },
     forgetProviderAuth(providerId, accountId) {
       const result = forgetProviderAuth(cfgMod, providerId, accountId);
       refresh.afterCredentialChange();

package/src/session-runtime/quick-model-rows/provider-rows.mjs

@@ -46,7 +46,7 @@ export function createQuickProviderRows({
     const addRoute = (routeLike = {}) => {
       const provider = clean(routeLike.provider);
       const model = clean(routeLike.model);
-      if (!provider || !model) return;
+      if (!provider || !model || isDeletedCustom(provider)) return;
       const meta = metadataFor(provider, model);
       addModel(provider, {
         id: model,
@@ -64,8 +64,23 @@ export function createQuickProviderRows({
       });
     };
 
-    for (const [provider, providerConfig] of Object.entries(pickerConfig.providers || {})) {
+    // A custom-* id with no live custom config entry was deleted: stale
+    // routes must not bring it back into the picker.
+    const customProviders = pickerConfig.providers || {};
+    const isDeletedCustom = (provider) =>
+      provider.startsWith('custom-') &&
+      !(customProviders[provider]?.type === 'custom' && customProviders[provider].enabled !== false);
+    for (const [provider, providerConfig] of Object.entries(customProviders)) {
       if (!providerConfig?.enabled) continue;
+      if (providerConfig.type === 'custom') {
+        // Configured models are listed at once, before any catalog refresh.
+        for (const model of providerConfig.models || []) {
+          addModel(provider, {
+            ...model,
+            outputTokens: model.maxOutputTokens || null,
+          });
+        }
+      }
       for (const model of providerCachedModelsSync(provider)) addModel(provider, model);
     }
     addRoute(route);

package/src/session-runtime/resource-api.mjs

@@ -8,7 +8,7 @@ import { createExtensionSync } from './resource-extension-sync.mjs';
 import { createScopeDecorators } from './resource-scope-decorate.mjs';
 import { createMcpResourceApi } from './resource-mcp-api.mjs';
 import { createSkillsResourceApi } from './resource-skills-api.mjs';
-import { createPluginsResourceApi } from './resource-plugins-api.mjs';
+import { createPluginsResourceApi, findRegisteredPlugin } from './resource-plugins-api.mjs';
 import { createRecallResourceApi } from './resource-recall-api.mjs';
 
 export function createResourceApi(deps) {
@@ -27,8 +27,14 @@ export function createResourceApi(deps) {
       if (!EXTENSION_SCOPE_KINDS.includes(scopeKind)) {
         throw new Error(`extension scope kind must be one of ${EXTENSION_SCOPE_KINDS.join(', ')}`);
       }
-      const key = clean(name);
+      let key = clean(name);
       if (!key) throw new Error('extension name is required');
+      // Plugin scopes are keyed by registry id; a name must resolve to it.
+      if (scopeKind === 'plugins') {
+        const plugin = findRegisteredPlugin(pluginsStatus, key);
+        if (!plugin) throw new Error(`plugin not registered: ${key}`);
+        key = clean(plugin.id || plugin.name);
+      }
       let list = [projects];
       if (Array.isArray(projects)) list = projects;
       else if (projects == null) list = [];

package/src/session-runtime/resource-plugins-api.mjs

@@ -10,6 +10,15 @@ import { pluginMcpServerName, pluginServerMatcher } from '../runtime/agent/orche
 
 const pluginKey = (plugin) => clean(plugin.id || plugin.name || plugin);
 
+/** The registered status row a caller means by `plugin` (row, id, name, or
+ *  title), or null. Callers such as the setup tool pass only a name, while
+ *  MCP entry names and scope keys come from the registered record. */
+export function findRegisteredPlugin(pluginsStatus, plugin) {
+  const key = pluginKey(plugin);
+  if (!key) return null;
+  return (pluginsStatus()?.plugins || []).find((row) => [row.id, row.name, row.title].map(clean).includes(key)) || null;
+}
+
 export function createPluginsResourceApi({ deps, sync, decorate }) {
   const {
     getConfig,
@@ -52,8 +61,9 @@ export function createPluginsResourceApi({ deps, sync, decorate }) {
       return { plugin: updated, status: pluginsStatus() };
     },
     async setPluginEnabled(plugin = {}, enabled = true) {
+      const owner = findRegisteredPlugin(pluginsStatus, plugin) || plugin;
       const updated = registrySetPluginEnabled(pluginKey(plugin), enabled, { dataDir: pluginData() });
-      await rewritePluginServers(plugin, (servers, owned) => {
+      await rewritePluginServers(owner, (servers, owned) => {
         const next = {};
         for (const [name, value] of Object.entries(servers)) {
           const config = value && typeof value === 'object' && !Array.isArray(value) ? { ...value } : value;
@@ -69,8 +79,10 @@ export function createPluginsResourceApi({ deps, sync, decorate }) {
       return { plugin: updated, status: pluginsStatus() };
     },
     async removePlugin(plugin = {}) {
+      // Resolve before the registry forgets the plugin and its manifest name.
+      const owner = findRegisteredPlugin(pluginsStatus, plugin) || plugin;
       const removed = registryRemovePlugin(pluginKey(plugin), { dataDir: pluginData() });
-      await rewritePluginServers(plugin, (servers, owned) => {
+      await rewritePluginServers(owner, (servers, owned) => {
         const next = { ...servers };
         for (const name of Object.keys(next)) {
           if (owned(name)) delete next[name];

package/src/session-runtime/route-state.mjs

@@ -5,6 +5,7 @@ import { clean, hasOwn } from '../runtime/agent/orchestrator/runtime-core/sessio
 import { coerceEffortFor } from '../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import { fastCapableFor } from '../runtime/agent/orchestrator/runtime-core/model-capabilities.mjs';
 import { providerCachedModelMetadataSync } from '../runtime/agent/orchestrator/providers/provider-catalog-cache.mjs';
+import { contextWindowRange } from '../runtime/shared/llm/default-context-window.mjs';
 
 export function resolveRouteEffortState(targetRoute = {}, modelMeta = null) {
   const requested = hasOwn(targetRoute, 'effort') ? targetRoute.effort : targetRoute.preset?.effort || null;
@@ -49,8 +50,11 @@ export function resolveRouteContextState(targetRoute = {}, modelMeta = null, win
     Number(modelMeta?.contextWindow) > 0 || Number(modelMeta?.maxContextWindow) > 0
       ? modelMeta
       : windowLookup?.(clean(targetRoute?.provider), clean(targetRoute?.model)) || modelMeta;
-  const defaultWindow = Math.max(0, Number(windowMeta?.contextWindow) || 0);
-  const maxWindow = Math.max(defaultWindow, Number(windowMeta?.maxContextWindow) || 0);
+  const { defaultWindow, maxWindow } = contextWindowRange({
+    provider: clean(targetRoute?.provider),
+    contextWindow: windowMeta?.contextWindow,
+    maxContextWindow: windowMeta?.maxContextWindow,
+  });
   if (!maxWindow) {
     return { contextPercent: undefined, contextDefaultPercent: undefined, selectedContextWindow: undefined };
   }

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

@@ -11,6 +11,7 @@ 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';
 
 /** Resolve schedule.model into a {provider,model,effort?,fast?} route. */
@@ -58,6 +59,11 @@ export async function runScheduleSession(schedule, { config = null, prompt: prom
   // title/preview derive from it, so no "[Scheduled task: …]" header noise.
   // Stored attachments ride along as composer-style content parts.
   const content = automationPromptContent(prompt, schedule.attachments);
-  const result = await askSession(session.id, content, null, null, cwd || undefined);
+  // Agents the run delegates to report back; each result is the next turn.
+  const result = await runAutomationTurns(
+    session.id,
+    () => askSession(session.id, content, null, null, cwd || undefined),
+    (completions) => askSession(session.id, completions, null, null, cwd || undefined)
+  );
   return { sessionId: session.id, result: String(result?.content || '') };
 }