mixdog 0.9.151 → 0.9.153

package/src/standalone/daemon.mjs

@@ -59,7 +59,11 @@ import { createChannelSessionRouter } from './channel-session-router.mjs';
 import { createSessionTransport } from './session-transport.mjs';
 import { createSessionService } from './session-service.mjs';
 import { createSessionProtocolClient } from './session-protocol.mjs';
-import { createSessionRuntimeHost } from './session-runtime-host.mjs';
+import {
+  listStoredActiveGoalSessionIds,
+  readStoredGoalSnapshot,
+} from '../session-runtime/goal-runtime.mjs';
+import { createDaemonSessionRuntimeHost } from './session-runtime-host-factory.mjs';
 import { getStandaloneMemoryRuntime } from './memory-runtime-proxy.mjs';
 import {
   compareRuntimeVersions,
@@ -244,10 +248,10 @@ const eventLoopDelay = monitorEventLoopDelay({ resolution: 20 });
 eventLoopDelay.enable();
 let eventLoopLagTimer = null;
 
-function startMemoryRuntimeEarly() {
-  // Start the isolated memory process immediately after singleton ownership is
-  // established. Do not await it: daemon front-door readiness remains
-  // independent while PG/embedding cold-start overlaps all other boot work.
+function registerMemoryRuntimeLazy() {
+  // Register the shared proxy immediately so daemon shutdown owns its
+  // lifecycle, but keep the isolated process off the startup path. A real
+  // memory call or the post-connect idle warmup starts the exact singleton.
   if (process.env.MIXDOG_DAEMON_SKIP_MEMORY === '1') {
     log('memory runtime skipped (MIXDOG_DAEMON_SKIP_MEMORY=1)');
     return;
@@ -259,9 +263,7 @@ function startMemoryRuntimeEarly() {
       dataDir: DATA_DIR,
       cwd: CWD,
     });
-    void memoryRuntime.init()
-      .then(() => log('memory runtime ready in isolated process'))
-      .catch((e) => log(`memory.start failed (non-fatal): ${e?.message || e}`));
+    log('memory runtime registered for lazy start');
   } catch (e) { log(`memory.start setup failed (non-fatal): ${e?.message || e}`); }
 }
 
@@ -414,11 +416,10 @@ async function main() {
     process.exit(0);
   }
   process.on('exit', () => { try { releaseSingletonOwner(OWNER_PATH, process.pid); } catch {} });
-  startMemoryRuntimeEarly();
+  registerMemoryRuntimeLazy();
   agentDispatchBroker = createAgentDispatchBroker({
-    // Memory-cycle agents execute inside the recyclable session runtime
-    // worker: this permanent daemon never loads the orchestrator graph for
-    // them, so its commit stays flat across cycles.
+    // Memory-cycle agents use the same lazy provider/orchestrator graph as
+    // session actors; it stays unloaded until a real cycle requests it.
     dispatchAgent: (payload, options) => {
       if (!sessionRuntimeHost) throw new Error('session runtime host is not ready');
       return sessionRuntimeHost.agentDispatch(payload, options);
@@ -580,10 +581,64 @@ async function main() {
   };
   let sessionRuntimePrewarmStarted = false;
   let sessionRuntimePrewarmPromise = null;
-  sessionRuntimeHost = createSessionRuntimeHost({
+  let canonicalAgentToolPromise = null;
+  function canonicalAgentTool() {
+    if (!sessionService) {
+      return Promise.reject(new Error('canonical session service is not ready'));
+    }
+    canonicalAgentToolPromise ??= Promise.all([
+      import('./agent-tool.mjs'),
+      import('../runtime/agent/orchestrator/config.mjs'),
+      import('../runtime/agent/orchestrator/providers/registry.mjs'),
+    ]).then(([agentModule, cfgMod, reg]) => agentModule.createStandaloneAgent({
+      cfgMod,
+      reg,
+      mgr: sessionService.agentManager,
+      dataDir: cfgMod.getPluginData(),
+      cwd: CWD,
+      awaitKeychainPrewarm: async () => {},
+      isKeychainPrewarmReady: () => true,
+      sessionSurface: sessionService.agentSurface,
+      notifySessionCompletion(ownerSessionId, text, meta = {}) {
+        return sessionRuntimeHost?.notifySessionCompletion?.(ownerSessionId, text, meta) === true;
+      },
+    })).catch((error) => {
+      canonicalAgentToolPromise = null;
+      throw error;
+    });
+    return canonicalAgentToolPromise;
+  }
+  async function executeCanonicalAgentControl(args = {}, context = {}) {
+    const tool = await canonicalAgentTool();
+    const parentSessionId = String(context?.callerSessionId || '').trim();
+    await sessionService.rehydrateAgentSessions();
+    const scopedContext = {
+      ...context,
+      callerSessionId: parentSessionId || null,
+      ownerSessionId: sessionService.rootOwnerSessionId(parentSessionId),
+    };
+    if (String(args?.type || '') === '__close_all') {
+      await tool.closeAll?.(
+        String(args?.reason || 'agent owner closed'),
+        { callerSessionId: parentSessionId || null },
+      );
+      await sessionService.cancelAgentDescendants(
+        parentSessionId,
+        String(args?.reason || 'agent owner closed'),
+      );
+      return 'agent close all: ok';
+    }
+    return await tool.execute(args, scopedContext);
+  }
+  sessionRuntimeHost = createDaemonSessionRuntimeHost({
     cwd: CWD,
     log,
+    executeAgentControl: executeCanonicalAgentControl,
   });
+  // Codex-style runtime: daemon routing and independent async session actors
+  // share one V8 isolate and module graph. CPU-heavy work stays in bounded
+  // native helpers/worker pools instead of duplicating the whole runtime.
+  log(`session runtime mode=${sessionRuntimeHost.status.mode}`);
   function prewarmSessionRuntime() {
     if (sessionRuntimePrewarmPromise) return sessionRuntimePrewarmPromise;
     sessionRuntimePrewarmStarted = true;
@@ -592,7 +647,7 @@ async function main() {
       .catch((error) => log(`image pipeline prewarm failed (non-fatal): ${error?.message || error}`));
     sessionRuntimePrewarmPromise = sessionRuntimeHost.prewarm()
       .then(() => {
-        log('session runtime worker/agent-loop/keychain/memory prewarm ready');
+        log('session runtime/agent-loop/keychain prewarm ready');
         return true;
       })
       .catch((error) => {
@@ -601,7 +656,7 @@ async function main() {
         log(`session runtime/keychain prewarm failed (non-fatal): ${error?.message || error}`);
         return false;
       });
-    return sessionRuntimePrewarmPromise;
+      return sessionRuntimePrewarmPromise;
   }
   sessionService = createSessionService({
     createSessionRuntime: (options) => sessionRuntimeHost.create(options),
@@ -617,7 +672,31 @@ async function main() {
       if (typeof store.readStoredSessionTranscript !== 'function') return null;
       return await store.readStoredSessionTranscript(sessionId, options) ?? null;
     },
+    readStoredGoal: async (sessionId) => readStoredGoalSnapshot({
+      dataDir: DATA_DIR,
+      sessionId,
+    }),
+    listStoredActiveGoalSessionIds: async () => listStoredActiveGoalSessionIds({
+      dataDir: DATA_DIR,
+    }),
     listSessions: async (options = {}) => {
+      if (options.includeAgentOnly === true) {
+        // Agent discovery is metadata-only. Exact session reads/subscriptions
+        // keep using the canonical session id after the user opens a worker.
+        const store = await import('../runtime/agent/orchestrator/session/store.mjs');
+        const summaries = store.listStoredSessionSummaries({
+          refreshFromStorage: options.refreshFromStorage === true,
+        });
+        const viewStore = await desktopRuntime.loadSessionStore();
+        const links = viewStore.listStoredAgentWorkerLinks?.() || [];
+        if (!links.length) return summaries;
+        const linksById = new Map(links.map((link) => [link.sessionId, link]));
+        return summaries.map((row) => {
+          if (row?.parentSessionId) return row;
+          const link = linksById.get(row?.id);
+          return link ? { ...row, ...link, id: row.id } : row;
+        });
+      }
       const store = await desktopRuntime.loadSessionStore();
       return store.listStoredSessionSummaries({
         refreshFromStorage: options.refreshFromStorage === true,
@@ -715,11 +794,30 @@ async function main() {
     safeIpcSend(process, { type: 'ready', port, token });
   }
   log(`ready port=${port} pid=${process.pid} in ${(performance.now() - startedAt).toFixed(0)}ms`);
+  void prewarmSessionRuntime()
+    .then(() => sessionService.recoverActiveGoals())
+    .then(({ found, resumed, skipped, failed }) => {
+      log(`active Goal recovery found=${found} resumed=${resumed} skipped=${skipped} failed=${failed}`);
+    })
+    .catch((error) => {
+      log(`active Goal recovery failed: ${error?.message || error}`);
+    });
   eventLoopLagTimer = setInterval(() => {
     const status = eventLoopStatus();
     if (status.eventLoopP99Ms >= 250) {
       log(`event-loop lag p95=${status.eventLoopP95Ms}ms p99=${status.eventLoopP99Ms}ms max=${status.eventLoopMaxMs}ms`);
     }
+    // Legacy external runtime hosts may still report shard-local lag. The
+    // production in-process host is already covered by daemon loop telemetry.
+    const shards = sessionRuntimeHost?.status?.shards || [];
+    const lagging = shards.filter((shard) => Number(shard?.lag?.p99Ms) >= 250 || shard?.degraded);
+    if (lagging.length > 0) {
+      log(`session runtime shard lag ${lagging.map((shard) => (
+        `#${shard.index}${shard.degraded ? '(quarantined)' : ''}`
+        + ` p95=${shard.lag?.p95Ms ?? -1}ms p99=${shard.lag?.p99Ms ?? -1}ms`
+        + ` max=${shard.lag?.maxMs ?? -1}ms runtimes=${shard.runtimes}`
+      )).join(' ')}`);
+    }
     eventLoopDelay.reset();
   }, 30_000);
   eventLoopLagTimer.unref?.();

package/src/standalone/hook-bus/config.mjs

@@ -81,6 +81,7 @@ function pluginHookConfigEntries(dataDir) {
   }
   const entries = [];
   for (const plugin of plugins || []) {
+    if (plugin?.enabled === false) continue;
     const root = String(plugin?.root || '').trim();
     if (!root || !existsSync(root)) continue;
     const id = cleanHookId(plugin.id || plugin.name || plugin.title || root.split(/[\\/]/).pop());

package/src/standalone/plugin-admin.mjs

@@ -242,6 +242,7 @@ function enrichEntry(entry) {
   const name = clean(manifest.name) || clean(manifest.id) || clean(entry.name) || displayNameFromUrl(entry.source);
   return {
     ...entry,
+    enabled: entry.enabled !== false,
     name,
     title: clean(manifest.title) || clean(manifest.displayName) || clean(entry.title) || name,
     version: clean(manifest.version) || clean(entry.version) || null,
@@ -280,6 +281,7 @@ export function addPlugin(sourceInput, { dataDir = resolvePluginData(), name } =
       title: clean(manifest.title) || clean(manifest.displayName) || clean(name) || displayNameFromUrl(normalized.displaySource),
       version: clean(manifest.version) || null,
       description: clean(manifest.description),
+      enabled: true,
       installedAt: nowIso(),
       updatedAt: nowIso(),
     };
@@ -338,6 +340,21 @@ export function updatePlugin(idOrName, { dataDir = resolvePluginData() } = {}) {
   });
 }
 
+export function setPluginEnabled(idOrName, enabled, { dataDir = resolvePluginData() } = {}) {
+  const key = clean(idOrName);
+  if (!key) throw new Error('plugin id/name is required');
+  return mutateRegistry(dataDir, (registry) => {
+    const index = pluginIndex(registry, key);
+    if (index < 0) throw new Error(`plugin not registered: ${key}`);
+    const next = {
+      ...registry.plugins[index],
+      enabled: enabled !== false,
+    };
+    registry.plugins[index] = next;
+    return enrichEntry(next);
+  });
+}
+
 export function removePlugin(idOrName, { dataDir = resolvePluginData() } = {}) {
   const key = clean(idOrName);
   if (!key) throw new Error('plugin id/name is required');

package/src/standalone/plugin-admin.test.mjs

@@ -18,7 +18,9 @@ import {
   _publishManagedPluginRoot,
   addPlugin,
   listRegisteredPlugins,
+  setPluginEnabled,
 } from './plugin-admin.mjs';
+import { hookConfigEntries } from './hook-bus/config.mjs';
 
 test('plugin registry persists atomically with owner-only permissions', () => {
   const root = mkdtempSync(join(tmpdir(), 'mixdog-plugin-registry-'));
@@ -33,6 +35,11 @@ test('plugin registry persists atomically with owner-only permissions', () => {
     const registry = JSON.parse(readFileSync(registryPath, 'utf8'));
     assert.equal(registry.plugins.length, 1);
     assert.equal(listRegisteredPlugins({ dataDir })[0].name, 'local-test');
+    assert.equal(listRegisteredPlugins({ dataDir })[0].enabled, true);
+    assert.equal(hookConfigEntries(dataDir, root).some((entry) => entry.sourceType === 'plugin'), true);
+    setPluginEnabled('local-test', false, { dataDir });
+    assert.equal(listRegisteredPlugins({ dataDir })[0].enabled, false);
+    assert.equal(hookConfigEntries(dataDir, root).some((entry) => entry.sourceType === 'plugin'), false);
     if (process.platform !== 'win32') {
       assert.equal(statSync(registryPath).mode & 0o777, 0o600);
     }

package/src/standalone/provider-admin.mjs

@@ -44,6 +44,7 @@ import {
 
 const API_PROVIDERS = Object.freeze([
   Object.freeze({ id: 'opencode-go', name: 'OpenCode Go API', env: 'OPENCODE_API_KEY', url: 'https://opencode.ai' }),
+  Object.freeze({ id: 'openrouter', name: 'OpenRouter', env: 'OPENROUTER_API_KEY', url: 'https://openrouter.ai/keys' }),
   Object.freeze({ id: 'openai', name: 'OpenAI API', env: 'OPENAI_API_KEY', url: 'https://platform.openai.com/api-keys' }),
   Object.freeze({ id: 'anthropic', name: 'Anthropic API', env: 'ANTHROPIC_API_KEY', url: 'https://console.anthropic.com/settings/keys' }),
   Object.freeze({ id: 'gemini', name: 'Gemini API', env: 'GEMINI_API_KEY', url: 'https://aistudio.google.com/apikey' }),

package/src/standalone/session-protocol.mjs

@@ -15,6 +15,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getCompactionSettings',
   'getDisabledSkills',
   'getMediaJob',
+  'getMcpServerConfig',
   'getOnboardingStatus',
   'getOAuthProviderLoginStatus',
   'getOutputStyle',
@@ -79,6 +80,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'deleteWorkflow',
   'enablePluginMcp',
   'forgetProviderAuth',
+  'goalControl',
   'inheritFrom',
   'loginOAuthProvider',
   'loginOpenCodeGoUsage',
@@ -107,10 +109,12 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'runScheduleNow',
   'runUpdateNow',
   'saveAgentDefinition',
+  'saveMcpServer',
   'saveOpenAIUsageSessionKey',
   'saveOpenCodeGoUsageAuth',
   'saveProviderApiKey',
   'saveSchedule',
+  'saveSkill',
   'saveWebhook',
   'saveWorkflowPack',
   'selectTools',
@@ -129,6 +133,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setMemoryToolsEnabled',
   'setModel',
   'setOutputStyle',
+  'setPluginEnabled',
   'setProfile',
   'setProgressHint',
   'setRecapEnabled',

package/src/standalone/session-runtime-agent-control-client.mjs

@@ -0,0 +1,133 @@
+'use strict';
+
+// Runtime-shard client for distributed Agent control.
+//
+// A Lead runtime and every Subagent it creates used to share one worker
+// process even after top-level session sharding. Agent control now crosses the
+// existing shard IPC link: the daemon chooses a target shard, while the target
+// keeps the ordinary persistent Agent tool/tag/session implementation.
+import { safeIpcSend } from '../runtime/shared/safe-ipc-send.mjs';
+import { isSessionRuntimeWorkerProcess } from '../runtime/shared/child-spawn-remote.mjs';
+
+const pending = new Map();
+let sequence = 0;
+let listening = false;
+
+function remoteError(body) {
+  const error = new Error(String(body?.message || 'remote agent control failed'));
+  if (body?.name) error.name = String(body.name);
+  if (body?.stack) error.stack = String(body.stack);
+  if (body?.code) error.code = String(body.code);
+  return error;
+}
+
+function ensureListener() {
+  if (listening) return;
+  listening = true;
+  process.on('message', (message) => {
+    if (!message || message.type !== 'agent-control-result') return;
+    const controlId = String(message.controlId || '');
+    const request = pending.get(controlId);
+    if (!request) return;
+    pending.delete(controlId);
+    request.cleanup();
+    if (message.ok === false) request.reject(remoteError(message.error));
+    else request.resolve(message.value);
+  });
+  process.on('disconnect', () => {
+    for (const [controlId, request] of pending) {
+      pending.delete(controlId);
+      request.cleanup();
+      request.reject(new Error('runtime shard disconnected during agent control'));
+    }
+  });
+}
+
+export function remoteAgentControlEnabled(env = process.env) {
+  return isSessionRuntimeWorkerProcess(env)
+    && typeof process.send === 'function'
+    && process.connected === true;
+}
+
+export function executeRemoteAgentControl(args = {}, context = {}) {
+  if (!remoteAgentControlEnabled()) {
+    return Promise.reject(new Error('remote agent control is unavailable'));
+  }
+  ensureListener();
+  const controlId = `agent-control-${process.pid}-${++sequence}`;
+  const signal = context?.signal || null;
+  if (signal?.aborted) {
+    return Promise.reject(signal.reason instanceof Error
+      ? signal.reason
+      : new Error(String(signal.reason || 'agent control canceled')));
+  }
+  return new Promise((resolve, reject) => {
+    let timer = null;
+    let onAbort = null;
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      timer = null;
+      if (onAbort && signal) {
+        try { signal.removeEventListener('abort', onAbort); } catch {}
+      }
+      onAbort = null;
+    };
+    pending.set(controlId, { resolve, reject, cleanup });
+    if (signal) {
+      onAbort = () => {
+        safeIpcSend(process, {
+          type: 'agent-control-cancel',
+          controlId,
+          reason: String(signal.reason?.message || signal.reason || 'agent control canceled'),
+        }, { onError: () => {} });
+        const request = pending.get(controlId);
+        if (!request) return;
+        pending.delete(controlId);
+        cleanup();
+        reject(signal.reason instanceof Error
+          ? signal.reason
+          : new Error(String(signal.reason || 'agent control canceled')));
+      };
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+    timer = setTimeout(() => {
+      const request = pending.get(controlId);
+      if (!request) return;
+      pending.delete(controlId);
+      cleanup();
+      reject(new Error('remote agent control timed out'));
+    }, 180_000);
+    timer.unref?.();
+    const sent = safeIpcSend(process, {
+      type: 'agent-control',
+      controlId,
+      args: args && typeof args === 'object' ? args : {},
+      context: {
+        callerCwd: typeof context?.callerCwd === 'string' ? context.callerCwd : null,
+        invocationSource: typeof context?.invocationSource === 'string'
+          ? context.invocationSource
+          : null,
+        callerSessionId: typeof context?.callerSessionId === 'string'
+          ? context.callerSessionId
+          : null,
+        clientHostPid: Number(context?.clientHostPid) || null,
+      },
+    }, {
+      onError: (error) => {
+        const request = pending.get(controlId);
+        if (!request) return;
+        pending.delete(controlId);
+        cleanup();
+        reject(error);
+      },
+    });
+    if (!sent) {
+      const request = pending.get(controlId);
+      if (request) {
+        pending.delete(controlId);
+        cleanup();
+        reject(new Error('runtime shard IPC is unavailable'));
+      }
+    }
+  });
+}

package/src/standalone/session-runtime-agent-control-client.test.mjs

@@ -0,0 +1,71 @@
+import assert from 'node:assert/strict';
+import { fork } from 'node:child_process';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+const CLIENT_URL = new URL('./session-runtime-agent-control-client.mjs', import.meta.url).href;
+
+test('runtime shard Agent client sends serializable context and receives the routed result', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'mixdog-agent-control-client-'));
+  const entry = join(dir, 'client.mjs');
+  await writeFile(entry, `
+process.env.MIXDOG_SESSION_RUNTIME_WORKER_PID = String(process.pid);
+const client = await import(${JSON.stringify(CLIENT_URL)});
+const value = await client.executeRemoteAgentControl(
+  { type: 'spawn', tag: 'routed', agent: 'worker', prompt: 'run' },
+  {
+    callerCwd: 'C:/Project/test',
+    invocationSource: 'model-tool',
+    callerSessionId: 'sess_lead',
+    clientHostPid: 4242,
+  },
+);
+process.send({ type: 'report', value });
+`, 'utf8');
+
+  try {
+    const observed = await new Promise((resolve, reject) => {
+      const child = fork(entry, [], {
+        stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+        env: { ...process.env },
+      });
+      const timer = setTimeout(() => {
+        try { child.kill(); } catch {}
+        reject(new Error('agent control client test timed out'));
+      }, 10_000);
+      child.on('message', (message) => {
+        if (message?.type === 'agent-control') {
+          assert.deepEqual(message.args, {
+            type: 'spawn',
+            tag: 'routed',
+            agent: 'worker',
+            prompt: 'run',
+          });
+          assert.deepEqual(message.context, {
+            callerCwd: 'C:/Project/test',
+            invocationSource: 'model-tool',
+            callerSessionId: 'sess_lead',
+            clientHostPid: 4242,
+          });
+          child.send({
+            type: 'agent-control-result',
+            controlId: message.controlId,
+            ok: true,
+            value: 'agent task: task_routed',
+          });
+          return;
+        }
+        if (message?.type !== 'report') return;
+        clearTimeout(timer);
+        try { child.kill(); } catch {}
+        resolve(message.value);
+      });
+      child.on('error', reject);
+    });
+    assert.equal(observed, 'agent task: task_routed');
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/src/standalone/session-runtime-dispatch-cancel.test.mjs

@@ -0,0 +1,139 @@
+// Cold-start cancellation contract, exercised against the REAL runtime worker
+// child (no stub): a cancel that arrives before or during the dispatch's
+// module/provider cold start must never be answered "not running" and then let
+// the dispatch run anyway.
+import assert from 'node:assert/strict';
+import { fork } from 'node:child_process';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import test from 'node:test';
+
+const WORKER_ENTRY = fileURLToPath(new URL('./session-runtime-worker.mjs', import.meta.url));
+const REPO_ROOT = join(dirname(WORKER_ENTRY), '..', '..');
+
+function startWorker(runtimeRoot) {
+  const child = fork(WORKER_ENTRY, [], {
+    cwd: REPO_ROOT,
+    execArgv: [],
+    stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+    env: {
+      ...process.env,
+      MIXDOG_RUNTIME_ROOT: runtimeRoot,
+      MIXDOG_DATA_DIR: runtimeRoot,
+      MIXDOG_SESSION_RUNTIME_SHARD: '0',
+      MIXDOG_SESSION_RUNTIME_SHARD_COUNT: '2',
+    },
+  });
+  const responses = new Map();
+  const waiters = new Map();
+  child.on('message', (message) => {
+    if (message?.type !== 'response') return;
+    const id = String(message.requestId || '');
+    const waiter = waiters.get(id);
+    if (waiter) {
+      waiters.delete(id);
+      waiter(message);
+      return;
+    }
+    responses.set(id, message);
+  });
+  const send = (payload) => child.send(payload);
+  const wait = (requestId, timeoutMs = 30_000) => new Promise((resolve, reject) => {
+    const settled = responses.get(requestId);
+    if (settled) {
+      responses.delete(requestId);
+      resolve(settled);
+      return;
+    }
+    const timer = setTimeout(
+      () => reject(new Error(`timed out waiting for ${requestId}`)),
+      timeoutMs,
+    );
+    waiters.set(requestId, (message) => { clearTimeout(timer); resolve(message); });
+  });
+  return { child, send, wait };
+}
+
+async function stopWorker(worker) {
+  try {
+    worker.send({ type: 'shutdown', requestId: 'shutdown-1', reason: 'test complete' });
+    await worker.wait('shutdown-1', 8_000).catch(() => {});
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  } finally {
+    try { worker.child.kill(); } catch {}
+  }
+}
+
+test('a cancel that arrives before the dispatch is retained and aborts it', async () => {
+  const runtimeRoot = await mkdtemp(join(tmpdir(), 'mixdog-dispatch-cancel-'));
+  const worker = startWorker(runtimeRoot);
+  try {
+    worker.send({
+      type: 'agent-dispatch-cancel',
+      requestId: 'cancel-early',
+      dispatchId: 'dispatch-cold',
+      reason: 'user aborted during cold start',
+    });
+    const cancel = await worker.wait('cancel-early', 15_000);
+    assert.equal(cancel.ok, true);
+    // Never "cancelled: false": an unknown id means not-registered-YET.
+    assert.equal(cancel.value.cancelled, true);
+    assert.equal(cancel.value.retained, true);
+
+    const startedAt = Date.now();
+    worker.send({
+      type: 'agent-dispatch',
+      requestId: 'dispatch-cold-1',
+      dispatchId: 'dispatch-cold',
+      agent: 'memory',
+      params: { prompt: 'must never run' },
+    });
+    const dispatch = await worker.wait('dispatch-cold-1', 20_000);
+    assert.equal(dispatch.ok, false);
+    assert.match(String(dispatch.error?.message || ''), /user aborted during cold start/);
+    // The abort is adopted at registration — before the orchestrator/provider
+    // cold start, which alone takes seconds in this worker.
+    assert.ok(
+      Date.now() - startedAt < 3_000,
+      'aborted dispatch never entered module/provider setup',
+    );
+  } finally {
+    await stopWorker(worker);
+    await rm(runtimeRoot, { recursive: true, force: true });
+  }
+});
+
+test('a cancel racing a cold-start dispatch is never answered "not running"', async () => {
+  const runtimeRoot = await mkdtemp(join(tmpdir(), 'mixdog-dispatch-cancel-warm-'));
+  const worker = startWorker(runtimeRoot);
+  try {
+    worker.send({
+      type: 'agent-dispatch',
+      requestId: 'dispatch-warm-1',
+      dispatchId: 'dispatch-warm',
+      agent: 'memory',
+      params: { prompt: 'cancelled while importing' },
+    });
+    // The cold start compiles the orchestrator graph and blocks this loop, so
+    // the cancel frame can only be handled once that window closes. Whichever
+    // side wins, the abort must be honoured or retained — never dropped with
+    // `cancelled: false`, which is what let a canceled dispatch keep running.
+    worker.send({
+      type: 'agent-dispatch-cancel',
+      requestId: 'cancel-warm',
+      dispatchId: 'dispatch-warm',
+      reason: 'aborted mid cold start',
+    });
+    const cancel = await worker.wait('cancel-warm', 60_000);
+    assert.equal(cancel.ok, true);
+    assert.equal(cancel.value.cancelled, true);
+
+    const dispatch = await worker.wait('dispatch-warm-1', 60_000);
+    assert.equal(dispatch.ok, false);
+  } finally {
+    await stopWorker(worker);
+    await rm(runtimeRoot, { recursive: true, force: true });
+  }
+});

package/src/standalone/session-runtime-host-factory.mjs

@@ -0,0 +1,17 @@
+import { createInlineSessionRuntimeHost } from './session-runtime-inline-host.mjs';
+import { createSessionRuntimeHost } from './session-runtime-host.mjs';
+
+export function resolveSessionRuntimeMode(value = process.env.MIXDOG_SESSION_RUNTIME_MODE) {
+  const mode = String(value || 'inline').trim().toLowerCase();
+  if (mode === 'inline') return 'inline';
+  if (mode === 'process') return 'process';
+  throw new Error(`unsupported MIXDOG_SESSION_RUNTIME_MODE=${JSON.stringify(value)}`);
+}
+
+export function createDaemonSessionRuntimeHost(options = {}, {
+  createInline = createInlineSessionRuntimeHost,
+  createProcess = createSessionRuntimeHost,
+  mode = resolveSessionRuntimeMode(),
+} = {}) {
+  return mode === 'process' ? createProcess(options) : createInline(options);
+}