mixdog 1.2.6 → 1.3.1

package/src/session-runtime/boot/apis.mjs

@@ -54,6 +54,7 @@ import { createResourceApi } from '../resource-api.mjs';
 import { createModelRouteApi } from '../model-route-api.mjs';
 import { createWorkflowAgentsApi } from '../workflow-agents-api.mjs';
 import { createToolPolicyRefresh } from '../tool-policy-refresh.mjs';
+import { subscribeAgentProfileChanges } from '../agent-profile-changes.mjs';
 import { loadInstructionFilesContext } from '../../runtime/agent/orchestrator/context/instruction-files.mjs';
 import { createSessionTurnApi } from '../session-turn-api.mjs';
 import { createGoalFacadeApi } from '../goal-facade-api.mjs';
@@ -66,6 +67,7 @@ import { createConversationImportApi } from '../conversation-import/service.mjs'
 import { importError } from '../conversation-import/discovery.mjs';
 import { bootProfile } from '../boot-profile.mjs';
 import { STANDALONE_DATA_DIR } from '../runtime-paths.mjs';
+import { registerBotRouteStore } from '../../runtime/shared/agent-store.mjs';
 import {
   dataDirOf,
   resolveRoute,
@@ -110,10 +112,29 @@ export function wireApis(boot) {
   }
   boot.disposeGlobalExtensionSubscription = () => {
     boot.disposeConfigSync?.();
+    boot.disposeAgentProfileChanges();
     boot.resourceApi.disposeGlobalExtensionSubscription?.();
   };
   boot.modelRouteApi = modelRouteApiFor(boot);
   boot.workflowAgentsApi = workflowAgentsApiFor(boot);
+  // Connector allow lists (agent lists, MCP project scopes) become the
+  // equivalent "switched off" lists once; a later connector is on everywhere.
+  if (!boot.params.initialConfig || typeof boot.params.initialConfig !== 'object') {
+    try {
+      boot.workflowAgentsApi.migrateConnectorPolicies();
+    } catch (error) {
+      bootProfile('connector-policy:migrate-failed', { error: error?.message || String(error) });
+    }
+    // Bots get their own store (bots/) once, before any catalog read; a
+    // failed split leaves agents/ read as before (bot-split-migration.mjs).
+    try {
+      boot.workflowAgentsApi.migrateBotStore();
+    } catch (error) {
+      bootProfile('bot-split:migrate-failed', { error: error?.message || String(error) });
+    }
+  }
+  // Route reads ask a store bot's own folder first (agent-store.mjs).
+  registerBotRouteStore(() => dataDirOf(boot.cfgMod));
   boot.workspaceApi = workspaceApiFor(boot);
   boot.sessionTurnApi = sessionTurnApiFor(boot);
   const getFacadeSessionId = () => boot.rt.session?.id || boot.rt.reservedSessionId || null;
@@ -132,24 +153,36 @@ export function wireApis(boot) {
 
 function wireToolPolicyRefresh(boot) {
   const { rt, cfgMod } = boot;
-  const { refreshEmptySessionToolPolicy } = createToolPolicyRefresh({
-    getSession: () => rt.session,
-    getRoute: () => rt.route,
-    getMode: () => rt.mode,
-    getConfig: () => rt.config,
-    getDataDir: () => dataDirOf(cfgMod),
-    getActiveTurnCount: () => rt.activeTurnCount || 0,
-    modelStandaloneTools: boot.modelStandaloneTools,
-    featureDisallowedTools: boot.featureDisallowedTools,
-    loadCoreMemoryContext: boot.loadCoreMemoryContext,
-    loadInstructionFilesContext: (session) =>
-      session.skipInstructionFiles
-        ? ''
-        : loadInstructionFilesContext({ mode: rt.config?.instructionFiles, cwd: session.cwd }),
-    activeWorkflowContext: workflowHelpers.activeWorkflowContext,
-    invalidatePreSessionToolSurface: boot.invalidatePreSessionToolSurface,
-  });
+  const { refreshEmptySessionToolPolicy, switchSessionWorkflow, refreshAgentProfile, applyPendingAgentProfile } =
+    createToolPolicyRefresh({
+      getSession: () => rt.session,
+      getRoute: () => rt.route,
+      getMode: () => rt.mode,
+      getConfig: () => rt.config,
+      getDataDir: () => dataDirOf(cfgMod),
+      getActiveTurnCount: () => rt.activeTurnCount || 0,
+      modelStandaloneTools: boot.modelStandaloneTools,
+      featureDisallowedTools: boot.featureDisallowedTools,
+      loadCoreMemoryContext: boot.loadCoreMemoryContext,
+      loadInstructionFilesContext: (session) =>
+        session.skipInstructionFiles
+          ? ''
+          : loadInstructionFilesContext({ mode: rt.config?.instructionFiles, cwd: session.cwd }),
+      activeWorkflowContext: workflowHelpers.activeWorkflowContext,
+      invalidatePreSessionToolSurface: boot.invalidatePreSessionToolSurface,
+    });
   boot.refreshEmptySessionToolPolicy = refreshEmptySessionToolPolicy;
+  boot.switchSessionWorkflow = switchSessionWorkflow;
+  boot.refreshAgentProfile = refreshAgentProfile;
+  boot.applyPendingAgentProfile = applyPendingAgentProfile;
+  // A saved bot reaches this runtime's thread when its prompt embeds it (it
+  // runs as that bot, or lists it); the rebuilt prompt is saved with the session.
+  const profileChanges = subscribeAgentProfileChanges(async () => {
+    if (!(await refreshAgentProfile())) return;
+    saveSession(rt.session);
+    boot.invalidateContextStatusCache();
+  });
+  boot.disposeAgentProfileChanges = profileChanges.unsubscribe;
 }
 
 // Built-in install adapters. Memory downloads and loads the embedding model at
@@ -425,6 +458,7 @@ function lifecycleApiFor(boot) {
     invalidateContextStatusCache: boot.invalidateContextStatusCache,
     invalidatePreSessionToolSurface: boot.invalidatePreSessionToolSurface,
     applyResolvedCwd: boot.applyResolvedCwd,
+    refreshAgentProfile: boot.refreshAgentProfile,
     // Created after the lifecycle API, so resolved at call time.
     cleanupDeletedSessionWorktree: (sessionId) => boot.workspaceApi?.cleanupDeletedSession?.(sessionId),
     resolveRoute,
@@ -458,7 +492,9 @@ function resourceApiFor(boot) {
     connectConfiguredMcp: boot.connectConfiguredMcp,
     cancelMcpLogin: boot.cancelMcpLogin,
     completeMcpLogin: boot.completeMcpLogin,
-    clearMcpServerOAuth: (cfg) => boot.mcpClient.clearMcpServerOAuth(cfg),
+    clearMcpServerOAuth: (cfg, options) => boot.mcpClient.clearMcpServerOAuth(cfg, options),
+    startMcpServerOAuthSwitch: (cfg, launch, name) => boot.mcpClient.startMcpServerOAuthSwitch(cfg, launch, name),
+    commitMcpServerOAuthSwitch: (cfg, signIn) => boot.mcpClient.commitMcpServerOAuthSwitch(cfg, signIn),
     getMcpServerOAuthState: (cfg) => boot.mcpClient.getMcpServerOAuthState(cfg),
     probeMcpServerAuth: (cfg) => boot.mcpClient.probeMcpServerAuth(cfg),
     invalidatePreSessionToolSurface: boot.invalidatePreSessionToolSurface,
@@ -473,6 +509,7 @@ function resourceApiFor(boot) {
     skillContent: boot.skillContent,
     addGlobalSkill: boot.addGlobalSkill,
     saveSkillDocument: boot.saveSkillDocument,
+    removeGlobalSkill: boot.removeGlobalSkill,
     invalidateSkills: boot.invalidateSkills,
     getDisabledSkills: () => settingsApi.getDisabledSkills(),
     setDisabledSkills: (names) => settingsApi.setDisabledSkills(names),
@@ -511,6 +548,8 @@ function modelRouteApiFor(boot) {
     adoptConfig: boot.adoptConfig,
     saveConfigAndAdopt: boot.saveConfigAndAdopt,
     ensureFullConfig: boot.ensureFullConfig,
+    reloadFullConfig: boot.reloadFullConfig,
+    confirmLeadFill: boot.confirmLeadFill,
     awaitKeychainPrewarm: boot.awaitKeychainPrewarm,
     ensureProvidersReady: boot.ensureProvidersReady,
     persistLeadRoute: boot.persistLeadRoute,
@@ -540,8 +579,12 @@ function workflowAgentsApiFor(boot) {
     lookupModelMeta: boot.lookupModelMeta,
     adoptConfig: boot.adoptConfig,
     saveConfigAndAdopt: boot.saveConfigAndAdopt,
+    reloadFullConfig: boot.reloadFullConfig,
     ensureProvidersReady: boot.ensureProvidersReady,
     displayConfig: boot.displayConfig,
+    mcpStatus: () => boot.mcpStatus(),
+    resolveConfiguredMcpCatalog: () => boot.resolveConfiguredMcpCatalog(),
+    getMcpTools: () => boot.mcpClient.getMcpTools(rt.mcpScopeId),
     agentRouteFromConfig,
     loadAgentDefinition: workflowHelpers.loadAgentDefinition,
     listCustomAgentIds: workflowHelpers.listCustomAgentIds,
@@ -555,6 +598,7 @@ function workflowAgentsApiFor(boot) {
     invalidateContextStatusCache: boot.invalidateContextStatusCache,
     invalidatePreSessionToolSurface: boot.invalidatePreSessionToolSurface,
     refreshEmptySessionToolPolicy: boot.refreshEmptySessionToolPolicy,
+    switchSessionWorkflow: boot.switchSessionWorkflow,
   });
 }
 
@@ -596,6 +640,7 @@ function sessionTurnApiFor(boot) {
   const { rt, tunables, remoteTranscript, routePreparation } = boot;
   return createSessionTurnApi({
     applyPendingRoute: () => boot.modelRouteApi.applyPendingRoute(),
+    applyPendingAgentProfile: boot.applyPendingAgentProfile,
     prepareTurnWorkspace: boot.workspaceApi.prepareTurnWorkspace,
     admitTurnWorkspace: boot.workspaceApi.admitTurnWorkspace,
     getSession: () => rt.session,

package/src/session-runtime/boot/facade.mjs

@@ -85,17 +85,14 @@ function reserveSessionId(boot, id) {
 }
 
 // Every session's 2 s status pulse lands here; activeWorkflowSummary reads
-// through the process-wide shared caches, so no per-session file I/O.
+// through the process-wide shared caches, so no per-session file I/O. A
+// session presents its own workflow (set at creation, or switched in it);
+// the configured one is the default for new sessions.
 function currentWorkflow(boot) {
   const { rt, cfgMod } = boot;
   const active = workflowHelpers.activeWorkflowSummary(rt.config, dataDirOf(cfgMod));
-  if (rt.session?.workflow && typeof rt.session.workflow === 'object') {
-    const current = rt.session.workflow;
-    return current?.id && active?.id && current.id !== active.id
-      ? { ...active, currentSession: current, appliedToCurrentSession: false }
-      : active;
-  }
-  return active;
+  const current = rt.session?.workflow;
+  return current?.id && active?.id && current.id !== active.id ? current : active;
 }
 
 function facadeGetters(boot) {

package/src/session-runtime/boot/infrastructure.mjs

@@ -14,6 +14,7 @@ import { createSelfUpdateController } from '../self-update.mjs';
 import { createCompletionWakeScheduler, createNotificationBus } from '../notification-bus.mjs';
 import { createSkillsApi } from '../skills-api.mjs';
 import { createCwdPlugins } from '../cwd-plugins.mjs';
+import { injectedMemoryAgentId } from '../services/memory-access.mjs';
 import { listProjectsStrict } from '../../runtime/shared/projects.mjs';
 import { isWithin } from '../../runtime/shared/worktrees/paths.mjs';
 import { STANDALONE_DATA_DIR } from '../runtime-paths.mjs';
@@ -212,29 +213,37 @@ export function sessionAdopter(boot) {
 // the mutable cwd, the context module and the live tool surface.
 function wireSkills(boot) {
   const { rt, contextMod } = boot;
-  const { skillsStatus, skillContent, skillToolContent, addGlobalSkill, saveSkillDocument, invalidateSkills } =
-    createSkillsApi({
-      contextMod,
-      getCwd: () => rt.currentCwd,
-      getTools: () => {
-        const surface = boot.activeToolSurface();
-        return [
-          ...new Map(
-            [
-              ...(surface?.tools || []),
-              ...(surface?.deferredToolCatalog || []),
-              ...(surface?.deferredLateToolCatalog || []),
-            ].map((tool) => [tool.name, tool])
-          ).values(),
-        ];
-      },
-    });
+  const {
+    skillsStatus,
+    skillContent,
+    skillToolContent,
+    addGlobalSkill,
+    saveSkillDocument,
+    removeGlobalSkill,
+    invalidateSkills,
+  } = createSkillsApi({
+    contextMod,
+    getCwd: () => rt.currentCwd,
+    getTools: () => {
+      const surface = boot.activeToolSurface();
+      return [
+        ...new Map(
+          [
+            ...(surface?.tools || []),
+            ...(surface?.deferredToolCatalog || []),
+            ...(surface?.deferredLateToolCatalog || []),
+          ].map((tool) => [tool.name, tool])
+        ).values(),
+      ];
+    },
+  });
   Object.assign(boot, {
     skillsStatus,
     skillContent,
     skillToolContent,
     addGlobalSkill,
     saveSkillDocument,
+    removeGlobalSkill,
     invalidateSkills,
   });
 }
@@ -247,6 +256,8 @@ function wireCwdPlugins(boot) {
   const { rt, cfgMod, hooks, hookCommonPayload, tunables } = boot;
   const { resolveCwdPath, applyResolvedCwd, pluginsStatus, loadCoreMemoryContext } = createCwdPlugins({
     getCurrentCwd: () => rt.currentCwd,
+    getMemoryAgentId: () =>
+      injectedMemoryAgentId({ session: rt.session, sessionId: rt.reservedSessionId, profile: rt.sessionProfile }),
     setCurrentCwd: (next) => {
       rt.currentCwd = next;
     },

package/src/session-runtime/boot/providers.mjs

@@ -11,7 +11,10 @@ import { LOCAL_PROVIDER_ID, configureLocalProviderIdleTtl } from '../../runtime/
 import { resolve } from 'node:path';
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { LAZY_SECRET_PROVIDERS } from '../../runtime/agent/orchestrator/runtime-core/model-capabilities.mjs';
-import { ensureProviderEnabled, normalizeSystemShellConfig } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
+import {
+  ensureProviderEnabled,
+  normalizeSystemShellConfig,
+} from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import {
   workflowPresetId,
   normalizeWebSearchProviderId,
@@ -33,7 +36,7 @@ import { createProviderModels } from '../provider-models.mjs';
 import { createProviderUsage } from '../provider-usage.mjs';
 import { bootProfile } from '../boot-profile.mjs';
 import { STANDALONE_DATA_DIR } from '../runtime-paths.mjs';
-import { outputStyleStatus, webSearchCapableFor } from './shared.mjs';
+import { outputStyleStatus, resolveRoute, webSearchCapableFor } from './shared.mjs';
 
 export function wireProviders(boot) {
   wireConfigLifecycle(boot);
@@ -63,6 +66,10 @@ function wireConfigLifecycle(boot) {
       rt.configHasSecrets = next;
     },
     getRoute: () => rt.route,
+    setRouteState: (next) => {
+      rt.route = next;
+    },
+    resolveRoute,
     cfgMod,
     sharedCfgMod,
     setConfiguredShell,
@@ -82,6 +89,7 @@ function wireConfigLifecycle(boot) {
     seedOutputStyleStatusCache,
     adoptConfig,
     saveConfigAndAdopt,
+    confirmLeadFill,
     scheduleSkillsSave,
     flushSkillsSave,
     scheduleOutputStyleSave,
@@ -98,6 +106,7 @@ function wireConfigLifecycle(boot) {
     seedOutputStyleStatusCache,
     adoptConfig,
     saveConfigAndAdopt,
+    confirmLeadFill,
     scheduleSkillsSave,
     flushSkillsSave,
     scheduleOutputStyleSave,
@@ -106,13 +115,14 @@ function wireConfigLifecycle(boot) {
     ensureFullConfig,
     displayConfig,
     ensureConfigForRouteProvider,
-    persistLeadRoute: (routeLike) => {
+    persistLeadRoute: (routeLike, { onlyIfAbsent = false } = {}) => {
       const leadRoute = normalizeWorkflowRoute(routeLike);
       if (!leadRoute) return null;
       const nextConfig = { ...(rt.config || {}) };
       nextConfig.presets = upsertWorkflowPreset(nextConfig.presets, 'lead', leadRoute);
       nextConfig.default = workflowPresetId('lead');
-      saveConfigAndAdopt(nextConfig);
+      // A conditional fill reaches the file only while no Lead route is stored.
+      saveConfigAndAdopt(nextConfig, { leadFill: onlyIfAbsent });
       return leadRoute;
     },
   });

package/src/session-runtime/boot/tools.mjs

@@ -225,6 +225,8 @@ function wireInternalTools(boot) {
     getConfig: () => rt.config,
     notifySessionUi,
     getSessionId: () => rt.session?.id || rt.reservedSessionId || null,
+    getCallerSession: (sessionId) =>
+      sessionId === rt.session?.id ? rt.session : boot.mgr?.getSession?.(sessionId) || null,
     flushSettings: () => boot.flushAllConfigSavesAsync({ requireSaved: true }),
   });
   const disposeInternalTools = internalTools.setInternalToolsProvider({
@@ -250,6 +252,7 @@ function wireInternalTools(boot) {
       runNativeWebSearch: (...a) => boot.runNativeWebSearch(...a),
       activeToolSurface: boot.activeToolSurface,
       mcpStatus: boot.mcpStatus,
+      awaitMcpConnect: () => boot.awaitInitialMcpConnect?.(),
       skillToolContent: boot.skillToolContent,
       // Late-bound: the workspace authority is built with the API slices.
       getWorkspaceApi: () => boot.workspaceApi || null,

package/src/session-runtime/channel-config-api.mjs

@@ -10,8 +10,18 @@ import {
   setWebhookConfigAsync,
   testWebhook,
 } from './services/channel-admin.mjs';
-import { getSchedule } from '../runtime/channels/lib/schedules-db.mjs';
+import { getSchedule, markScheduleFailure, markScheduleSuccess } from '../runtime/channels/lib/schedules-db.mjs';
+import { loadEndpointConfig, readEndpointLastPayload } from '../runtime/channels/lib/webhooks-db.mjs';
+import { webhookEventSummary, webhookRunPrompt } from '../runtime/channels/lib/webhook/session-dispatch.mjs';
 import { runScheduleSession } from './schedule-session-run.mjs';
+import { runWebhookSession } from './webhook-session-run.mjs';
+import { retryRoutineDelivery } from './owned-automation-run.mjs';
+
+/** Why a "Run now" did not run: its owner bot is missing, or a run is going. */
+function skippedRunMessage(name, outcome) {
+  if (outcome.reason === 'owner') return `"${name}" is paused: ${outcome.message}`;
+  return `"${name}" is still running; this run was skipped`;
+}
 
 // Webhook/schedule config surface. The mutating admin helpers are imported
 // directly here and the runtime injects only the closure-owned callbacks
@@ -78,10 +88,48 @@ export function createChannelConfigApi({ channels, reloadChannelsSoon, ensureAut
       const id = String(name || '').trim();
       const schedule = await getSchedule(id);
       if (!schedule) throw new Error(`schedule "${id}" does not exist`);
-      // Runs in the engine process as a VISIBLE schedule session, so it works
-      // even while the channels worker is off and the run lands in Recent.
-      const { sessionId, result } = await runScheduleSession(schedule);
-      return { name: schedule.name, ok: true, sessionId, result };
+      // Runs in the engine process as a turn in the owner bot's chat, so it
+      // works even while the channels worker is off.
+      let outcome;
+      try {
+        // Asked for by a person: no failure backoff.
+        outcome = await runScheduleSession(schedule, { attended: true });
+      } catch (error) {
+        await markScheduleFailure(schedule.name, new Date()).catch(() => {});
+        throw error;
+      }
+      if (outcome.skipped) throw new Error(skippedRunMessage(schedule.name, outcome));
+      // The run's outcome shows as the schedule's last run, like a timed fire.
+      await markScheduleSuccess(schedule.name, new Date()).catch(() => {});
+      return { name: schedule.name, ok: true, sessionId: outcome.sessionId, result: outcome.result };
+    },
+    // Re-runs the endpoint on its latest received payload, with its current
+    // instructions, behind the same untrusted-data fence as a live delivery.
+    async runWebhookNow(name) {
+      const id = String(name || '').trim();
+      const endpoint = await loadEndpointConfig(id);
+      if (!endpoint) throw new Error(`webhook "${id}" does not exist`);
+      const payload = await readEndpointLastPayload(id);
+      if (!payload) throw new Error(`webhook "${id}" has not received a payload yet`);
+      const run = webhookRunPrompt(endpoint.instructions, payload.body ?? {}, payload.headers ?? {});
+      const outcome = await runWebhookSession(
+        {
+          name: endpoint.name,
+          ownerAgentId: endpoint.ownerAgentId,
+          cwd: endpoint.cwd || null,
+          attachments: endpoint.attachments || null,
+          event: webhookEventSummary(payload.headers ?? {}, payload.body ?? {}),
+          prompt: run.prompt,
+          skillSelection: run.skillSelection,
+        },
+        { attended: true }
+      );
+      if (outcome.skipped) throw new Error(skippedRunMessage(endpoint.name, outcome));
+      return { name: endpoint.name, ok: true, sessionId: outcome.sessionId, result: outcome.result };
+    },
+    // Queues again the result a finished run could not deliver; never reruns it.
+    async retryRoutineDelivery(kind, name) {
+      return retryRoutineDelivery(kind, String(name || '').trim());
     },
   };
 }

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

@@ -79,6 +79,9 @@ export function createConfigLifecycle({
   getConfigHasSecrets,
   setConfigHasSecrets,
   getRoute,
+  // Main route sync on reload (both optional: a lifecycle without them never syncs)
+  setRouteState,
+  resolveRoute,
   // shared modules / helpers
   cfgMod,
   sharedCfgMod,
@@ -121,16 +124,42 @@ export function createConfigLifecycle({
   // separate from adoptConfig: model tuning is adopted before its route save.
   let configSaveBaseline = structuredClone(getConfig());
 
-  function saveConfigAndAdopt(nextConfig, { hasSecrets = getConfigHasSecrets() } = {}) {
+  // The Lead route lives in these two stored keys; a conditional fill writes
+  // them only while `default` is still unset on disk, judged under the config
+  // file lock when the patch is applied (config-patch.mjs `unlessSet`).
+  const LEAD_FILL_KEYS = new Set(['default', 'presets']);
+
+  function saveConfigAndAdopt(nextConfig, { hasSecrets = getConfigHasSecrets(), leadFill = false } = {}) {
     // 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 });
-    const changes = cfgMod.createConfigPatch(configSaveBaseline, adopted);
+    const changes = cfgMod
+      .createConfigPatch(configSaveBaseline, adopted)
+      .map((change) =>
+        leadFill && LEAD_FILL_KEYS.has(change.path[0]) ? { ...change, unlessSet: ['default'] } : change
+      );
     configSaveBaseline = structuredClone(adopted);
     if (changes.length) writers.queueConfigChanges([...changes, ...seedChanges(adopted, changes)]);
     return adopted;
   }
 
+  const sameModel = (a, b) => clean(a?.provider) === clean(b?.provider) && clean(a?.model) === clean(b?.model);
+
+  /** After a conditional Lead fill adopted `filled`: persist it now and, when
+   *  the file already held another Lead route (written by another process after
+   *  the fill's re-read, so the patch skipped it), adopt that one instead.
+   *  Answers whether the runtime route was replaced. A route the user has moved
+   *  off `filled` meanwhile stays. */
+  async function confirmLeadFill(filled) {
+    await writers.flushConfigSaveAsync();
+    reloadFullConfig();
+    if (!setRouteState || !resolveRoute || !sameModel(getRoute(), filled)) return false;
+    const winner = resolveRoute(getConfig(), {});
+    if (!clean(winner?.model) || sameModel(winner, filled)) return false;
+    setRouteState(winner);
+    return true;
+  }
+
   // A fresh profile's install markers (an empty `builtins`) equal the
   // defaults, so no diff ever carries them — yet on disk their absence reads
   // as a grandfathered profile. The first write seeds them where the stored
@@ -177,9 +206,20 @@ export function createConfigLifecycle({
     }
     const adopted = adoptConfig(next, { hasSecrets: true });
     configSaveBaseline = structuredClone(adopted);
+    syncEmptyMainRoute(adopted);
     return adopted;
   }
 
+  // A Main route the runtime still has no model for takes the Lead route a
+  // reload brings in (edited on disk or by another process), so a conditional
+  // backfill sees it and never overwrites it. A live route that has a model is
+  // the user's selection and stays.
+  function syncEmptyMainRoute(config) {
+    if (!setRouteState || !resolveRoute || clean(getRoute()?.model)) return;
+    const resolved = resolveRoute(config, {});
+    if (clean(resolved?.model)) setRouteState(resolved);
+  }
+
   function ensureFullConfig() {
     if (getConfigHasSecrets()) return getConfig();
     return reloadFullConfig();
@@ -211,6 +251,7 @@ export function createConfigLifecycle({
     // adopt / save
     adoptConfig,
     saveConfigAndAdopt,
+    confirmLeadFill,
     // Skills publication also drains older config edits first.
     flushSkillsSave: writers.flushConfigSaveAsync,
     scheduleSkillsSave,

package/src/session-runtime/cwd-plugins/core-memory-context.mjs

@@ -1,6 +1,10 @@
 // cwd-plugins/core-memory-context.mjs — the user-curated core-memory block
-// injected into new sessions, read from the memory runtime's atomic snapshot.
+// injected into new sessions, read from the memory runtime's atomic snapshot:
+// common, then the project's, then the session's own agent memory
+// (services/memory-access.mjs injectedMemoryAgentId). The same snapshot gives
+// the same bytes, so an unchanged pool never invalidates the prompt cache.
 import { featureEnvOverride } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
+import { clean as cleanText } from '../../runtime/shared/clean.mjs';
 import { readSessionCoreMemoryPayload } from '../../runtime/memory/lib/core-memory-file.mjs';
 
 // Budget for the whole injected block in UTF-8 bytes: bytes track token cost
@@ -8,25 +12,37 @@ import { readSessionCoreMemoryPayload } from '../../runtime/memory/lib/core-memo
 const CORE_MEMORY_MAX_BYTES = 32 * 1024;
 const TRUNCATED_MARK = '\n- ...';
 
-export function createCoreMemoryContext({ getCurrentCwd, bootProfile, clean, cfgMod, STANDALONE_DATA_DIR }) {
-  function formatCoreMemoryLines(payload = {}) {
-    const seen = new Set();
-    const lines = [];
-    for (const value of Array.isArray(payload.userLines) ? payload.userLines : []) {
-      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}`);
-    }
-    const out = lines.join('\n');
-    if (Buffer.byteLength(out, 'utf8') <= CORE_MEMORY_MAX_BYTES) return out;
-    const budget = CORE_MEMORY_MAX_BYTES - Buffer.byteLength(TRUNCATED_MARK, 'utf8');
-    // A byte cut can split a multi-byte character; drop its replacement chars.
-    const head = Buffer.from(out, 'utf8').subarray(0, budget).toString('utf8').replace(/\uFFFD+$/, '');
-    return `${head.replace(/\s+\S*$/, '')}${TRUNCATED_MARK}`;
+function formatCoreMemoryBlock(payload = {}, clean = cleanText) {
+  const seen = new Set();
+  const lines = [];
+  for (const value of Array.isArray(payload.userLines) ? payload.userLines : []) {
+    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}`);
   }
+  const out = lines.join('\n');
+  if (Buffer.byteLength(out, 'utf8') <= CORE_MEMORY_MAX_BYTES) return out;
+  const budget = CORE_MEMORY_MAX_BYTES - Buffer.byteLength(TRUNCATED_MARK, 'utf8');
+  // A byte cut can split a multi-byte character; drop its replacement chars.
+  const head = Buffer.from(out, 'utf8')
+    .subarray(0, budget)
+    .toString('utf8')
+    .replace(/\uFFFD+$/, '');
+  return `${head.replace(/\s+\S*$/, '')}${TRUNCATED_MARK}`;
+}
+
+export function createCoreMemoryContext({
+  getCurrentCwd,
+  getMemoryAgentId = () => '',
+  bootProfile,
+  clean,
+  cfgMod,
+  STANDALONE_DATA_DIR,
+}) {
+  const formatCoreMemoryLines = (payload) => formatCoreMemoryBlock(payload, clean);
 
   async function loadCoreMemoryContext() {
     // User-curated core memory always injects into new sessions: the Memory
@@ -42,7 +58,7 @@ export function createCoreMemoryContext({ getCurrentCwd, bootProfile, clean, cfg
       // The prompt path never starts or waits for PG/embedding/IPC. Memory
       // runtime maintains this atomic snapshot independently.
       const dataDir = process.env.MIXDOG_DATA_DIR || cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
-      const payload = readSessionCoreMemoryPayload(dataDir, getCurrentCwd());
+      const payload = readSessionCoreMemoryPayload(dataDir, getCurrentCwd(), getMemoryAgentId());
       if (!payload) {
         bootProfile('core-memory:file-missing');
         return '';

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

@@ -68,6 +68,10 @@ export function createPluginStatus({
     const name = clean(manifest.name) || clean(manifest.id) || clean(entry.name) || root.split(/[\\/]/).pop() || root;
     const { mcpScript, mcpInline } = discoverPluginMcp(root);
     const skillCount = countSkillFiles(root);
+    // The hook files the hook bus loads for a plugin (hook-bus/config.mjs).
+    const hooks = [resolve(root, 'hooks', 'hooks.json'), resolve(root, '.mixdog', 'hooks.json')].some((file) =>
+      existsSync(file)
+    );
     const plugin = {
       id: clean(entry.id) || name,
       name,
@@ -85,11 +89,12 @@ export function createPluginStatus({
       installedAt: entry.installedAt || null,
       updatedAt: entry.updatedAt || null,
       skillCount,
+      hooks,
       mcpScript,
       mcpInline,
     };
     if (invalid) plugin.invalid = true;
-    if (plugin.enabled && skillCount === 0 && !mcpScript && !mcpInline) {
+    if (plugin.enabled && skillCount === 0 && !mcpScript && !mcpInline && !hooks) {
       plugin.searchedSkillRoots = pluginSkillsRoots(root);
       plugin.warning = `No skills or MCP server found. Searched skill roots: ${plugin.searchedSkillRoots.join(', ')}`;
     }