mixdog 1.2.5 → 1.3.0

package/src/session-runtime/agent-task-sessions.mjs

@@ -0,0 +1,200 @@
+/**
+ * `session create`: an attended agent-mode conversation (an agent's home
+ * thread) hands coding to a new, visible coding-mode task session — the
+ * user's own Lead, created through the same session service and defaults as a
+ * desktop New task — and gets each of its own turns' results back.
+ *
+ * Only turns the origin agent starts (the brief, a later `send` from it)
+ * report: when such a turn ends its result is queued durably for the agent's
+ * home (agent-home-delivery.mjs), which posts it and wakes the agent once to
+ * relay it. A turn blocked on the user's answer or approval posts one faint
+ * line instead; the card stays in the task session for the user.
+ */
+import { randomUUID } from 'node:crypto';
+import { realpathSync, statSync } from 'node:fs';
+import { basename, resolve } from 'node:path';
+import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+
+const TITLE_LIMIT = 60;
+
+/** `{ cwd, desktopSession, project }` of `project`: a registered Project name
+ *  (or alias) or an existing directory; none starts a task without a Project
+ *  in the caller's folder, as a desktop New task does in its task workspace. */
+export function resolveTaskProject(project, { projects = [], cwd = process.cwd() } = {}) {
+  const requested = clean(project);
+  if (!requested) return { cwd, desktopSession: { classification: 'task', projectPath: null }, project: null };
+  const key = requested.toLowerCase();
+  const named = projects.filter((entry) => [entry.name, entry.alias].some((name) => clean(name).toLowerCase() === key));
+  if (named.length > 1)
+    throw new Error(`session: Project "${requested}" is ambiguous; ask the user which one is meant`);
+  let path = named[0]?.path || '';
+  if (!path) {
+    const candidate = resolve(cwd, requested);
+    let directory = false;
+    try {
+      directory = statSync(candidate).isDirectory();
+    } catch {}
+    if (!directory) {
+      throw new Error(
+        `session: "${requested}" is neither a registered Project nor an existing directory; run list-projects`
+      );
+    }
+    path = realpathSync(candidate);
+  }
+  return {
+    cwd: path,
+    desktopSession: { classification: 'project', projectPath: path },
+    project: { name: named[0]?.name || basename(path), path },
+  };
+}
+
+const turnStatus = (detail) =>
+  ({ done: 'completed', completed: 'completed', failed: 'failed' })[detail?.status] || 'cancelled';
+
+export function createAgentTaskSessions({
+  getSessionService,
+  deliver = async (agentId, report) => (await import('./agent-home-delivery.mjs')).deliverAgentTask(agentId, report),
+  loadSession = async (sessionId) =>
+    (await import('../runtime/agent/orchestrator/session/store.mjs')).loadSession(sessionId),
+  listProjects = async () => (await import('../runtime/shared/projects.mjs')).listProjects(),
+  newTaskDefault = async () =>
+    (await import('../runtime/agent/orchestrator/config.mjs')).loadConfig({ secrets: false }).worktree?.newTaskDefault,
+  modelRoute = async (modelRef) => {
+    const [{ modelRouteFields, parseScheduleModelRef }, { migrateCodexRoute }, { loadConfig }] = await Promise.all([
+      import('../runtime/shared/schedule-model-ref.mjs'),
+      import('../runtime/agent/orchestrator/providers/openai-oauth-catalog-store.mjs'),
+      import('../runtime/agent/orchestrator/config.mjs'),
+    ]);
+    // A provider/model[@effort…] ref (a superseded model runs on its
+    // successor) or a preset name.
+    const ref = parseScheduleModelRef(modelRef);
+    if (ref && typeof ref === 'object') return modelRouteFields(migrateCodexRoute(ref));
+    const preset = loadConfig({ secrets: false }).presets?.find((p) => p.id === ref || p.name === ref);
+    if (!preset) throw new Error(`model "${ref}" is neither a provider/model route nor a known preset name`);
+    return modelRouteFields(preset);
+  },
+  log = (line) => process.stderr.write(`mixdog task sessions: ${line}\n`),
+}) {
+  const service = () => {
+    const value = getSessionService();
+    if (!value) throw new Error('session: session service is unavailable');
+    return value;
+  };
+
+  /** Submit `prompt` as the origin agent's turn; its end (and a wait for the
+   *  user in it) reports to the agent's home. Resolves on intake. */
+  async function agentTurn(sessionId, prompt, origin, id = `atask_${randomUUID()}`, beforeReport = null) {
+    const sessions = service();
+    const report = (status, text = '') =>
+      Promise.resolve(beforeReport)
+        .then(() =>
+          deliver(origin.agentId, {
+            runId: `${id}_${status === 'blocked' ? 'blocked' : 'end'}`,
+            taskSessionId: sessionId,
+            title: origin.title,
+            status,
+            text,
+          })
+        )
+        .catch((error) => log(`report of ${sessionId} failed: ${error?.message || error}`));
+    const notify = origin.notify !== false;
+    let unwatch = () => {};
+    if (notify) {
+      const runtime = await sessions.materializeSession(sessionId);
+      let blocked = false;
+      unwatch =
+        runtime?.subscribe?.(() => {
+          if (blocked || !runtime.getState?.()?.toolApproval) return;
+          blocked = true;
+          void report('blocked');
+        }) || unwatch;
+    }
+    const result = await sessions.submitSession({
+      sessionId,
+      prompt,
+      options: {
+        id,
+        mode: 'prompt',
+        transcriptMeta: { sender: 'lead' },
+        ...(notify
+          ? {
+              onSettled: (detail) => {
+                unwatch();
+                void report(turnStatus(detail), detail?.result?.content || detail?.error || '');
+              },
+            }
+          : {}),
+      },
+    });
+    if (result?.accepted !== true) unwatch();
+    return result?.accepted === true;
+  }
+
+  /** Create the task session for `brief` and start it; returns at once. */
+  async function create(args = {}, { callerSessionId, callerAgentId, callerCwd } = {}) {
+    if (!callerAgentId) throw new Error('session: create is only for an agent conversation');
+    const brief = typeof args.brief === 'string' ? args.brief.trim() : '';
+    if (!brief) throw new Error('session: brief is required for action=create');
+    const where = resolveTaskProject(args.project, { projects: await listProjects(), cwd: callerCwd || process.cwd() });
+    const requestId = `atask_${randomUUID()}`;
+    const title = (clean(args.title) || clean(brief.split('\n')[0])).slice(0, TITLE_LIMIT);
+    const taskOrigin = {
+      agentId: callerAgentId,
+      sessionId: callerSessionId,
+      requestId,
+      title,
+      notify: args.notify !== false,
+    };
+    const route = clean(args.model) ? await modelRoute(clean(args.model)) : {};
+    const sessions = service();
+    const created = await sessions.createSession({
+      ...route,
+      cwd: where.cwd,
+      desktopSession: where.desktopSession,
+      sessionProfile: { taskOrigin },
+    });
+    const sessionId = String(created?.sessionId || '');
+    if (!sessionId) throw new Error('session: task session creation returned no session id');
+    // The user's New task default: a Project task starts in its own worktree.
+    if (where.project && (await newTaskDefault()) === 'worktree') {
+      try {
+        await sessions.configureSession(
+          {
+            sessionId,
+            action: 'requestWorktree',
+            args: [{ provision: true, carryChanges: 'leave', prompt: title, txId: requestId }],
+          },
+          { revision: 1 }
+        );
+      } catch (error) {
+        if (error?.code !== 'WORKTREE_UNSUPPORTED_REPO') throw error;
+      }
+    }
+    // "Started" lands in the home before any report of the brief's turn.
+    let started = () => {};
+    const ready = new Promise((resolveReady) => {
+      started = resolveReady;
+    });
+    const accepted = await agentTurn(sessionId, brief, taskOrigin, requestId, ready);
+    if (!accepted) throw new Error(`session: task session ${sessionId} did not accept the brief`);
+    if (taskOrigin.notify) {
+      await deliver(callerAgentId, {
+        runId: `${requestId}_started`,
+        taskSessionId: sessionId,
+        title,
+        status: 'started',
+      }).catch((error) => log(`start line of ${sessionId} failed: ${error?.message || error}`));
+    }
+    started();
+    return { session_id: sessionId, title, project: where.project?.path ?? null };
+  }
+
+  /** The origin of a task session, when `agentId` created it. */
+  async function originFor(sessionId, agentId) {
+    if (!agentId) return null;
+    const origin = (await loadSession(sessionId))?.taskOrigin;
+    return origin?.agentId === agentId ? origin : null;
+  }
+
+  return { create, originFor, send: (sessionId, prompt, origin) => agentTurn(sessionId, prompt, origin) };
+}

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';
@@ -110,10 +111,20 @@ 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) });
+    }
+  }
   boot.workspaceApi = workspaceApiFor(boot);
   boot.sessionTurnApi = sessionTurnApiFor(boot);
   const getFacadeSessionId = () => boot.rt.session?.id || boot.rt.reservedSessionId || null;
@@ -132,24 +143,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 +448,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 +482,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 +499,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),
@@ -542,6 +569,9 @@ function workflowAgentsApiFor(boot) {
     saveConfigAndAdopt: boot.saveConfigAndAdopt,
     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 +585,7 @@ function workflowAgentsApiFor(boot) {
     invalidateContextStatusCache: boot.invalidateContextStatusCache,
     invalidatePreSessionToolSurface: boot.invalidatePreSessionToolSurface,
     refreshEmptySessionToolPolicy: boot.refreshEmptySessionToolPolicy,
+    switchSessionWorkflow: boot.switchSessionWorkflow,
   });
 }
 
@@ -596,6 +627,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/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/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(', ')}`;
     }