mixdog 0.9.3 → 0.9.4

package/src/runtime/shared/transcript-writer.mjs

@@ -144,10 +144,33 @@ export function createTranscriptWriter({ mixdogHome, sessionId, cwd, pid } = {})
     });
   }
 
+  // Idempotently create the transcript file as an empty 0-byte file if it
+  // does not already exist. Called on every remote turn (before the first
+  // append) so the channel worker's fs.watch can attach to the path right
+  // away instead of waiting on schedulePendingTranscriptRearm(). Never
+  // truncates an existing transcript: guarded by existsSync + the 'wx'
+  // (exclusive-create) flag, and any EEXIST/other error is swallowed via
+  // logOnce like the other writers.
+  function ensureTranscriptFile() {
+    try {
+      ensureProjectDir();
+      if (existsSync(transcriptPath)) return;
+      try {
+        writeFileSync(transcriptPath, '', { flag: 'wx' });
+      } catch (err) {
+        if (err && err.code === 'EEXIST') return;
+        logOnce(err);
+      }
+    } catch (err) {
+      logOnce(err);
+    }
+  }
+
   return {
     transcriptPath,
     sessionRecordPath,
     writeSessionRecord,
+    ensureTranscriptFile,
     refresh,
     appendAssistant,
     appendToolUse,

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

@@ -154,12 +154,15 @@ export async function checkLatestVersion({ force = false, dataDir } = {}) {
   }
   // Registry unreachable: fall back to a stale cache (if any) rather than
   // reporting "no update info" every time the network hiccups.
-  if (cache && cache.latestVersion) {
+  // Re-read the cache here: a force:true call skips the read above, but a
+  // stale answer still beats none when the network is down.
+  const staleCache = cache || readCache(dataDir);
+  if (staleCache && staleCache.latestVersion) {
     return {
       currentVersion,
-      latestVersion: cache.latestVersion,
-      updateAvailable: isNewerVersion(cache.latestVersion, currentVersion),
-      lastCheckedAt: cache.lastCheckedAt || now,
+      latestVersion: staleCache.latestVersion,
+      updateAvailable: isNewerVersion(staleCache.latestVersion, currentVersion),
+      lastCheckedAt: staleCache.lastCheckedAt || now,
       fromCache: true,
     };
   }

package/src/session-runtime/config-helpers.mjs

@@ -112,6 +112,45 @@ export function ensureProviderEnabled(config, provider) {
 
 const AUTO_CLEAR_DEFAULT_IDLE_MS = 60 * 60 * 1000;
 
+// Provider-aware auto-clear idle-sweep defaults. Rationale mirrors the
+// provider cache TTLs documented in agent-runtime/cache-strategy.mjs
+// (explicit breakpoint / managed-cache windows): Anthropic, Gemini, xAI and
+// Mistral caches run ~1h, Groq's implicit cache persists ~2h, OpenAI/
+// DeepSeek key-prefix/implicit caches persist far longer (~24h), and OpenAI
+// OAuth's in-memory server cache is short-lived (~5-10min), so we round up
+// slightly to 10m to avoid sweeping a still-warm cache. Unknown/
+// unrecognized providers fall back to the 'default' 1h entry.
+export const AUTO_CLEAR_PROVIDER_IDLE_MS = Object.freeze({
+  'anthropic': 60 * 60 * 1000,
+  'anthropic-oauth': 60 * 60 * 1000,
+  'gemini': 60 * 60 * 1000,
+  'groq': 2 * 60 * 60 * 1000,
+  'openai': 24 * 60 * 60 * 1000,
+  'deepseek': 24 * 60 * 60 * 1000,
+  'xai': 60 * 60 * 1000,
+  'openai-oauth': 10 * 60 * 1000,
+  'mistral': 60 * 60 * 1000,
+  'default': AUTO_CLEAR_DEFAULT_IDLE_MS,
+});
+export const AUTO_CLEAR_UNKNOWN_PROVIDER_IDLE_MS = AUTO_CLEAR_PROVIDER_IDLE_MS.default;
+
+// Resolve the auto-clear idle-sweep threshold for a given provider id.
+// Unknown/missing providers fall back to the 'default' 1h entry (above).
+export function autoClearIdleMsForProvider(provider) {
+  const key = clean(provider).toLowerCase();
+  return AUTO_CLEAR_PROVIDER_IDLE_MS[key] ?? AUTO_CLEAR_PROVIDER_IDLE_MS.default;
+}
+
+// Resolve the effective auto-clear idle window for a config + provider:
+// an explicit user-set idleMs (config.autoClear.idleMs) always wins; else
+// fall back to the provider's default; else the global 1h default.
+export function resolveAutoClearIdleMs(config, provider) {
+  const raw = config?.autoClear && typeof config.autoClear === 'object' ? config.autoClear : {};
+  const idleMs = Number(raw.idleMs ?? raw.thresholdMs ?? raw.idleMillis);
+  if (Number.isFinite(idleMs) && idleMs > 0) return Math.max(60_000, Math.round(idleMs));
+  return autoClearIdleMsForProvider(provider);
+}
+
 export function normalizeSystemShellConfig(value = {}) {
   const raw = value && typeof value === 'object' ? value : {};
   const command = clean(raw.command ?? raw.path ?? raw.executable ?? raw.shell);
@@ -138,9 +177,15 @@ export function normalizeSystemShellCommand(value) {
 export function normalizeAutoClearConfig(value = {}) {
   const raw = value && typeof value === 'object' ? value : {};
   const idleMs = Number(raw.idleMs ?? raw.thresholdMs ?? raw.idleMillis);
+  const hasExplicitIdle = Number.isFinite(idleMs) && idleMs > 0;
+  // idleMs: null means "no explicit override" — callers resolve the
+  // effective window via resolveAutoClearIdleMs/provider default. `custom`
+  // tells UI whether the stored idleMs is a user override (true) or the
+  // provider-default mode (false, idleMs null).
   return {
     enabled: raw.enabled !== false,
-    idleMs: Number.isFinite(idleMs) && idleMs > 0 ? Math.max(60_000, Math.round(idleMs)) : AUTO_CLEAR_DEFAULT_IDLE_MS,
+    idleMs: hasExplicitIdle ? Math.max(60_000, Math.round(idleMs)) : null,
+    custom: hasExplicitIdle,
   };
 }
 
@@ -155,7 +200,11 @@ export function normalizeCompactTypeSetting(value, fallback = 'semantic') {
 export function normalizeCompactionConfig(value = {}, { memoryEnabled = true } = {}) {
   const raw = value && typeof value === 'object' ? value : {};
   let compactType = normalizeCompactTypeSetting(raw.compactType ?? raw.compact_type ?? raw.type, 'semantic');
-  if (compactType === 'recall-fasttrack' && memoryEnabled === false) compactType = 'semantic';
+  // Memory is now always-on, so recall-fasttrack no longer downgrades to
+  // semantic. `memoryEnabled` is retained as a param for API compatibility but
+  // is intentionally ignored (fasttrack drains run on-demand regardless of the
+  // recap/background-cycle toggle).
+  void memoryEnabled;
   return {
     ...raw,
     auto: raw.auto !== false && raw.enabled !== false,
@@ -170,6 +219,39 @@ export function moduleEnabled(configLike, name, fallback = true) {
   return fallback !== false;
 }
 
+// Recap toggle: gates ONLY the background memory cycles (1/2/3). The memory
+// module itself (transcript watcher/ingest, on-demand recall/fasttrack drains)
+// is always-on. Default enabled. Reads the dedicated `recap` section; if a
+// legacy `modules.memory === false` flag is present it is honored as recap off
+// (migration folds it into `recap.enabled` on config load).
+export function recapEnabled(configLike, fallback = true) {
+  const entry = configLike?.recap;
+  if (entry && typeof entry === 'object' && entry.enabled === false) return false;
+  // Legacy fallback: pre-migration configs may still carry modules.memory=false.
+  if (configLike?.modules?.memory === false) return false;
+  if (moduleEnabled(configLike, 'memory', true) === false) return false;
+  return fallback !== false;
+}
+
+export function setRecapEnabledInConfig(configLike, enabled) {
+  const next = { ...(configLike || {}) };
+  next.recap = { ...(next.recap || {}), enabled: enabled !== false };
+  // Drop the legacy flag if it was carrying the disabled state.
+  if (next.modules && next.modules.memory === false) {
+    const modules = { ...next.modules };
+    delete modules.memory;
+    next.modules = modules;
+  } else if (next.modules && next.modules.memory && typeof next.modules.memory === 'object') {
+    const modules = { ...next.modules };
+    const memoryMod = { ...modules.memory };
+    delete memoryMod.enabled;
+    if (Object.keys(memoryMod).length === 0) delete modules.memory;
+    else modules.memory = memoryMod;
+    next.modules = modules;
+  }
+  return next;
+}
+
 export function setModuleEnabledInConfig(configLike, name, enabled) {
   const next = { ...(configLike || {}) };
   next.modules = { ...(next.modules || {}) };

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

@@ -0,0 +1,232 @@
+// config-lifecycle.mjs — config reload/save/adopt family + output-style status
+// cache, extracted from mixdog-session-runtime.mjs. Dependency-injected factory:
+// closes over config/searchRoute mutable state via getter/setter injection
+// (getConfig/setConfig/getSearchRoute/setSearchRoute) and shared helpers, so the
+// facade keeps ownership of the mutable locals while the debounce/adopt logic
+// lives here.
+//
+// Debounce rationale (unchanged from the original inline implementation):
+// persisting mixdog-config.json is heavy (cross-process lock, atomic
+// temp+rename, win32 icacls owner-only ACL). Adopt in-memory IMMEDIATELY so
+// same-tick readers see fresh state, and DEBOUNCE the disk write so a burst of
+// toggles collapses into one persist. Three independent debounce channels:
+//   - config save  (cfgMod.saveConfig, agent-section serialize)
+//   - backend save (channel-admin setBackend, file-locked RMW)
+//   - outputStyle  (sharedCfgMod.updateConfig whole-root RMW — cfgMod.saveConfig
+//                   only serializes agent-section fields, so a top-level
+//                   outputStyle would never reach disk via that path)
+
+export const CONFIG_SAVE_DEBOUNCE_MS = 150;
+
+export function createConfigLifecycle({
+  // config mutable-state injection
+  getConfig,
+  setConfig,
+  getSearchRoute,
+  setSearchRoute,
+  getConfigHasSecrets,
+  setConfigHasSecrets,
+  getRoute,
+  // shared modules / helpers
+  cfgMod,
+  sharedCfgMod,
+  setBackend,
+  setConfiguredShell,
+  normalizeSystemShellConfig,
+  normalizeSearchRouteConfig,
+  outputStyleStatus,
+  LAZY_SECRET_PROVIDERS,
+  clean,
+  resolve,
+  performanceNow = () => performance.now(),
+  STANDALONE_DATA_DIR,
+}) {
+  // --- output-style status cache (short TTL, keyed on plugin data dir) --------
+  let outputStyleStatusCache = null;
+  let outputStyleStatusCacheAt = 0;
+  let outputStyleStatusCacheDir = '';
+
+  const getOutputStyleStatusCached = ({ fresh = false } = {}) => {
+    const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
+    const cacheDir = resolve(dataDir);
+    const now = performanceNow();
+    if (
+      !fresh
+      && outputStyleStatusCache
+      && outputStyleStatusCacheDir === cacheDir
+      && now - outputStyleStatusCacheAt < 2500
+    ) {
+      return outputStyleStatusCache;
+    }
+    outputStyleStatusCache = outputStyleStatus(dataDir);
+    outputStyleStatusCacheAt = now;
+    outputStyleStatusCacheDir = cacheDir;
+    return outputStyleStatusCache;
+  };
+  const invalidateOutputStyleStatusCache = () => {
+    outputStyleStatusCache = null;
+    outputStyleStatusCacheAt = 0;
+    outputStyleStatusCacheDir = '';
+  };
+  // In-memory seed of the status cache after an outputStyle select (avoids a
+  // second forced-fresh filesystem scan during the debounce window).
+  const seedOutputStyleStatusCache = (status) => {
+    outputStyleStatusCache = status;
+    outputStyleStatusCacheAt = performanceNow();
+    outputStyleStatusCacheDir = resolve(cfgMod.getPluginData?.() || STANDALONE_DATA_DIR);
+  };
+
+  // --- config adopt -----------------------------------------------------------
+  function adoptConfig(nextConfig, { hasSecrets = getConfigHasSecrets() } = {}) {
+    setConfig(nextConfig);
+    setConfigHasSecrets(hasSecrets === true);
+    const config = getConfig();
+    setConfiguredShell(normalizeSystemShellConfig(config.shell).command);
+    setSearchRoute(
+      normalizeSearchRouteConfig(config.searchRoute)
+        || normalizeSearchRouteConfig(getSearchRoute()),
+    );
+    return config;
+  }
+
+  // --- debounced config save --------------------------------------------------
+  let pendingConfigToSave = null;
+  let configSaveTimer = null;
+
+  function flushConfigSave() {
+    if (configSaveTimer) {
+      clearTimeout(configSaveTimer);
+      configSaveTimer = null;
+    }
+    if (pendingConfigToSave === null) return;
+    const snapshot = pendingConfigToSave;
+    pendingConfigToSave = null;
+    try {
+      cfgMod.saveConfig(snapshot);
+    } catch (err) {
+      process.stderr.write(`[config] debounced saveConfig failed: ${err?.message || err}\n`);
+    }
+  }
+
+  function saveConfigAndAdopt(nextConfig, { hasSecrets = getConfigHasSecrets() } = {}) {
+    // In-memory adopt is synchronous and first so callers that read back the
+    // value immediately (e.g. setProfile -> getProfile) see the new state.
+    const adopted = adoptConfig(nextConfig, { hasSecrets });
+    // Persist the adopted object; coalesce rapid successive changes into one
+    // disk write after CONFIG_SAVE_DEBOUNCE_MS of quiet.
+    pendingConfigToSave = getConfig();
+    if (configSaveTimer) clearTimeout(configSaveTimer);
+    configSaveTimer = setTimeout(flushConfigSave, CONFIG_SAVE_DEBOUNCE_MS);
+    configSaveTimer.unref?.();
+    return adopted;
+  }
+
+  // --- debounced backend switch ----------------------------------------------
+  let pendingBackendName = null;
+  let backendSaveTimer = null;
+
+  function flushBackendSave() {
+    if (backendSaveTimer) {
+      clearTimeout(backendSaveTimer);
+      backendSaveTimer = null;
+    }
+    if (pendingBackendName === null) return;
+    const name = pendingBackendName;
+    pendingBackendName = null;
+    try {
+      setBackend(name);
+    } catch (err) {
+      process.stderr.write(`[channels] debounced setBackend failed: ${err?.message || err}\n`);
+    }
+  }
+
+  function scheduleBackendSave(name) {
+    pendingBackendName = name;
+    if (backendSaveTimer) clearTimeout(backendSaveTimer);
+    backendSaveTimer = setTimeout(flushBackendSave, CONFIG_SAVE_DEBOUNCE_MS);
+    backendSaveTimer.unref?.();
+  }
+
+  // --- debounced top-level outputStyle persist -------------------------------
+  let pendingOutputStyleId = null;
+  let outputStyleSaveTimer = null;
+
+  function flushOutputStyleSave() {
+    if (outputStyleSaveTimer) {
+      clearTimeout(outputStyleSaveTimer);
+      outputStyleSaveTimer = null;
+    }
+    if (pendingOutputStyleId === null) return;
+    const styleId = pendingOutputStyleId;
+    pendingOutputStyleId = null;
+    try {
+      sharedCfgMod.updateConfig((root) => {
+        const next = { ...(root || {}), outputStyle: styleId };
+        if (next.agent && typeof next.agent === 'object' && !Array.isArray(next.agent)) {
+          const agent = { ...next.agent };
+          delete agent.outputStyle;
+          next.agent = agent;
+        }
+        return next;
+      });
+    } catch (err) {
+      process.stderr.write(`[config] debounced outputStyle save failed: ${err?.message || err}\n`);
+    }
+  }
+
+  function scheduleOutputStyleSave(styleId) {
+    pendingOutputStyleId = styleId;
+    if (outputStyleSaveTimer) clearTimeout(outputStyleSaveTimer);
+    outputStyleSaveTimer = setTimeout(flushOutputStyleSave, CONFIG_SAVE_DEBOUNCE_MS);
+    outputStyleSaveTimer.unref?.();
+  }
+
+  // --- reload / ensure --------------------------------------------------------
+  function reloadFullConfig() {
+    // A pending debounced write holds the only copy of the latest change.
+    // Flush it before re-reading from disk so loadConfig() observes (and the
+    // subsequent adopt preserves) that change instead of reverting to a stale
+    // on-disk snapshot.
+    flushConfigSave();
+    return adoptConfig(cfgMod.loadConfig(), { hasSecrets: true });
+  }
+
+  function ensureFullConfig() {
+    if (getConfigHasSecrets()) return getConfig();
+    return reloadFullConfig();
+  }
+
+  function displayConfig() {
+    return getConfig();
+  }
+
+  function ensureConfigForRouteProvider() {
+    const config = getConfig();
+    const providerId = clean(getRoute().provider);
+    const providerCfg = config?.providers?.[providerId];
+    if (getConfigHasSecrets() || LAZY_SECRET_PROVIDERS.has(providerId) || providerCfg?.apiKey) {
+      return config;
+    }
+    return ensureFullConfig();
+  }
+
+  return {
+    // output-style cache
+    getOutputStyleStatusCached,
+    invalidateOutputStyleStatusCache,
+    seedOutputStyleStatusCache,
+    // adopt / save
+    adoptConfig,
+    saveConfigAndAdopt,
+    flushConfigSave,
+    flushBackendSave,
+    scheduleBackendSave,
+    flushOutputStyleSave,
+    scheduleOutputStyleSave,
+    // reload / ensure
+    reloadFullConfig,
+    ensureFullConfig,
+    displayConfig,
+    ensureConfigForRouteProvider,
+  };
+}

package/src/session-runtime/cwd-plugins.mjs

@@ -0,0 +1,226 @@
+// cwd-plugins.mjs — cwd resolution/apply + plugins-status + core-memory context,
+// extracted from mixdog-session-runtime.mjs. Dependency-injected factory that
+// closes over the facade's mutable cwd/config/session state via getter/setter
+// injection (getCurrentCwd/setCurrentCwd/getConfig/getSession/...) plus the MCP
+// glue + prewarm callbacks. The facade keeps ownership of the mutable locals;
+// this module owns the pure logic that was previously inline.
+
+export function createCwdPlugins({
+  // mutable-state injection
+  getCurrentCwd,
+  setCurrentCwd,
+  getConfig,
+  getSession,
+  getRoute,
+  getLastProjectMcpKey,
+  setLastProjectMcpKey,
+  isCodeGraphPrewarmLazy,
+  isCodeGraphFirstTurnPrewarmDone,
+  getCodeGraphPrewarmDelayMs,
+  setSessionNeedsCwdRefresh,
+  // callbacks / deps
+  connectConfiguredMcp,
+  invalidatePreSessionToolSurface,
+  scheduleCodeGraphPrewarm,
+  hooks,
+  hookCommonPayload,
+  bootProfile,
+  getMemoryModule,
+  // channel-admin / registry helpers
+  listRegisteredPlugins,
+  pluginAdminStatus,
+  pluginManifest,
+  pluginMcpServerName,
+  mcpScriptForPlugin,
+  countSkillFiles,
+  readProjectMcpServers,
+  writeLastSessionCwd,
+  // shared utils
+  clean,
+  resolve,
+  statSync,
+  existsSync,
+  cfgMod,
+  STANDALONE_DATA_DIR,
+}) {
+  function resolveCwdPath(value) {
+    const raw = clean(value);
+    if (!raw) throw new Error('cwd: path is required for action=set');
+    const next = resolve(getCurrentCwd() || process.cwd(), raw);
+    const stat = statSync(next);
+    if (!stat.isDirectory()) throw new Error(`cwd: not a directory: ${next}`);
+    return next;
+  }
+
+  function applyResolvedCwd(nextCwd, { markRefresh = true } = {}) {
+    const resolved = resolve(nextCwd);
+    const stat = statSync(resolved);
+    if (!stat.isDirectory()) throw new Error(`cwd: not a directory: ${resolved}`);
+    const changed = resolve(getCurrentCwd()) !== resolved;
+    setCurrentCwd(resolved);
+    const currentCwd = resolved;
+    process.env.MIXDOG_SESSION_CWD = currentCwd;
+    writeLastSessionCwd(currentCwd);
+    const session = getSession();
+    if (session) session.cwd = currentCwd;
+    // cwd changes NEVER recreate the session: a mid-conversation cwd switch must
+    // preserve the full message history (and the BP1–BP3 prompt cache). We only
+    // retarget the live session's cwd in place; tool execution already reads the
+    // current cwd per turn. `cwd` is intentionally absent from the prompt
+    // context (see composeSystemPrompt), so there is nothing prompt-side to
+    // refresh either. `markRefresh`/`changed` are kept only for signature
+    // compatibility with existing callers.
+    void markRefresh;
+    // Lazy mode: before the first turn (e.g. the initial project-selection
+    // cwd set), do NOT prewarm — that is exactly the post-first-frame freeze
+    // we are avoiding. Once a turn has run, an in-session cwd switch DOES
+    // prewarm the new dir, since a lookup there is now likely.
+    if (isCodeGraphPrewarmLazy() && !isCodeGraphFirstTurnPrewarmDone()) {
+      bootProfile('code-graph:prewarm-lazy', { reason: 'cwd-deferred-to-first-turn' });
+    } else {
+      const delay = getCodeGraphPrewarmDelayMs();
+      scheduleCodeGraphPrewarm(changed ? 0 : delay, changed ? 'cwd-change' : 'cwd');
+    }
+    // Project-local `.mcp.json` follows the cwd: when the effective project MCP
+    // set changes, reconnect in the background (never await — this stays sync,
+    // and the session is preserved). Guarded so a no-op cwd change does not
+    // churn connections.
+    if (changed) {
+      try {
+        const nextKey = resolved + '\u0000' + JSON.stringify(readProjectMcpServers(resolved));
+        if (nextKey !== getLastProjectMcpKey()) {
+          setLastProjectMcpKey(nextKey);
+          void connectConfiguredMcp({ reset: true })
+            .then(() => invalidatePreSessionToolSurface())
+            .catch(() => {});
+        }
+      } catch {}
+    }
+    // CwdChanged: bridge an effective cwd switch to the standard hook bus.
+    // No matcher event — payload is minimal { cwd }. Fire-and-forget.
+    if (changed) {
+      try { void hooks.dispatch('CwdChanged', hookCommonPayload({ cwd: currentCwd })); } catch {}
+    }
+    return currentCwd;
+  }
+
+  async function refreshSessionForCwdIfNeeded(reason = 'cwd-change') {
+    // No-op: cwd changes are applied in place by applyResolvedCwd and never
+    // tear down the session. Retained as a stable hook for ask()'s pre-turn
+    // call so the surrounding turn flow is unchanged.
+    void reason;
+    setSessionNeedsCwdRefresh(false);
+    return getSession();
+  }
+
+  function pluginsStatus() {
+    const config = getConfig();
+    const dataDir = cfgMod.getPluginData?.();
+    const configuredMcp = config?.mcpServers && typeof config.mcpServers === 'object'
+      ? config.mcpServers
+      : {};
+    const plugins = [];
+    const addRegisteredPlugin = (entry) => {
+      const root = clean(entry.root);
+      if (!root || !existsSync(root)) return;
+      const manifest = pluginManifest(root);
+      const name = clean(manifest.name) || clean(manifest.id) || clean(entry.name) || root.split(/[\\/]/).pop() || root;
+      const plugin = {
+        id: clean(entry.id) || name,
+        name,
+        title: clean(manifest.title) || clean(manifest.displayName) || clean(entry.title) || name,
+        version: clean(manifest.version) || clean(entry.version) || null,
+        description: clean(manifest.description) || clean(entry.description),
+        marketplace: null,
+        source: clean(entry.sourceType) === 'local' ? 'local' : 'registry',
+        sourceUrl: clean(entry.source),
+        sourceType: clean(entry.sourceType) || 'git',
+        managed: entry.managed !== false,
+        root,
+        installedAt: entry.installedAt || null,
+        updatedAt: entry.updatedAt || null,
+        skillCount: countSkillFiles(root),
+        mcpScript: mcpScriptForPlugin(root),
+      };
+      plugin.mcpServerName = pluginMcpServerName(plugin);
+      plugin.mcpEnabled = Object.prototype.hasOwnProperty.call(configuredMcp, plugin.mcpServerName)
+        || Object.keys(configuredMcp).some((k) => k.startsWith(`${plugin.mcpServerName}--`));
+      plugins.push(plugin);
+    };
+
+    for (const entry of listRegisteredPlugins({ dataDir })) addRegisteredPlugin(entry);
+
+    plugins.sort((a, b) => {
+      if (a.source !== b.source) return a.source.localeCompare(b.source);
+      return a.name.localeCompare(b.name);
+    });
+    const admin = pluginAdminStatus({ dataDir });
+    return {
+      count: plugins.length,
+      plugins,
+      roots: {
+        registry: admin.registryPath,
+        installed: admin.installRoot,
+      },
+    };
+  }
+
+  function formatCoreMemoryLines(payload = {}) {
+    const seen = new Set();
+    const lines = [];
+    for (const value of [
+      ...(Array.isArray(payload.userLines) ? payload.userLines : []),
+      ...(Array.isArray(payload.dbLines) ? payload.dbLines : []),
+    ]) {
+      const text = clean(value).replace(/\s+/g, ' ');
+      if (!text) continue;
+      const key = text.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      lines.push(`- ${text}`);
+      if (lines.length >= 40) break;
+    }
+    const out = lines.join('\n');
+    const maxChars = 6000;
+    return out.length > maxChars ? `${out.slice(0, maxChars).replace(/\s+\S*$/, '')}\n- ...` : out;
+  }
+
+  async function loadCoreMemoryContext() {
+    // Boot should not pay for memory/PG startup unless explicitly requested.
+    // Recall and memory tools still initialize the memory service on first use.
+    if (process.env.MIXDOG_BOOT_CORE_MEMORY !== '1') {
+      bootProfile('core-memory:skipped');
+      return '';
+    }
+    const startedAt = performance.now();
+    let timer = null;
+    const timeout = new Promise((resolveTimeout) => {
+      timer = setTimeout(() => resolveTimeout(''), 2000);
+      timer.unref?.();
+    });
+    try {
+      return await Promise.race([
+        (async () => {
+          const memoryMod = await getMemoryModule();
+          if (typeof memoryMod?.buildSessionCoreMemoryPayload !== 'function') return '';
+          return formatCoreMemoryLines(await memoryMod.buildSessionCoreMemoryPayload(getCurrentCwd()));
+        })(),
+        timeout,
+      ]);
+    } catch {
+      return '';
+    } finally {
+      if (timer) clearTimeout(timer);
+      bootProfile('core-memory:done', { ms: (performance.now() - startedAt).toFixed(1) });
+    }
+  }
+
+  return {
+    resolveCwdPath,
+    applyResolvedCwd,
+    refreshSessionForCwdIfNeeded,
+    pluginsStatus,
+    formatCoreMemoryLines,
+    loadCoreMemoryContext,
+  };
+}