mixdog 0.9.95 → 0.9.97

package/src/session-runtime/runtime-core.mjs

@@ -3,6 +3,7 @@ import { createSessionTitleController } from './session-title.mjs';
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 import { performance } from 'node:perf_hooks';
+import { fileURLToPath } from 'node:url';
 import keychain from '../lib/keychain-cjs.cjs';
 import './hitch-profile.mjs';
 import { ensureStandaloneEnvironment } from '../standalone/seeds.mjs';
@@ -10,8 +11,8 @@ import { createStandaloneAgent } from '../standalone/agent-tool.mjs';
 import { isAgentOwner } from '../runtime/agent/orchestrator/agent-owner.mjs';
 import { EXPLORE_TOOL, runExplore } from '../standalone/explore-tool.mjs';
 import { createStandaloneChannelWorker } from '../standalone/channel-worker.mjs';
-import { createStandaloneMemoryRuntime } from '../standalone/memory-runtime-proxy.mjs';
 import { createStandaloneHookBus } from '../standalone/hook-bus.mjs';
+import { getStandaloneMemoryRuntime } from '../standalone/memory-runtime-proxy.mjs';
 import { createRemoteTransitionQueue } from './remote-transition-queue.mjs';
 import { writeLastSessionCwd } from '../runtime/shared/user-cwd.mjs';
 import { cancelBackgroundTasks } from '../runtime/shared/background-tasks.mjs';
@@ -67,8 +68,8 @@ import {
   saveTelegramToken,
   saveSchedule,
   saveWebhook,
-  setBackend,
-  setBackendAsync,
+  setChannelProvider,
+  setChannelProviderAsync,
   setScheduleEnabled,
   setWebhookEnabled,
   setWebhookConfig,
@@ -260,13 +261,10 @@ import {
   SEARCH_RUNTIME,
   SEARCH_TOOL_DEFS,
   MEMORY_TOOL_DEFS,
-  MEMORY_RUNTIME,
   CHANNEL_TOOL_DEFS,
-  CHANNEL_WORKER_ENTRY,
   CODE_GRAPH_TOOL_DEFS,
   CODE_GRAPH_RUNTIME,
   STATUSLINE_SESSION_ROUTES,
-  SESSION_RUNTIME_DIR,
   STANDALONE_SOURCE_ROOT,
   STANDALONE_ROOT,
   STANDALONE_DATA_DIR,
@@ -297,6 +295,7 @@ const searchCapableFor = makeSearchCapableFor(normalizeSearchProviderId, isSearc
 const KEYCHAIN_PREWARM_WAIT_MS = 5000;
 
 const outputStyleStatus = (dataDir = STANDALONE_DATA_DIR, opts = {}) => outputStyleStatusRaw(STANDALONE_ROOT, dataDir || STANDALONE_DATA_DIR, opts);
+const MEMORY_RUNTIME_ENTRY = fileURLToPath(new URL('../runtime/memory/index.mjs', import.meta.url));
 // Workflow/agent pack loaders bound to this runtime's root/data layout.
 const {
   listWorkflowPacks,
@@ -417,28 +416,30 @@ export async function createMixdogSessionRuntime({
   // seconds. Timer is unref'd and first fires after CLEANUP_INITIAL_DELAY_MS
   // (5min), so this adds zero boot-path cost.
   try { mgr.startIdleCleanup?.(); } catch { /* cleanup is best-effort */ }
-  const memoryRuntime = createStandaloneMemoryRuntime({
-    // Entry constants are module-relative ('../runtime/...'); resolve against
-    // this module's dir, not STANDALONE_ROOT, or the 'src/' segment is lost.
-    entry: join(SESSION_RUNTIME_DIR, MEMORY_RUNTIME),
-    dataDir: pluginDataDir,
-    cwd,
-  });
   rt.memoryModPromise = null;
   rt.searchModPromise = null;
   rt.codeGraphModPromise = null;
 
-  // Memory module is always-on. `memoryEnabled()` is kept as a thin alias that
-  // now always returns true (callers/compaction helpers still reference it);
-  // the user-facing toggle is `recap` (background cycles only), read via
-  // recapEnabled(config).
-  const memoryEnabled = () => true;
+  // Memory is always-on. The user-facing toggle is `recap` (background cycles
+  // only), read via recapEnabled(config).
   const recapEnabledFn = () => recapEnabled(rt.config, true);
   const channelsEnabled = () => moduleEnabled(rt.config, 'channels', true);
 
   async function getMemoryModule() {
     const startedAt = performance.now();
-    rt.memoryModPromise ??= Promise.resolve(memoryRuntime);
+    rt.memoryModPromise ??= Promise.resolve().then(() => {
+      const runtime = getStandaloneMemoryRuntime({
+        entry: MEMORY_RUNTIME_ENTRY,
+        dataDir: process.env.MIXDOG_DATA_DIR || cfgMod.getPluginData?.() || STANDALONE_DATA_DIR,
+      });
+      // Session teardown must never stop a process shared by every other live
+      // session. The daemon owns the actual stop()/deregister lifecycle.
+      return {
+        init: () => runtime.init(),
+        handleToolCall: (...args) => runtime.handleToolCall(...args),
+        buildSessionCoreMemoryPayload: (...args) => runtime.buildSessionCoreMemoryPayload(...args),
+      };
+    });
     const mod = await rt.memoryModPromise;
     if (typeof mod?.init === 'function') {
       await mod.init();
@@ -469,10 +470,6 @@ export async function createMixdogSessionRuntime({
 
     const nextConfig = { ...(rt.config || {}) };
     nextConfig.presets = upsertWorkflowPreset(nextConfig.presets, 'lead', leadRoute);
-    nextConfig.workflowRoutes = {
-      ...(nextConfig.workflowRoutes || {}),
-      lead: leadRoute,
-    };
     nextConfig.default = workflowPresetId('lead');
 
     saveConfigAndAdopt(nextConfig);
@@ -534,6 +531,20 @@ export async function createMixdogSessionRuntime({
     channelStartPromise: null,
   };
   rt.activeTurnCount = 0;
+  rt.activeTurnAbortControllers = new Set();
+  const registerActiveTurnController = (controller) => {
+    rt.activeTurnAbortControllers.add(controller);
+    return () => rt.activeTurnAbortControllers.delete(controller);
+  };
+  const abortActiveTurns = (reason) => {
+    let aborted = false;
+    for (const controller of [...rt.activeTurnAbortControllers]) {
+      if (controller.signal.aborted) continue;
+      aborted = true;
+      try { controller.abort(reason); } catch {}
+    }
+    return aborted;
+  };
   rt.firstTurnCompleted = false;
   function hookTranscriptPath(sessionId) {
     const id = clean(sessionId);
@@ -746,7 +757,6 @@ export async function createMixdogSessionRuntime({
   };
   const channelsStartedAt = performance.now();
   const channels = createStandaloneChannelWorker({
-    entry: join(SESSION_RUNTIME_DIR, CHANNEL_WORKER_ENTRY),
     rootDir: STANDALONE_ROOT,
     dataDir: cfgMod.getPluginData(),
     cwd,
@@ -971,8 +981,8 @@ export async function createMixdogSessionRuntime({
     adoptConfig,
     saveConfigAndAdopt,
     flushConfigSave,
-    flushBackendSave,
-    scheduleBackendSave,
+    flushChannelProviderSave,
+    scheduleChannelProviderSave,
     scheduleSkillsSave,
     flushSkillsSave,
     flushOutputStyleSave,
@@ -992,8 +1002,8 @@ export async function createMixdogSessionRuntime({
     getRoute: () => rt.route,
     cfgMod,
     sharedCfgMod,
-    setBackend,
-    setBackendAsync,
+    setChannelProvider,
+    setChannelProviderAsync,
     setConfiguredShell,
     normalizeSystemShellConfig,
     normalizeSearchRouteConfig,
@@ -1198,7 +1208,6 @@ export async function createMixdogSessionRuntime({
     reg,
     cfgMod,
     activeWorkflowContext,
-    memoryEnabled,
     hooks,
     hookCommonPayload,
     mcpClient,
@@ -1253,7 +1262,7 @@ export async function createMixdogSessionRuntime({
     channels,
     channelsEnabled,
     hasActiveAutomation,
-    flushBackendSave,
+    flushChannelProviderSave,
     invokeChannelStart,
     createCurrentSession,
     ensureRemoteTranscriptWriter,
@@ -1304,7 +1313,7 @@ export async function createMixdogSessionRuntime({
   // was toggled into) remote mode. Non-remote sessions never contend for the
   // channel; see startRemote()/stopRemote() and the `/remote` toggle.
   // A manual `mixdog --remote` request is deferred past the TUI's
-  // first frame. startRemote() front-loads heavy work — memory daemon fork
+  // first frame. startRemote() front-loads memory initialization
   // (PG + forced ONNX embed warmup in the child), eager session create, and
   // the channel-worker fork — and running it inline here interleaves that
   // CPU/disk load with engine boot, visibly delaying the first ink frame by
@@ -1323,7 +1332,7 @@ export async function createMixdogSessionRuntime({
   } else {
     // Automation decoupling (user decision): enabled schedules/webhooks boot
     // the worker on their own — no remote flag, no remote.autoStart, and no
-    // messaging backend. A later explicit Remote ON promotes the same
+    // messaging provider. A later explicit Remote ON promotes the same
     // daemon without restarting schedules or webhooks.
     prewarmTimers.channelStartTimer = setTimeout(() => {
       prewarmTimers.channelStartTimer = null;
@@ -1341,7 +1350,7 @@ export async function createMixdogSessionRuntime({
 
   // Pure settings-delegate methods (onboarding status/skip, autoClear, profile,
   // compaction, recap/memory, channels, systemShell, update settings, channel
-  // token save/forget, setBackend). Extracted to session-runtime/settings-api.mjs
+  // token save/forget, setChannelProvider). Extracted to session-runtime/settings-api.mjs
   // and SPREAD into the API object below so the external surface is unchanged.
   const settingsApi = createSettingsApi({
     getConfig: () => rt.config,
@@ -1350,7 +1359,7 @@ export async function createMixdogSessionRuntime({
     getRemoteEnabled: () => rt.remoteEnabled,
     adoptConfig,
     saveConfigAndAdopt,
-    scheduleBackendSave,
+    scheduleChannelProviderSave,
     scheduleSkillsSave,
     cfgMod,
     hasOwn,
@@ -1368,7 +1377,6 @@ export async function createMixdogSessionRuntime({
     parseDurationMs,
     formatDurationMs,
     localPackageVersion,
-    memoryEnabled,
     recapEnabledFn,
     channelsEnabled,
     autoUpdateEnabled,
@@ -1392,11 +1400,11 @@ export async function createMixdogSessionRuntime({
     forgetDiscordToken,
     saveTelegramToken,
     forgetTelegramToken,
-    setBackend,
+    setChannelProvider,
   });
 
   const channelConfigApi = createChannelConfigApi({
-    flushBackendSave,
+    flushChannelProviderSave,
     channels,
     reloadChannelsSoon,
     // Automation saved mid-session boots the worker (claim-if-vacant) even
@@ -1445,6 +1453,8 @@ export async function createMixdogSessionRuntime({
     getMemoryModPromise: () => rt.memoryModPromise,
     setMemoryModPromise: (v) => { rt.memoryModPromise = v; },
     setSessionNeedsCwdRefresh: (v) => { rt.sessionNeedsCwdRefresh = v; },
+    getReservedSessionId: () => rt.reservedSessionId,
+    abortActiveTurns,
     hooks,
     hookCommonPayload,
     mgr,
@@ -1456,7 +1466,7 @@ export async function createMixdogSessionRuntime({
     warmupTimers,
     prewarmTimers,
     flushConfigSave,
-    flushBackendSave,
+    flushChannelProviderSave,
     flushOutputStyleSave,
     flushAllConfigSavesAsync,
     withTeardownDeadline,
@@ -1624,6 +1634,7 @@ export async function createMixdogSessionRuntime({
     mcpTurnGraceMs,
     awaitRoutePreparation: () => routePreparation.wait(),
     getReservedSessionId: () => rt.reservedSessionId,
+    registerActiveTurnController,
     sessionTitles,
   });
 
@@ -1633,7 +1644,11 @@ export async function createMixdogSessionRuntime({
     ...providerAuthApi,
     ...mediaApi,
     // Turn-scoped worktree review plus exact child apply_patch attribution.
-    getTurnReviewDiff: () => getTurnSnapshotReviewDiff(rt.currentCwd, rt.session?.id),
+    getTurnReviewDiff: (options = {}) => getTurnSnapshotReviewDiff(
+      rt.currentCwd,
+      rt.session?.id,
+      options,
+    ),
     revertTurnReviewFile: (file) => revertTurnSnapshotReviewFile(
       rt.currentCwd,
       rt.session?.id,
@@ -1651,6 +1666,15 @@ export async function createMixdogSessionRuntime({
         throw new Error(`session ${rt.session.id} is already materialized`);
       }
       rt.reservedSessionId = id;
+      // Reservation is the earliest safe point to prepare keychain, memory,
+      // provider metadata, hooks, and the provider transport. This starts no
+      // model response and therefore incurs no inference/token usage. The first
+      // submit joins this single-flight promise instead of paying cold setup.
+      void createCurrentSession('reservation').catch((error) => {
+        bootProfile('session:reservation-prewarm-failed', {
+          error: error?.message || String(error),
+        });
+      });
       return id;
     },
     get provider() {

package/src/session-runtime/runtime-tunables.mjs

@@ -24,10 +24,10 @@ export function readRuntimeTunables() {
     statuslineUsageRefreshDelayMs: envDelayMs('MIXDOG_STATUSLINE_USAGE_REFRESH_MS', 240_000, { min: 30_000, max: 540_000 }),
     channelStartDelayMs: envDelayMs('MIXDOG_CHANNEL_START_DELAY_MS', 10_000, { min: 0, max: 120_000 }),
     backgroundBusyRetryMs: envDelayMs('MIXDOG_BACKGROUND_BUSY_RETRY_MS', 1_000, { min: 50, max: 10_000 }),
-    // MCP startup must not own the first-token critical path. Servers that do
-    // not connect inside this small grace period join through the existing
-    // late-tool announcement path on the next turn.
-    mcpTurnGraceMs: envDelayMs('MIXDOG_MCP_TURN_GRACE_MS', 150, { min: 0, max: 2_000 }),
+    // MCP startup never owns the first-token critical path by default. Already
+    // connected tools fold synchronously; in-flight servers join through the
+    // late-tool announcement path. Operators may opt back into a grace window.
+    mcpTurnGraceMs: envDelayMs('MIXDOG_MCP_TURN_GRACE_MS', 0, { min: 0, max: 2_000 }),
     // Boot-time remote start is deferred past the first frame; see the caller.
     remoteAutoStartDelayMs: envDelayMs('MIXDOG_REMOTE_AUTOSTART_DELAY_MS', 1_500, { min: 0, max: 60_000 }),
     providerWarmupEnabled: !envFlag('MIXDOG_DISABLE_PROVIDER_WARMUP')

package/src/session-runtime/self-update.mjs

@@ -14,7 +14,7 @@ import {
 
 const STAGE_POLL_MS = 3_000;
 const STAGE_POLL_MAX_MS = 10 * 60 * 1000;
-// A backend daemon can host many session runtimes. Their boot controllers all
+// A daemon can host many session runtimes. Their boot controllers all
 // need the same update state, not one forced registry request per pane.
 const processBootChecks = new Map();
 

package/src/session-runtime/session-lifecycle.mjs

@@ -18,6 +18,7 @@ import { envFlag } from './env.mjs';
 import { createPrewarmSchedulers } from './prewarm.mjs';
 import { hasActiveAutomation } from '../standalone/channel-admin.mjs';
 import { createRemoteTranscript } from './remote-transcript.mjs';
+import { runAbortable, throwIfAborted } from '../runtime/shared/abort-race.mjs';
 export function createSessionLifecycle({
   rt,
   collectProviderModels,
@@ -30,7 +31,6 @@ export function createSessionLifecycle({
   reg,
   cfgMod,
   activeWorkflowContext,
-  memoryEnabled,
   hooks,
   hookCommonPayload,
   mcpClient,
@@ -62,9 +62,10 @@ export function createSessionLifecycle({
   codeGraphPrewarmEnabled,
   prewarmState,
 }) {
-  async function resolveMissingRouteModelForFirstTurn() {
+  async function resolveMissingRouteModelForFirstTurn(signal = null) {
     if (routeHasModel()) return rt.route;
-    const models = await collectProviderModels();
+    const models = await runAbortable(signal, () => collectProviderModels());
+    throwIfAborted(signal);
     const picked = models[0] || null;
     if (!picked) {
       throw new Error('No provider models available. Open /providers to sign in, then /model to choose a model.');
@@ -78,10 +79,14 @@ export function createSessionLifecycle({
     return rt.route;
   }
 
-  async function refreshRouteEffort(modelMetaOverride = null, expectedRoute = null) {
+  async function refreshRouteEffort(modelMetaOverride = null, expectedRoute = null, signal = null) {
     const targetRoute = expectedRoute || rt.route;
-    await ensureProvidersReady(ensureProviderEnabled(rt.config, targetRoute.provider));
-    const modelMeta = modelMetaOverride || await lookupModelMeta(targetRoute.provider, targetRoute.model);
+    await runAbortable(signal, () => ensureProvidersReady(ensureProviderEnabled(rt.config, targetRoute.provider)));
+    const modelMeta = modelMetaOverride || await runAbortable(
+      signal,
+      () => lookupModelMeta(targetRoute.provider, targetRoute.model),
+    );
+    throwIfAborted(signal);
     // A rapid second resume/model change can replace the route while provider
     // metadata is loading. Never let the older completion overwrite it.
     if (expectedRoute && rt.route !== expectedRoute) return null;
@@ -127,8 +132,12 @@ export function createSessionLifecycle({
     return await createCurrentSession();
   }
 
-  async function createCurrentSession(reason = 'demand') {
-    if (rt.sessionCreatePromise) return await rt.sessionCreatePromise;
+  async function createCurrentSession(reason = 'demand', options = {}) {
+    const signal = options?.signal || null;
+    throwIfAborted(signal);
+    if (rt.sessionCreatePromise) {
+      return await runAbortable(signal, () => rt.sessionCreatePromise, 'Session creation aborted');
+    }
     if (rt.session?.id && !rt.sessionNeedsCwdRefresh) {
       const liveSession = mgr.getSession(rt.session.id);
       if (liveSession && liveSession.closed !== true && liveSession.status !== 'closed') {
@@ -140,23 +149,34 @@ export function createSessionLifecycle({
 
     const startedAt = performance.now();
     bootProfile('session:create:start', { mode: rt.mode, reason });
+    // A daemon reservation is deliberate user-think-time prewarm. Start the
+    // one-time agent-loop module load now so the first real prompt does not pay
+    // its ~100ms dynamic-import graph immediately before provider.send.
+    if (reason === 'reservation' && typeof mgr.prewarmAgentLoop === 'function') {
+      void mgr.prewarmAgentLoop().catch((error) => {
+        bootProfile('agent-loop:prewarm-failed', { error: error?.message || String(error) });
+      });
+    }
     const promise = (async () => {
       // Demand-only: this starts only after the user submits (unless an
       // explicitly enabled prewarm caller asks for a session). Core-memory
       // startup does not depend on keychain/provider readiness, so overlap the
       // two cold paths instead of paying their bounded waits serially.
-      const coreMemoryContextPromise = loadCoreMemoryContext();
-      await awaitKeychainPrewarm();
+      const coreMemoryContextPromise = Promise.resolve(loadCoreMemoryContext());
+      coreMemoryContextPromise.catch(() => {});
+      await runAbortable(signal, () => awaitKeychainPrewarm());
       ensureConfigForRouteProvider();
-      await resolveMissingRouteModelForFirstTurn();
+      await resolveMissingRouteModelForFirstTurn(signal);
       requireModelRoute();
       bootProfile('session:create:route-ready', { ms: (performance.now() - startedAt).toFixed(1) });
       // Route effort waits on provider readiness while the already-started
       // memory load continues independently.
-      const [, coreMemoryContext] = await Promise.all([
-        refreshRouteEffort(),
+      const expectedRoute = rt.route;
+      const [, coreMemoryContext] = await runAbortable(signal, () => Promise.all([
+        refreshRouteEffort(null, expectedRoute, signal),
         coreMemoryContextPromise,
-      ]);
+      ]));
+      throwIfAborted(signal);
       bootProfile('session:create:effort-ready', { ms: (performance.now() - startedAt).toFixed(1) });
       const providerImpl = reg.getProvider(rt.route.provider);
       if (!providerImpl) {
@@ -164,6 +184,7 @@ export function createSessionLifecycle({
       }
       bootProfile('session:create:provider-ready', { ms: (performance.now() - startedAt).toFixed(1) });
       if (rt.closeRequested) throw new Error('runtime is closing');
+      throwIfAborted(signal);
       const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
       // Load the active WORKFLOW.md pack once for both summary + context block.
       const { summary: workflow, context: workflowContext } = activeWorkflowContext(rt.config, dataDir);
@@ -187,7 +208,7 @@ export function createSessionLifecycle({
         workflowContext,
         fast: rt.route.fast === true,
         compaction: rt.config.compaction && typeof rt.config.compaction === 'object'
-          ? normalizeCompactionConfig(rt.config.compaction, { memoryEnabled: memoryEnabled() })
+          ? normalizeCompactionConfig(rt.config.compaction)
           : undefined,
       };
       if (hasOwn(rt.route, 'effort') || rt.route.effectiveEffort) {
@@ -229,7 +250,10 @@ export function createSessionLifecycle({
         const startSource = /resume/i.test(String(reason || ''))
           ? 'resume'
           : (/clear/i.test(String(reason || '')) ? 'clear' : 'startup');
-        const startDispatch = await hooks.dispatch('SessionStart', hookCommonPayload({ session_id: rt.session.id, source: startSource, model: rt.route.model }));
+        const startDispatch = await runAbortable(
+          signal,
+          () => hooks.dispatch('SessionStart', hookCommonPayload({ session_id: rt.session.id, source: startSource, model: rt.route.model })),
+        );
         const startContext = Array.isArray(startDispatch?.additionalContext)
           ? startDispatch.additionalContext.join('\n\n')
           : String(startDispatch?.additionalContext || '');
@@ -238,7 +262,11 @@ export function createSessionLifecycle({
           rt.session.messages.push({ role: 'assistant', content: '.' });
           rt.session.updatedAt = Date.now();
         }
-      } catch { /* best-effort: never break session create */ }
+      } catch {
+        throwIfAborted(signal);
+        // best-effort: ordinary hook failure never breaks session create
+      }
+      throwIfAborted(signal);
       bootProfile('session:create:ready', {
         ms: (performance.now() - startedAt).toFixed(1),
         reason,

package/src/session-runtime/session-title.mjs

@@ -106,7 +106,7 @@ export function resolvedSystemLocale() {
   }
 }
 
-/** Shared backend controller used by every lead surface (TUI and desktop). */
+/** Shared session controller used by every lead surface (TUI and desktop). */
 export function createSessionTitleController(deps = {}) {
   const firstAttempts = new Set();
   const thirdAttempts = new Set();