mixdog 0.9.166 → 0.9.167

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

@@ -4,7 +4,8 @@
  *  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 } from '../builtin-features.mjs';
-import { SETUP_ACTIONS, SETUP_OPEN_TARGETS, SETUP_STATUS_DOMAINS } from './tool-defs.mjs';
+import { SETUP_ACTIONS, SETUP_ACTION_FIELDS, SETUP_OPEN_TARGETS, SETUP_STATUS_DOMAINS, SETUP_TOOL_DEFS, SETUP_BUILTIN_TOGGLE_FEATURES } from './tool-defs.mjs';
+import { schemaValueError } from '../../runtime/shared/schema-value-error.mjs';
 
 const clean = (value) => String(value ?? '').trim();
 
@@ -48,8 +49,7 @@ function requireText(value, label) {
   return text;
 }
 
-function routeInput(route) {
-  const source = route && typeof route === 'object' ? route : {};
+function routeInput(source) {
   const next = {};
   if (clean(source.provider) || Object.prototype.hasOwnProperty.call(source, 'provider')) next.provider = clean(source.provider);
   if (clean(source.model)) next.model = clean(source.model);
@@ -192,6 +192,14 @@ export function createSetupToolExecutor({ getApi, getConfig, notifySessionUi, ge
 
   async function execute(args = {}) {
     const action = requireEnum(args?.action, SETUP_ACTIONS, 'action');
+    const validationError = schemaValueError({ ...args, action }, SETUP_TOOL_DEFS[0].inputSchema, 'setup');
+    if (validationError) throw new Error(`[tool-input-validation] ${validationError}`);
+    const fields = SETUP_ACTION_FIELDS[action].split(' ').filter(Boolean);
+    const allowed = fields.map((field) => field.replace(/\?$/, ''));
+    const extras = Object.keys(args).filter((field) => field !== 'action' && !allowed.includes(field));
+    if (extras.length) throw new Error(`[tool-input-validation] setup.${action} does not accept field(s): ${extras.join(', ')}`);
+    const missing = fields.find((field) => !field.endsWith('?') && !Object.hasOwn(args, field));
+    if (missing) throw new Error(`[tool-input-validation] ${missing} is required for setup.${action}`);
     const rt = action === 'status' || action === 'open' ? null : api();
     switch (action) {
       case 'status': {
@@ -235,7 +243,7 @@ export function createSetupToolExecutor({ getApi, getConfig, notifySessionUi, ge
       case 'set_recap_enabled': return rt.setRecapEnabled(requireBoolean(args.enabled));
       case 'set_web_search_enabled': return await rt.setWebSearchEnabled(requireBoolean(args.enabled));
       case 'set_builtin_enabled': {
-        const name = requireEnum(args.name, ['git', 'office', 'localProvider'], 'name');
+        const name = requireEnum(args.name, SETUP_BUILTIN_TOGGLE_FEATURES, 'name');
         return await rt.setBuiltinToolEnabled(name, requireBoolean(args.enabled));
       }
       case 'set_first_use_approval': {
@@ -298,7 +306,7 @@ export function createSetupToolExecutor({ getApi, getConfig, notifySessionUi, ge
       }
       case 'set_extension_scope': {
         const kind = requireEnum(args.kind, ['skills', 'mcp', 'plugins'], 'kind');
-        const projects = Array.isArray(args.projects) ? args.projects.map(clean).filter(Boolean) : [];
+        const projects = args.projects.map(clean);
         const status = await rt.setExtensionScope(kind, requireText(args.name, 'name'), projects);
         if (kind === 'mcp') return { mcp: mcpRows(status) };
         return status || {};

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

@@ -47,48 +47,54 @@ export const SETUP_OPEN_TARGETS = Object.freeze([
   'context',
 ]);
 
-export const SETUP_ACTIONS = Object.freeze([
-  'status',
-  'open',
-  'set_route',
-  'set_agent_route',
-  'set_web_search_route',
-  'set_workflow',
-  'set_output_style',
-  'set_profile',
-  'set_autoclear',
-  'set_compaction',
-  'set_memory_enabled',
-  'set_recap_enabled',
-  'set_web_search_enabled',
-  'set_builtin_enabled',
-  'set_first_use_approval',
-  'install_builtin',
-  'install_local_model',
-  'start_local_installation',
-  'cancel_local_installation',
-  'set_local_idle_ttl',
-  'search_local_models',
-  'inspect_hf_model',
-  'register_hf_model',
-  'local_model_details',
-  'maintain_local_model',
-  'delete_local_model',
-  'set_system_shell',
-  'set_auto_update',
-  'forget_provider_auth',
-  'add_mcp_server',
-  'save_mcp_server',
-  'remove_mcp_server',
-  'set_mcp_enabled',
-  'reconnect_mcp',
-  'set_disabled_skills',
-  'set_extension_scope',
-  'add_plugin',
-  'update_plugin',
-  'set_plugin_enabled',
-  'remove_plugin',
-]);
+// Runtime dispatch contract. A trailing ? denotes an optional field. Keep
+// this out of the wire schema: field descriptions already name their actions.
+export const SETUP_ACTION_FIELDS = Object.freeze({
+  status: 'domain?',
+  open: 'target',
+  set_route: 'route',
+  set_agent_route: 'agent route',
+  set_web_search_route: 'route',
+  set_workflow: 'workflow',
+  set_output_style: 'style',
+  set_profile: 'profile',
+  set_autoclear: 'autoclear',
+  set_compaction: 'enabled',
+  set_memory_enabled: 'enabled',
+  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?',
+  cancel_local_installation: 'jobId',
+  set_local_idle_ttl: 'idleTtlSeconds?',
+  search_local_models: 'query',
+  inspect_hf_model: 'repository filename? contextWindow?',
+  register_hf_model: 'previewId licenseAccepted',
+  local_model_details: 'modelId',
+  maintain_local_model: 'modelId operation',
+  delete_local_model: 'confirmationToken',
+  set_system_shell: 'command',
+  set_auto_update: 'enabled',
+  forget_provider_auth: 'name',
+  add_mcp_server: 'server',
+  save_mcp_server: 'server',
+  remove_mcp_server: 'name',
+  set_mcp_enabled: 'name enabled',
+  reconnect_mcp: '',
+  set_disabled_skills: 'skills',
+  set_extension_scope: 'kind name projects',
+  add_plugin: 'source',
+  update_plugin: 'name',
+  set_plugin_enabled: 'name enabled',
+  remove_plugin: 'name',
+});
+
+export const SETUP_ACTIONS = Object.freeze(Object.keys(SETUP_ACTION_FIELDS));
+
+export const SETUP_BUILTIN_TOGGLE_FEATURES = Object.freeze(['git', 'office', 'localProvider']);
 
 const ROUTE_SCHEMA = {
   type: 'object',
@@ -119,7 +125,7 @@ export const SETUP_TOOL_DEFS = Object.freeze([
       additionalProperties: false,
       required: ['action'],
       properties: {
-        action: { type: 'string', enum: [...SETUP_ACTIONS] },
+        action: { type: 'string', enum: [...SETUP_ACTIONS], description: 'Pass only fields for this action.' },
         domain: { type: 'string', enum: [...SETUP_STATUS_DOMAINS], description: 'status: which domain to read; default summary.' },
         target: { type: 'string', enum: [...SETUP_OPEN_TARGETS], description: 'open: settings surface, named by its slash command.' },
         route: { ...ROUTE_SCHEMA, description: 'set_route / set_agent_route / set_web_search_route. set_agent_route with provider "" restores inheritance.' },
@@ -140,7 +146,7 @@ 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).' },
-        name: { type: 'string', description: 'Feature (git|memory|office|localProvider; browser|computer for set_first_use_approval), MCP server, plugin id, or provider id, per action.' },
+        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; else MCP/plugin/provider id.` },
         modelId: { type: 'string', description: 'install_local_model: exact model id from status domain local-provider; runtime must already be installed.' },
         phase: { type: 'string', enum: ['runtime', 'model'], description: 'start_local_installation: which managed asset to install or resume. Model phase requires modelId.' },
         jobId: { type: 'string', description: 'cancel_local_installation: current jobId from local-provider status.' },
@@ -153,12 +159,12 @@ export const SETUP_TOOL_DEFS = Object.freeze([
         licenseAccepted: { type: 'boolean', description: 'register_hf_model: explicit acceptance of the inspected license and installation plan.' },
         operation: { type: 'string', enum: ['verify', 'repair'], description: 'maintain_local_model: verify SHA-256 or redownload the pinned model; returns a background job.' },
         confirmationToken: { type: 'string', description: 'delete_local_model: unexpired token from local_model_details.' },
-        command: { type: 'string', description: 'set_system_shell: shell command; empty restores automatic selection.' },
+        command: { type: 'string', description: 'set_system_shell: required shell command; "" restores automatic selection.' },
         server: { type: 'object', additionalProperties: true, description: 'add_mcp_server / save_mcp_server: {name, type, command, args, cwd, env} or {name, type, url, headers}.' },
         skills: { type: 'array', items: { type: 'string' }, description: 'set_disabled_skills: full list of disabled skill names.' },
         source: { type: 'string', description: 'add_plugin: Git URL, owner/repo, or local path.' },
         kind: { type: 'string', enum: ['skills', 'mcp', 'plugins'], description: 'set_extension_scope: which extension list `name` belongs to.' },
-        projects: { type: 'array', items: { type: 'string' }, description: 'set_extension_scope: project root paths the extension is limited to; empty = every project.' },
+        projects: { type: 'array', items: { type: 'string', minLength: 1, pattern: '\\S' }, description: 'set_extension_scope: required project roots; [] = every project.' },
       },
     },
   },

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

@@ -13,11 +13,11 @@ export const TOOL_SEARCH_TOOL = {
     openWorldHint: false,
     agentHidden: true,
   },
-  description: 'Load full schemas for exact deferred tool names/aliases not already available; returns function descriptions and parameter schemas.',
+  description: 'Load full schemas for missing deferred tool names/aliases; batch needed names in one call.',
   inputSchema: {
     type: 'object',
     properties: {
-      names: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Exact deferred tool names/aliases to load.' },
+      names: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Exact name(s)/aliases.' },
     },
     required: ['names'],
     additionalProperties: false,
@@ -35,11 +35,12 @@ export const CWD_TOOL = {
     openWorldHint: false,
     agentHidden: true,
   },
-  description: 'Show the active Project, or set it to path. A shell-local cd does not change the Project.',
+  description: 'Show or switch the working directory (active Project). action=list returns the registered projects (name, path); when the user gives a project name instead of a path, list first, then set with the matching path and ask only if several candidates match. path must be an existing directory. A shell-local cd does not change the Project.',
   inputSchema: {
     type: 'object',
     properties: {
-      path: { type: 'string', description: 'New Project directory. Omit to show the active Project.' },
+      action: { type: 'string', enum: ['get', 'set', 'list'], description: 'get shows the active Project (default without path), set switches to path, list returns registered projects.' },
+      path: { type: 'string', description: 'Existing directory to switch to (implies action=set).' },
     },
     additionalProperties: false,
   },
@@ -73,3 +74,71 @@ export const LEAD_DISALLOWED_TOOLS = Object.freeze([
   'set_goal_tasks',
   'update_goal',
 ]);
+
+// The runtime surfaces named tools from each optional tool-def module, never
+// "whatever the module exports": a module that grows a tool must be admitted
+// here before it can reach a session.
+const WEB_SEARCH_RUNTIME_TOOLS = ['web_search', 'web_fetch', 'local_fetch', 'image_fetch'];
+const MEMORY_RUNTIME_TOOLS = ['recall', 'memory'];
+const CODE_GRAPH_RUNTIME_TOOLS = ['code_graph'];
+const BROWSER_RUNTIME_TOOLS = ['browser', 'browser_devtools'];
+const COMPUTER_RUNTIME_TOOLS = ['computer'];
+const OFFICE_RUNTIME_TOOLS = ['office'];
+const MEDIA_RUNTIME_TOOLS = ['media'];
+
+const admitted = (tools, names) => (tools || []).filter((tool) => names.includes(tool?.name));
+
+/**
+ * Assemble this runtime's tool definitions from the loaded tool-def modules.
+ * Pure: callers resolve their own availability flags (skills env gate, channel
+ * ownership) and pass the already-built goal/agent tool arrays.
+ *
+ * - `standaloneTools` is the model-facing set (also the deferred catalog base).
+ * - `internalToolDefs` adds the `public: false` web-search tools: reachable
+ *   through the internal executor for other tools, never advertised to a model.
+ */
+export function collectStandaloneToolDefs({
+  webSearchToolDefs,
+  memoryToolDefs,
+  channelToolDefs,
+  codeGraphToolDefs,
+  browserToolDefs = [],
+  computerToolDefs = [],
+  officeToolDefs = [],
+  mediaToolDefs = [],
+  setupToolDefs = [],
+  goalTools = [],
+  agentTools = [],
+  isChannelTool = () => false,
+  skillToolEnabled = true,
+}) {
+  const webSearchRuntimeTools = admitted(webSearchToolDefs?.TOOL_DEFS, WEB_SEARCH_RUNTIME_TOOLS);
+  const standaloneTools = [
+    TOOL_SEARCH_TOOL,
+    ...(skillToolEnabled ? [SKILL_TOOL] : []),
+    CWD_TOOL,
+    ...webSearchRuntimeTools.filter((tool) => tool?.public !== false),
+    ...admitted(memoryToolDefs?.TOOL_DEFS, MEMORY_RUNTIME_TOOLS),
+    ...(channelToolDefs?.TOOL_DEFS || []).filter((tool) => isChannelTool(tool?.name)),
+    ...admitted(codeGraphToolDefs?.CODE_GRAPH_TOOL_DEFS, CODE_GRAPH_RUNTIME_TOOLS),
+    ...admitted(browserToolDefs, BROWSER_RUNTIME_TOOLS),
+    ...admitted(computerToolDefs, COMPUTER_RUNTIME_TOOLS),
+    ...admitted(officeToolDefs, OFFICE_RUNTIME_TOOLS),
+    ...admitted(mediaToolDefs, MEDIA_RUNTIME_TOOLS),
+    ...setupToolDefs,
+    ...goalTools,
+    ...agentTools,
+  ];
+  return {
+    standaloneTools,
+    internalToolDefs: [
+      ...standaloneTools,
+      ...webSearchRuntimeTools.filter((tool) => tool?.public === false),
+    ],
+    // Workflow-aware model surface: a pack that declares an EMPTY agents list
+    // (Solo) must not advertise the agent tool at all — the model calling a
+    // schema-visible tool that policy always rejects is a guaranteed error turn
+    // (user-reported in Solo). Names derive from the live agent tool defs.
+    agentToolNames: new Set(agentTools.map((tool) => String(tool?.name || '')).filter(Boolean)),
+  };
+}

package/src/session-runtime/usage-stats-api.mjs

@@ -2,6 +2,7 @@
 // dependencies after the one-time import of surviving historical originals.
 import { getUsageLedger } from '../runtime/shared/llm/usage-ledger.mjs';
 import { importUsageHistory } from '../runtime/shared/llm/usage-ledger-import.mjs';
+import { refreshUnpricedUsage } from '../runtime/shared/llm/usage-pricing-refresh.mjs';
 import { resolvePluginData } from '../runtime/shared/plugin-paths.mjs';
 import { usageStatsSnapshot } from '../standalone/usage-stats-model.mjs';
 import { resolveUsageStatsPeriod } from '../standalone/usage-stats-period.mjs';
@@ -39,16 +40,18 @@ export function createUsageStatsApi({ ledger = getUsageLedger, importHistory = i
           .finally(() => { importing = null; });
         await importing;
       }
+      refreshUnpricedUsage(store);
       // Imports may take time: their newly retained timestamps must not fall
       // beyond a clock captured before the import started.
       const now = Date.now();
       // Keep the existing days API for non-desktop callers.
       const period = options?.view == null ? null : resolveUsageStatsPeriod({
-        view: options.view, anchor: options.anchor, now,
+        view: options.view, anchor: options.anchor, startDay: options.startDay, endDay: options.endDay, now,
       });
       const snapshot = usageStatsSnapshot({
         rollup: store.rollup({
           hourlyDay: period?.view === 'hour' ? period.startDay : null,
+          ...(period?.view === 'hour' ? { fromMs: period.fromMs, toMs: period.toMs } : {}),
           ...(period ? {
             fromDay: period.startDay || undefined,
             toDay: usageRollupDayKey(period.toMs),

package/src/session-runtime/warmup-schedulers.mjs

@@ -146,8 +146,14 @@ export function createWarmupSchedulers({
         return;
       }
       void warmCatalogsInBackground()
-        .then(() => bootProfile('model-catalog:warm-ready'))
-        .catch((error) => bootProfile('model-catalog:warm-failed', { error: error?.message || String(error) }));
+        .then((result) => {
+          bootProfile('model-catalog:warm-ready');
+          scheduleModelCatalogWarmup(result?.retryAfterMs ?? 6 * 60 * 60 * 1000);
+        })
+        .catch((error) => {
+          bootProfile('model-catalog:warm-failed', { error: error?.message || String(error) });
+          scheduleModelCatalogWarmup(60_000);
+        });
     }, delayMs);
     timers.modelCatalogWarmupTimer.unref?.();
   }

package/src/session-runtime/workflow.mjs

@@ -431,6 +431,20 @@ export function normalizeWebSearchRouteConfig(routeLike, fallback = {}) {
   };
 }
 
+// The runtime's web-search route is never "unconfigured": an unset or invalid
+// candidate falls through to the next one, and an empty list resolves to the
+// default "follow the Main Model" route.
+export function webSearchRouteOrDefault(...routeLikes) {
+  for (const routeLike of routeLikes) {
+    const normalized = normalizeWebSearchRouteConfig(routeLike);
+    if (normalized) return normalized;
+  }
+  return normalizeWebSearchRouteConfig({
+    provider: WEB_SEARCH_DEFAULT_PROVIDER,
+    model: WEB_SEARCH_DEFAULT_MODEL,
+  });
+}
+
 export function normalizeWorkflowRoute(routeLike, fallback = {}) {
   const provider = clean(routeLike?.provider) || clean(fallback.provider);
   const model = clean(routeLike?.model) || clean(fallback.model);

package/src/standalone/channel-session-router.mjs

@@ -1,6 +1,8 @@
 import { channelNotificationModelContent } from '../runtime/shared/channel-notification-routing.mjs';
 
-const CHANNEL_NOTIFICATION_METHOD = 'notifications/claude/channel';
+/** The one inbound channel notification method. Exported so every consumer
+ *  (daemon router, session runtime) matches the same wire name. */
+export const CHANNEL_NOTIFICATION_METHOD = 'notifications/claude/channel';
 
 export function createChannelSessionRouter({
   getSessionService,

package/src/standalone/channel-worker.mjs

@@ -10,6 +10,7 @@ import { detachedSpawnOpts } from '../runtime/shared/spawn-flags.mjs';
 import { scrubLoaderVars } from '../runtime/agent/orchestrator/tools/env-scrub.mjs';
 import { withHeapCap } from '../runtime/shared/heap-cap.mjs';
 import { rotateBoundedLog, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../lib/mixdog-debug.cjs';
+import { beginDaemonSpawnCapture } from './daemon-crash-capture.mjs';
 import { attachChannel, readChannelDiscovery, probeChannelHealth } from './channel-client.mjs';
 
 const CHANNEL_TOOLS = new Set([
@@ -195,34 +196,40 @@ export function createStandaloneChannelWorker({
   function spawnDaemonCandidate() {
     return new Promise((resolveSpawn) => {
       let settled = false;
+      // fd 2 is a capture FILE, not a pipe: a V8 fatal abort is written below
+      // every JS hook and a pipe stops being drained once this worker detaches.
+      const capture = beginDaemonSpawnCapture({
+        launcher: 'channel-worker',
+        dataDir,
+        log: (line) => logLine(logPath, line),
+      });
       const done = () => {
         if (settled) return;
         settled = true;
+        capture.mirror();
         resolveSpawn();
       };
+      // Same singleton daemon as the session spawn path, so the same heap policy.
+      const execArgv = withHeapCap('daemon', ['--require', WORKER_PRELOAD]);
       let daemon;
       try {
         daemon = fork(daemonEntry(), [], {
           cwd,
-          // Same singleton daemon as the session spawn path, so the same cap.
-          execArgv: withHeapCap('daemon', ['--require', WORKER_PRELOAD]),
-          stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+          execArgv,
+          stdio: ['ignore', 'ignore', capture.stderrStdio, 'ipc'],
           env: daemonEnv(),
           ...detachedSpawnOpts,
         });
       } catch (error) {
+        capture.noteSpawnError(error);
         logLine(logPath, `daemon spawn failed: ${error?.message || error}`);
         done();
         return;
       }
-      const mirrorStderr = (chunk) => {
-        const text = String(chunk || '').trimEnd();
-        if (text) logLine(logPath, text);
-      };
-      daemon.stderr?.on('data', mirrorStderr);
+      capture.track(daemon, { detached: Boolean(detachedSpawnOpts.detached), execArgv });
       daemon.once('message', (message) => {
         if (message?.type !== 'ready') return;
-        try { daemon.stderr?.off?.('data', mirrorStderr); } catch {}
+        capture.noteReady();
         try { daemon.disconnect?.(); } catch {}
         try { daemon.unref?.(); } catch {}
         try { daemon.stderr?.unref?.(); } catch {}
@@ -230,6 +237,8 @@ export function createStandaloneChannelWorker({
       });
       daemon.once('exit', done);
       daemon.once('error', (error) => {
+        // An async spawn failure may never emit 'exit'; the sidecar still gets it.
+        capture.noteSpawnError(error);
         logLine(logPath, `daemon spawn error: ${error?.message || error}`);
         done();
       });