mixdog 0.9.43 → 0.9.45

package/src/rules/lead/lead-brief.md

@@ -8,12 +8,13 @@
   `Task:`. Never infer exactness from a task name, file count, or perceived
   difficulty.
 - All other fields are optional task-specific deltas: `Anchors:`
-  `Allow/Forbid:` `Deliver:` `Verify:`. Omit any that add no information.
+  `Allow/Forbid:` `Deliver:`. Omit any that add no information.
 - Anchors: `file:line` + one-line conclusion; never log/code bodies. Specify
   outcome, not method unless required. `Deliver:` gives shape/size, never a long
-  handoff. Referenced spec/test beats its summary.
-- Preserve the exact same `Task:` across Worker -> Debugger -> Reviewer. Never
-  summarize, rewrite, or replace it when handing the scope to the next role.
+  handoff. The original request and official spec/test acceptance criteria beat
+  their brief summary.
+- Each role independently constructs a role-appropriate, lossless `Task:` from
+  the original request and official spec/test acceptance criteria.
 - Full brief only for fresh spawn/`respawned: true`; live follow-ups are delta.
   Dead-tag send is cold: re-supply anchors.
 - Never `send` mid-run; batch one follow-up after completion; interrupt only to

package/src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs

@@ -24,6 +24,7 @@
 import { loadConfig } from '../config.mjs';
 import { resolveRuntimeSpec } from '../config.mjs';
 import { getHiddenAgent, resolveAgentSessionPermission } from '../internal-agents.mjs';
+import { isKnownProvider } from '../../../../standalone/provider-admin.mjs';
 import { prepareAgentSession } from './session-builder.mjs';
 import {
     askSession,
@@ -163,9 +164,30 @@ export function resolveHiddenRoleSchemaAllowedTools(hidden) {
  *     against config.presets for backward compatibility.
  *   - null — unresolved.
  *
- * Hidden roles read their slot from `maint[maintKey || slot]`; the cycle1/2/3
- * agents share one knob via the `maintKey: 'memory'` override.
+ * Explore and memory hidden roles mirror public spawning precedence:
+ * `agents.<role>` (including legacy `agents.maintenance`) → workflow route →
+ * maintenance route → Main. The cycle1/2/3 agents share the memory knob via
+ * their `maintKey: 'memory'` override. Scheduler and webhook are unchanged.
  */
+const DEFAULT_AGENT_ROUTE_PROVIDER = 'anthropic-oauth';
+
+function normalizeMaintenanceCandidate(candidate, config) {
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) return candidate || null;
+    const configuredProvider = String(config?.defaultProvider || '').trim();
+    const fallbackProvider = isKnownProvider(configuredProvider)
+        ? configuredProvider
+        : DEFAULT_AGENT_ROUTE_PROVIDER;
+    const provider = String(candidate.provider || fallbackProvider).trim();
+    const model = String(candidate.model || '').trim();
+    if (!provider || !model) return null;
+    return {
+        provider,
+        model,
+        effort: String(candidate.effort || '').trim() || undefined,
+        fast: candidate.fast === true,
+    };
+}
+
 export function resolveMaintenanceRoute({ preset, optsPreset, agent, config: cfgIn = null }) {
     if (preset) return preset;
     if (optsPreset) return optsPreset;
@@ -175,7 +197,22 @@ export function resolveMaintenanceRoute({ preset, optsPreset, agent, config: cfg
         try {
             const config = cfgIn || loadConfig({ secrets: false });
             const maint = config?.maintenance || {};
-            return maint[hidden.maintKey || hidden.slot] ?? null;
+            const key = hidden.maintKey || hidden.slot;
+            const role = key === 'explore' ? 'explore' : (key === 'memory' ? 'maintainer' : '');
+            const workflowSlot = key === 'explore' ? 'explorer' : (key === 'memory' ? 'memory' : '');
+            if (!role) return maint[key] ?? null;
+            const candidates = [
+                role ? config?.agents?.[role] : null,
+                key === 'memory' ? config?.agents?.maintenance : null,
+                workflowSlot ? config?.workflowRoutes?.[workflowSlot] : null,
+                maint[key],
+                role ? config?.default : null,
+            ];
+            for (const candidate of candidates) {
+                const route = normalizeMaintenanceCandidate(candidate, config);
+                if (route) return route;
+            }
+            return null;
         } catch { return null; }
     }
     return null;

package/src/runtime/agent/orchestrator/config.mjs

@@ -7,6 +7,20 @@ import {
     hasGrokOAuthCredentials,
 } from './providers/oauth-credential-probes.mjs';
 
+// Keep config loading free of standalone provider-admin and its provider
+// runtimes. These identifiers mirror that module's static catalog, assembled
+// solely from the lightweight config/provider constants already imported here.
+const CONFIG_PROVIDER_IDS = new Set([
+    ...Object.keys(AGENT_PROVIDER_ENV),
+    ...Object.keys(OPENAI_COMPAT_PRESETS),
+    'openai-oauth',
+    'anthropic-oauth',
+    'grok-oauth',
+]);
+function isConfiguredProviderId(provider) {
+    return CONFIG_PROVIDER_IDS.has(String(provider || '').trim());
+}
+
 // Thin wrapper around resolvePluginData so callers in this orchestrator tree
 // can import a single helper without reaching into shared/.
 export function getPluginData() {
@@ -18,15 +32,12 @@ export function getPluginData() {
 // Canonical maintenance defaults. Single source of truth — imported by
 // llm/index.mjs and setup-server.mjs so UI/runtime cannot drift from config.
 //
-// Every hidden maintenance slot carries a CONCRETE preset here, so
-// resolvePresetName() (agent-dispatch) always resolves a model directly from
-// `maint[slot]` — no shared `defaultPreset` fallback is needed or used.
-// Memory cycles + Lead helper fan-out (explore/cycle1/cycle2/cycle3) and
-// entry-driven dispatch (scheduler/webhook) all default to `haiku`. The three
-// memory cycles (chunker / re-scorer / core reviewer) share ONE `memory`
-// preset knob — the cycle agents stay separate (cycle1/2/3-agent, distinct
-// slots and invokedBy) but resolve their model from `maint.memory` via the
-// `maintKey` override on their hidden-role entries.
+// Explore and Maintainer start without a route so they dynamically inherit the
+// Main route. Explicit `maintenance.explore` / `maintenance.memory` choices
+// remain supported. The memory cycles (chunker / re-scorer / core reviewer)
+// share the optional `memory` preset knob — the cycle agents stay separate
+// (cycle1/2/3-agent, distinct slots and invokedBy) but resolve their model from
+// `maint.memory` via the `maintKey` override on their hidden-role entries.
 // scheduler/webhook still let a per-entry config.json model win first (the
 // caller passes it explicitly via opts.preset); the haiku default below only
 // applies when an entry omits its own model.
@@ -129,8 +140,6 @@ const _HAIKU_ROUTE = Object.freeze({
     model: resolveAnthropicFamilyModel('haiku'),
 });
 export const DEFAULT_MAINTENANCE = Object.freeze({
-    explore: { ..._HAIKU_ROUTE },
-    memory: { ..._HAIKU_ROUTE },
     scheduler: { ..._HAIKU_ROUTE },
     webhook: { ..._HAIKU_ROUTE },
 });
@@ -201,12 +210,18 @@ function normalizeSearchRoute(route) {
 // is resolved against the config.presets array (the legacy lookup) and rewritten
 // to a route. Unresolvable strings are dropped so the DEFAULT_MAINTENANCE route
 // fills the slot. `presets` is the normalized preset array for legacy lookup.
-function migrateMaintenanceRoutes(rawMaint, presets) {
+function migrateMaintenanceRoutes(rawMaint, presets, defaultProvider) {
     const out = {};
     const list = Array.isArray(presets) ? presets : [];
+    const configuredProvider = String(defaultProvider || '').trim();
+    const fallbackProvider = isConfiguredProviderId(configuredProvider)
+        ? configuredProvider
+        : 'anthropic-oauth';
     for (const [slot, value] of Object.entries(rawMaint || {})) {
         if (value && typeof value === 'object' && !Array.isArray(value)) {
-            const provider = normalizeAgentProviderId(value.provider);
+            const provider = normalizeAgentProviderId(
+                value.provider || ((slot === 'explore' || slot === 'memory') ? fallbackProvider : ''),
+            );
             const model = String(value.model || '').trim();
             if (provider && model) {
                 const route = { provider, model };
@@ -437,7 +452,7 @@ export function loadConfig(options = {}) {
             delete workflowRoutes.search;
             // Migrate legacy preset-name maintenance slots to direct routes,
             // then overlay onto the route-shaped defaults.
-            const migratedMaint = migrateMaintenanceRoutes(rawMaint, normalizedPresets);
+            const migratedMaint = migrateMaintenanceRoutes(rawMaint, normalizedPresets, raw.defaultProvider);
             return {
                 providers: mergedProviders,
                 mcpServers,

package/src/runtime/agent/orchestrator/providers/grok-oauth.mjs

@@ -22,7 +22,7 @@ import { randomBytes, createHash } from 'crypto';
 import { readFileSync, existsSync, mkdirSync, statSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { getPluginData } from '../config.mjs';
-import { writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
+import { writeJsonAtomicSync, withFileLock } from '../../../shared/atomic-file.mjs';
 import { enrichModels, getModelMetadataSync } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { makeModelCache } from './model-cache.mjs';
@@ -180,6 +180,10 @@ function getOwnTokenPath() {
     return join(dir, 'grok-oauth.json');
 }
 
+function getRefreshLockPath() {
+    return `${getOwnTokenPath()}.refresh.lock`;
+}
+
 // expires_at may arrive as a unix number or an ISO-8601 string. Normalize both
 // to epoch milliseconds; 0 means unknown.
 function _normalizeExpiresAt(value) {
@@ -369,32 +373,53 @@ async function _postRefresh(tokens) {
     }
 }
 
-// 16 mixdog processes share one grok-oauth.json and xAI rotates refresh
-// tokens single-use. Re-read the store immediately before the network POST so
-// a peer's just-completed rotation is adopted instead of spending our
-// (now-stale) refresh_token; on invalid_grant, re-read once and retry with a
-// peer-rotated refresh_token before propagating.
+// Mixdog processes share one grok-oauth.json and xAI rotates refresh tokens
+// single-use. Hold a cross-process lease across the re-read, exchange, and
+// atomic save so only one process can spend a generation.
 async function refreshTokens(tokens, { force = false } = {}) {
     if (!tokens?.refresh_token) {
         throw new Error('[grok-oauth] refresh token not available — open /providers in mixdog to sign in again');
     }
-    const disk = _loadOwnTokens();
-    const validAfter = Date.now() + (force ? 0 : TOKEN_REFRESH_SKEW_MS);
-    if (disk?.access_token && disk.access_token !== tokens.access_token
-        && (!disk.expires_at || disk.expires_at >= validAfter)) {
-        return disk;
-    }
-    try {
-        return await _postRefresh(tokens);
-    } catch (err) {
-        if (err?.isInvalidGrant) {
-            const rotated = _loadOwnTokens();
-            if (rotated?.refresh_token && rotated.refresh_token !== tokens.refresh_token) {
-                return await _postRefresh(rotated);
+
+    return withFileLock(getRefreshLockPath(), async () => {
+        const validAfter = Date.now() + (force ? 0 : TOKEN_REFRESH_SKEW_MS);
+        const disk = _loadOwnTokens();
+        // A waiter that entered with the prior generation adopts the winner's
+        // persisted, valid token instead of rotating it again. xAI may rotate
+        // only the refresh token while reissuing the same access token.
+        const diskGenerationChanged = disk?.access_token
+            && (disk.access_token !== tokens.access_token
+                || disk.refresh_token !== tokens.refresh_token);
+        if (diskGenerationChanged
+            && (!disk.expires_at || disk.expires_at >= validAfter)) {
+            return disk;
+        }
+
+        const current = disk || tokens;
+        try {
+            return await _postRefresh(current);
+        } catch (err) {
+            if (err?.isInvalidGrant) {
+                // A writer that does not participate in this lease may still
+                // have won the rotation while the request was in flight.
+                // Adopt its valid generation; only exchange it when it cannot
+                // satisfy this caller.
+                const rotated = _loadOwnTokens();
+                if (rotated?.refresh_token && rotated.refresh_token !== current.refresh_token) {
+                    if (rotated.access_token
+                        && (!rotated.expires_at || rotated.expires_at >= validAfter)) {
+                        return rotated;
+                    }
+                    return await _postRefresh(rotated);
+                }
             }
+            throw err;
         }
-        throw err;
-    }
+    }, {
+        timeoutMs: 120_000,
+        staleMs: 120_000,
+        secret: true,
+    });
 }
 
 // --- Model catalog cache (24h disk TTL) ---

package/src/runtime/agent/orchestrator/providers/retry-classifier.mjs

@@ -325,7 +325,11 @@ function _classifyMidstreamWs(err, state, attemptIndex, policy) {
   }
   if (!state.sawResponseCreated) {
     const closeCode = Number(err?.wsCloseCode || state.wsCloseCode || 0)
-    if (closeCode !== 1011 && closeCode !== 1012) return null
+    // An abnormal close before response.created has not produced any response
+    // bytes to the caller. It is therefore safe to reconnect and replay under
+    // the normal ws_1006 bounded retry policy (text/tool emission was denied
+    // above before reaching this gate).
+    if (closeCode !== 1006 && closeCode !== 1011 && closeCode !== 1012) return null
   }
   if (state.userAbort) return null
 

package/src/runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs

@@ -985,10 +985,12 @@ function startBackgroundPowerShellJob({ command, timeoutMs, workDir, mergeStderr
         // the execution policy on Windows PowerShell; pwsh on macOS/Linux
         // accepts the parameter as a no-op, so it is safe unconditionally.
         "    $argList = @('-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', $innerPath)",
-        // -WindowStyle is a Windows-only Start-Process parameter; pwsh on
-        // macOS/Linux throws "not supported on this platform". Add it only on win32.
+        // Do not set WindowStyle: Hidden creates a separate transient conhost.
+        // On Windows, explicitly reuse the wrapper's CREATE_NO_WINDOW console.
+        // NoNewWindow is unavailable on non-Windows pwsh, so only add it for
+        // Windows (where $IsWindows is absent/null in Windows PowerShell 5.1).
         '    $spArgs = @{ FilePath = $exe; ArgumentList = $argList; RedirectStandardOutput = $stdoutPath; RedirectStandardError = $stderrPath; PassThru = $true }',
-        '    if ($IsWindows -or $null -eq $IsWindows) { $spArgs[\'WindowStyle\'] = \'Hidden\' }',
+        '    if ($IsWindows -or $null -eq $IsWindows) { $spArgs[\'NoNewWindow\'] = $true }',
         '    $p = Start-Process @spArgs',
         '    if ($timeoutMs -gt 0 -and -not $p.WaitForExit($timeoutMs)) {',
         // Kill the whole process TREE, not just the direct child: Start-Process
@@ -1039,8 +1041,8 @@ function startBackgroundPowerShellJob({ command, timeoutMs, workDir, mergeStderr
     // No `-WindowStyle Hidden` CLI switch: windowsHide:true on the spawn below
     // already gives CREATE_NO_WINDOW, and the visible command-line token trips
     // Defender's hidden-PowerShell dropper signature (PowhidSubExec). The
-    // in-wrapper Start-Process WindowStyle=Hidden (above) stays — it lives in
-    // the staged .ps1, not on the command line, and is still needed there.
+    // in-wrapper Start-Process uses Windows-only NoNewWindow to reuse this
+    // hidden console rather than creating a transient conhost window.
     // `-ExecutionPolicy` only applies to Windows PowerShell; build per-platform.
     const isWin = process.platform === 'win32';
     const wrapperArgs = ['-NoLogo', '-NoProfile', '-NonInteractive'];

package/src/runtime/memory/data/runtime-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema_version": 1,
-  "generated_at": "2026-06-30T06:23:20.385Z",
+  "generated_at": "2026-07-13T06:08:53.718Z",
   "release_tag": "runtime-v0.4.0",
   "pg": {
     "major": 16,
@@ -12,28 +12,28 @@
   "assets": {
     "darwin-arm64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-darwin-arm64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "7a642006ef60ccf8c385ba89c761c2b6f4927f6f01a1c4fb152604e6b41fe3d2",
-      "size": 23397361
+      "sha256": "c11f4b3046f0eeecf88790d2fff88cee1834231f96c11ec315a7a97180ea1413",
+      "size": 23397436
     },
     "darwin-x64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-darwin-x64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "8e39bfc3f06d88e9854946d5d83f7d77d9530f99284d7c1c51872c12f389f7e7",
-      "size": 23687666
+      "sha256": "ef93b837b1e3ea0b30591f2d31de10f9a628db88ad00183d271d539fe3cb0adb",
+      "size": 23687427
     },
     "linux-arm64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-linux-arm64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "64ff170013b9543ad8843c98cbfe14019e6be6ea3d142ec189b2bea0dd1dc797",
-      "size": 22885036
+      "sha256": "288d566fd38dd80ce2dcfa68083a76b6a9400fbd8020453cf72197d3cc161315",
+      "size": 22884871
     },
     "linux-x64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-linux-x64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "28ee64125a0125ff36c47560c08ce8f38e49aef034c010c7e4867e8cdd783385",
-      "size": 23276106
+      "sha256": "31b40d32d51afb85963e33557c3140e378b21c7cc54cec794049276a2160afd3",
+      "size": 23282291
     },
     "win32-x64": {
       "url": "https://github.com/tribgames/mixdog/releases/download/runtime-v0.4.0/mixdog-runtime-win32-x64-pg16.4-pgvector0.8.2.tar.gz",
-      "sha256": "6faed8a49b3303b0adb1c5715b2b19c5cc47df2e738d586d0d0bd432f1ca035d",
-      "size": 44036958
+      "sha256": "5d3d9d6e3ae4a93bb0bde615365bdda3ab5ff7206c0d1a066ed51b316932a8f8",
+      "size": 44037023
     }
   }
 }

package/src/runtime/memory/lib/runtime-fetcher.mjs

@@ -37,7 +37,6 @@ const BUNDLED_MANIFEST_PATH = fileURLToPath(new URL('../data/runtime-manifest.js
 
 // GitHub raw URL fallback — used only when no cached or bundled manifest exists.
 const MANIFEST_URL = 'https://raw.githubusercontent.com/tribgames/mixdog/main/src/runtime/memory/data/runtime-manifest.json'
-const LEGACY_RUNTIME_RELEASE_REPOSITORY = 'trib-plugin/mixdog'
 
 // ---------------------------------------------------------------------------
 // Platform key
@@ -183,7 +182,7 @@ function runtimeAssetUrlCandidates(url) {
     .split(/[\s,;]+/u)
     .map((repo) => repo.trim())
     .filter(Boolean)
-  for (const repo of [...overrides, LEGACY_RUNTIME_RELEASE_REPOSITORY]) {
+  for (const repo of overrides) {
     if (repo && repo !== releaseRepo) add(value.replace(`/github.com/${releaseRepo}/`, `/github.com/${repo}/`))
   }
   return out

package/src/runtime/shared/update-checker.mjs

@@ -13,8 +13,8 @@
  * the child exits, reporting the resolved version on success.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { basename, delimiter, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
 import { resolvePluginData } from './plugin-paths.mjs';
@@ -199,19 +199,49 @@ export async function checkLatestVersion({ force = false, dataDir } = {}) {
  * `-WindowStyle Hidden` style flags that antivirus heuristics flag).
  */
 export function npmCliJsPath() {
-  const execDir = dirname(process.execPath);
-  const candidates = [
-    // Windows: npm ships beside node.exe.
-    join(execDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-    // Unix layout: <prefix>/bin/node → <prefix>/lib/node_modules/npm.
-    join(execDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-  ];
   // When launched via npm itself, npm_execpath is authoritative.
   const envPath = process.env.npm_execpath;
-  if (envPath && /npm-cli\.js$/i.test(envPath)) candidates.unshift(envPath);
+  const candidates = envPath && /npm-cli\.js$/i.test(envPath) ? [envPath] : [];
+  const execDirs = [dirname(process.execPath)];
+  try {
+    const realExecDir = dirname(realpathSync(process.execPath));
+    if (!execDirs.includes(realExecDir)) execDirs.push(realExecDir);
+  } catch { /* retain the raw executable path */ }
+
+  for (const execDir of execDirs) {
+    // Windows: npm ships beside node.exe.
+    candidates.push(join(execDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'));
+    // Unix layout: <prefix>/bin/node → <prefix>/lib/node_modules/npm.
+    candidates.push(join(execDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'));
+    // Homebrew: <prefix>/bin/node → <prefix>/libexec/lib/node_modules/npm.
+    candidates.push(join(execDir, '..', 'libexec', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'));
+  }
   for (const candidate of candidates) {
     try { if (existsSync(candidate)) return candidate; } catch { /* keep looking */ }
   }
+
+  // Last resort: npm shims on PATH commonly resolve into npm's package bin dir.
+  const pathDirs = (process.env.PATH || process.env.Path || '').split(delimiter);
+  for (const pathDir of pathDirs) {
+    if (!pathDir) continue;
+    const npmPaths = process.platform === 'win32'
+      ? [join(pathDir, 'npm'), join(pathDir, 'npm.cmd')]
+      : [join(pathDir, 'npm')];
+    for (const npmPath of npmPaths) {
+      try {
+        if (!existsSync(npmPath)) continue;
+        const resolvedNpm = realpathSync(npmPath);
+        const npmBinDir = dirname(resolvedNpm);
+        if (
+          basename(npmBinDir) !== 'bin'
+          || basename(dirname(npmBinDir)) !== 'npm'
+          || basename(dirname(dirname(npmBinDir))) !== 'node_modules'
+        ) continue;
+        const cliJs = join(npmBinDir, 'npm-cli.js');
+        if (existsSync(cliJs)) return cliJs;
+      } catch { /* keep looking */ }
+    }
+  }
   return null;
 }
 

package/src/standalone/agent-tool.mjs

@@ -92,6 +92,70 @@ const DEFAULT_SPAWN_PREP_TIMEOUT_MS = envTimeoutMs('MIXDOG_AGENT_SPAWN_PREP_TIME
 const SPAWN_STAGGER_MS = envTimeoutMs('MIXDOG_SPAWN_STAGGER_MS', 0);
 const TAG_TOMBSTONE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const MAX_TAG_TOMBSTONES = 500;
+
+/**
+ * Resolve the route for a public agent spawn. Explore and Maintainer inherit
+ * Main only after their explicit agent, workflow, and maintenance routes.
+ */
+export function resolveAgentSpawnPreset(config, args = {}) {
+  if (args.provider && args.model) {
+    return {
+      presetName: args.preset || '__direct__',
+      preset: {
+        id: '__direct__',
+        name: '__DIRECT__',
+        type: 'agent',
+        provider: clean(args.provider),
+        model: clean(args.model),
+        effort: clean(args.effort) || undefined,
+        fast: args.fast === true,
+        tools: 'full',
+      },
+    };
+  }
+
+  const agentName = normalizeAgentName(args.agent);
+  const configuredDefault = clean(config?.defaultProvider);
+  const fallbackProvider = configuredDefault && isKnownProvider(configuredDefault)
+    ? configuredDefault
+    : DEFAULT_PROVIDER;
+  const workflowSlot = agentName === 'explore' ? 'explorer'
+    : (agentName === 'maintainer' ? 'memory' : '');
+  const maintenanceSlot = agentName === 'explore' ? 'explore'
+    : (agentName === 'maintainer' ? 'memory' : '');
+  const agentRoute = !clean(args.preset)
+    ? (normalizeAgentRoute(config?.agents?.[agentName], fallbackProvider)
+      || (agentName === 'maintainer' ? normalizeAgentRoute(config?.agents?.maintenance, fallbackProvider) : null)
+      || normalizeAgentRoute(config?.workflowRoutes?.[workflowSlot], fallbackProvider)
+      || normalizeAgentRoute(config?.maintenance?.[maintenanceSlot], fallbackProvider))
+    : null;
+  if (agentRoute) {
+    return {
+      presetName: agentPresetName(agentName),
+      preset: {
+        id: `agent-${agentName}`,
+        name: agentPresetName(agentName),
+        type: 'agent',
+        provider: agentRoute.provider,
+        model: agentRoute.model,
+        effort: agentRoute.effort,
+        fast: agentRoute.fast === true,
+        tools: 'full',
+      },
+    };
+  }
+
+  const mainPreset = !clean(args.preset) && (agentName === 'explore' || agentName === 'maintainer')
+    ? findPreset(config, config?.default)
+    : null;
+  if (mainPreset) return { presetName: mainPreset.id || mainPreset.name, preset: mainPreset };
+
+  const presetName = clean(args.preset) || DEFAULT_AGENT_PRESETS[agentName];
+  if (!presetName) throw new Error(`agent: agent "${agentName}" has no model assignment`);
+  const preset = findPreset(config, presetName) || synthesizePreset(config, presetName);
+  if (!preset) throw new Error(`agent: preset "${presetName}" not found`);
+  return { presetName, preset };
+}
 let lastSpawnStartAt = 0;
 async function waitForSpawnStagger() {
   if (SPAWN_STAGGER_MS <= 0) return;
@@ -741,55 +805,6 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
   // chain-gate defaults to the spawn-prep cap (see provider-init.mjs comments).
   const { ensureProvider } = createProviderInit(reg, DEFAULT_SPAWN_PREP_TIMEOUT_MS);
 
-  function resolvePreset(config, args) {
-    if (args.provider && args.model) {
-      return {
-        presetName: args.preset || '__direct__',
-        preset: {
-          id: '__direct__',
-          name: '__DIRECT__',
-          type: 'agent',
-          provider: clean(args.provider),
-          model: clean(args.model),
-          effort: clean(args.effort) || undefined,
-          fast: args.fast === true,
-          tools: 'full',
-        },
-      };
-    }
-
-    const agentName = normalizeAgentName(args.agent);
-    const configuredDefault = clean(config?.defaultProvider);
-    const fallbackProvider = configuredDefault && isKnownProvider(configuredDefault)
-      ? configuredDefault
-      : DEFAULT_PROVIDER;
-    const agentRoute = !clean(args.preset)
-      ? (normalizeAgentRoute(config?.agents?.[agentName], fallbackProvider)
-        || (agentName === 'maintainer' ? normalizeAgentRoute(config?.agents?.maintenance, fallbackProvider) : null))
-      : null;
-    if (agentRoute) {
-      return {
-        presetName: agentPresetName(agentName),
-        preset: {
-          id: `agent-${agentName}`,
-          name: agentPresetName(agentName),
-          type: 'agent',
-          provider: agentRoute.provider,
-          model: agentRoute.model,
-          effort: agentRoute.effort,
-          fast: agentRoute.fast === true,
-          tools: 'full',
-        },
-      };
-    }
-
-    const presetName = clean(args.preset) || DEFAULT_AGENT_PRESETS[agentName];
-    if (!presetName) throw new Error(`agent: agent "${agentName}" has no model assignment`);
-    const preset = findPreset(config, presetName) || synthesizePreset(config, presetName);
-    if (!preset) throw new Error(`agent: preset "${presetName}" not found`);
-    return { presetName, preset };
-  }
-
   function list({ scanSessions = false, context = {} } = {}) {
     refreshTagsFromSessions({ scanSessions, context });
     const now = Date.now();
@@ -1175,7 +1190,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     if (!agent) throw new Error('agent spawn: agent is required');
     const agentPermission = readAgentFrontmatterPermission(agent, dataDir, STANDALONE_SOURCE_ROOT);
     const agentPerm = normalizeAgentPermission(agentPermission) || null;
-    const { presetName, preset } = resolvePreset(config, args);
+    const { presetName, preset } = resolveAgentSpawnPreset(config, args);
     await ensureProvider(config, preset.provider);
     if (prepState?.timedOut) {
       throw new Error('agent spawn prep timed out before session bind');

package/src/standalone/explore-tool.mjs

@@ -1,7 +1,7 @@
 import { isAbsolute, resolve } from 'node:path';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { makeAgentDispatch } from '../runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs';
+import { makeAgentDispatch, resolveMaintenanceRoute } from '../runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs';
 import { loadConfig } from '../runtime/agent/orchestrator/config.mjs';
 import { initProviders } from '../runtime/agent/orchestrator/providers/registry.mjs';
 import { presentErrorText } from '../runtime/shared/err-text.mjs';
@@ -195,10 +195,13 @@ function exploreResultCacheEnabled() {
     && !/^(?:0|false|off|no)$/i.test(String(process.env.MIXDOG_EXPLORE_RESULT_CACHE || '1'));
 }
 
-function exploreResultCacheKey({ cwd, presetName, query }) {
+export function exploreResultCacheKey({ cwd, route, query }) {
   return JSON.stringify({
     cwd: String(cwd || ''),
-    presetName: String(presetName || ''),
+    provider: clean(route?.provider),
+    model: clean(route?.model),
+    effort: clean(route?.effort),
+    fast: route?.fast === true,
     query: String(query || ''),
   });
 }
@@ -211,13 +214,14 @@ function findConfigPreset(config, presetName) {
     || null;
 }
 
-async function ensureExploreProviderReady(config) {
-  const route = config?.maintenance?.explore;
-  // Route object ({provider,model}) is the current shape; a string is a
-  // legacy preset NAME resolved against config.presets.
-  const provider = (route && typeof route === 'object')
-    ? clean(route.provider)
-    : clean(findConfigPreset(config, route)?.provider);
+export function resolveExploreRoute(config) {
+  const routeOrName = resolveMaintenanceRoute({ agent: 'explorer', config });
+  if (routeOrName && typeof routeOrName === 'object') return routeOrName;
+  return findConfigPreset(config, routeOrName);
+}
+
+async function ensureExploreProviderReady(config, route) {
+  const provider = clean(route?.provider);
   if (!provider) return;
   const providers = { ...(config?.providers || {}) };
   providers[provider] = { ...(providers[provider] || {}), enabled: true };
@@ -411,11 +415,8 @@ async function runExploreSync(args = {}, ctx = {}) {
   scheduleExploreCodeGraphPrewarm(resolvedCwd);
   scheduleExploreFindPrewarm(resolvedCwd);
   const config = loadConfig();
-  await ensureExploreProviderReady(config);
-  const route = config?.maintenance?.explore;
-  const presetName = (route && typeof route === 'object')
-    ? `${clean(route.provider)}/${clean(route.model)}`
-    : (route || '');
+  const route = resolveExploreRoute(config);
+  await ensureExploreProviderReady(config, route);
   // Turn budget is enforced BOTH ways: the prompt contract (rules/agent/
   // 30-explorer.md, "hard max 3 tool turns, expected 1") steers the model,
   // and maxLoopIterations mechanically backstops it — live traces showed
@@ -439,7 +440,7 @@ async function runExploreSync(args = {}, ctx = {}) {
   // query resolves without delay regardless of index.
   const stagger = working.length > 1 ? EXPLORE_FANOUT_STAGGER_MS : 0;
   const settled = await Promise.allSettled(working.map((q, i) => {
-    const key = exploreResultCacheKey({ cwd: resolvedCwd, presetName, query: q });
+    const key = exploreResultCacheKey({ cwd: resolvedCwd, route, query: q });
     return runExploreCached(key, () => {
       const delay = (stagger > 0 && i > 0) ? new Promise((r) => setTimeout(r, stagger)) : null;
       return delay