mixdog 1.2.0 → 1.2.2

package/src/session-runtime/resource-mcp-api.mjs

@@ -1,51 +1,37 @@
-// MCP server configuration: add/save/remove/toggle plus the plugin-declared
-// servers a plugin's manifest or script contributes.
-import { join } from 'node:path';
-import { existsSync } from 'node:fs';
+// MCP server configuration: add/save/remove/toggle of the user's servers, and
+// the per-server intent (enabled flag) of servers registered plugins declare.
+// Plugin servers are derived live (mcp-glue/plugin-servers.mjs) and are never
+// written into `mcpServers`; ordinary edits refuse them.
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import {
-  normalizePluginMcpServerConfig,
-  pluginMcpServerName,
-  pluginRawMcpServers,
-  pluginMcpEnableScript,
-  pluginServerMatcher,
-  resolveContainedPluginPath,
   mergeMcpServerConfig,
   MCP_TIMEOUT_FIELD_GROUPS,
 } from '../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
+import { resolveMcpOAuthUrl } from '../runtime/agent/orchestrator/mcp/client-config.mjs';
+import { withAdoptedCopies, withPinnedCollisionNames, withPluginServerIntent } from './mcp-glue/plugin-servers.mjs';
+import { findRegisteredPlugin } from './resource-plugins-api.mjs';
+import { createMcpOAuthLogins } from './mcp-oauth-login.mjs';
+
+/** The URL a server's OAuth credentials are stored under, or null. */
+function oauthUrlOf(cfg) {
+  try {
+    return resolveMcpOAuthUrl(cfg);
+  } catch {
+    // No valid remote URL: such a server never logged in.
+    return null;
+  }
+}
 
 /** The `mcpServers` map of a config as a fresh object (never the live one). */
 function mcpServersOf(config) {
   return config.mcpServers && typeof config.mcpServers === 'object' ? { ...config.mcpServers } : {};
 }
 
-function pluginMcpEnv(pluginDataDir, plugin, serverName) {
-  return {
-    MIXDOG_PLUGIN_ROOT: clean(plugin.root),
-    MIXDOG_PLUGIN_DATA: join(pluginDataDir, 'plugins', 'data', clean(plugin.id || plugin.name || serverName)),
-  };
-}
-
-// Manifest-declared servers replace every entry the plugin owned before; a
-// single server keeps the bare name.
-function manifestPluginMcpServers(existing, { rawServers, mcpRoot }, { plugin, serverName, env }) {
-  const keys = Object.keys(rawServers).filter((k) => {
-    const v = rawServers[k];
-    return v !== null && typeof v === 'object' && !Array.isArray(v);
-  });
-  const owned = pluginServerMatcher(serverName);
-  const nextServers = {};
-  for (const [k, v] of Object.entries(existing || {})) {
-    if (owned(k)) continue;
-    nextServers[k] = v;
-  }
-  for (const serverKey of keys) {
-    const cfg = normalizePluginMcpServerConfig(rawServers[serverKey], mcpRoot);
-    cfg.env = { ...(cfg.env || {}), ...env };
-    if (plugin.enabled === false) cfg._mixdogPluginDisabled = true;
-    nextServers[keys.length === 1 ? serverName : `${serverName}--${serverKey}`] = cfg;
-  }
-  return nextServers;
+function pluginOwnedError(name, owner) {
+  return new Error(
+    `MCP server "${name}" is provided by plugin "${owner.id}" (server "${owner.key}"); ` +
+      'enable or disable it with set_mcp_enabled, or manage the plugin instead'
+  );
 }
 
 const transportType = (type) => (type === 'streamable-http' ? 'http' : type);
@@ -80,24 +66,84 @@ function mergedServerInput(input, existing, originalName) {
 export function createMcpResourceApi({ deps, sync, decorate }) {
   const {
     getConfig,
-    cfgMod,
-    STANDALONE_DATA_DIR,
     saveConfigAndAdopt,
     normalizeMcpServerInput,
     mcpStatus,
     getMcpServerConfig,
+    connectConfiguredMcp,
+    clearMcpServerOAuth,
     reloadFullConfig,
     awaitKeychainPrewarm,
+    pluginsStatus,
+    resolveMcpCatalog = () => ({ servers: {}, adoption: null, plugins: {}, entries: {} }),
+    resolveConfiguredMcpCatalog = resolveMcpCatalog,
+    pluginMcpServer = () => null,
+    flushSkillsSave,
+    cancelMcpLogin = () => {},
+    completeMcpLogin,
+    getMcpServerOAuthState = () => null,
+    probeMcpServerAuth,
   } = deps;
 
-  /** Persist a new `mcpServers` map; project overrides never survive a global edit. */
+  // Explicit OAuth sign-in: the one interactive MCP connect. On success the
+  // other runtimes reconnect the server non-interactively with the new tokens.
+  const oauthLogins = createMcpOAuthLogins({
+    async connect(name, openBrowser) {
+      const status = await connectConfiguredMcp({ only: name, enabled: true, login: { openBrowser } });
+      const row = status?.servers?.find((server) => server.name === name);
+      return { connected: row?.connected === true, error: row?.error || null };
+    },
+    cancel: (name) => cancelMcpLogin(name),
+    completeCallback: completeMcpLogin,
+    onComplete: (name) => sync.announce('mcp', { detail: { mcpChanges: [{ name, enabled: true }] } }),
+  });
+  /** The effective config of a server that signs in with MCP OAuth (HTTP/SSE
+   *  without configured authentication). */
+  const oauthServerConfig = async (name) => {
+    const serverName = clean(name);
+    if (!serverName) throw new Error('MCP server name is required');
+    await awaitKeychainPrewarm();
+    reloadFullConfig();
+    const cfg = resolveMcpCatalog().servers[serverName];
+    if (!cfg) throw new Error(`MCP server not configured: ${serverName}`);
+    if (!getMcpServerOAuthState(cfg)) throw new Error(`MCP server "${serverName}" does not use OAuth sign-in`);
+    return { serverName, cfg };
+  };
+
+  /** The config with any adoptable plugin server copies already adopted, so
+   *  every write also persists the adoption and never re-adds a copy. */
+  const adoptedConfig = () => withAdoptedCopies(getConfig(), resolveMcpCatalog().adoption);
+
+  /** Persist a new `mcpServers` map; project overrides never survive a global
+   *  edit. A plugin server pushed off its name by the edit keeps the collision
+   *  name it gets, so it does not flip again later. */
   const saveServers = (servers) => {
-    const nextConfig = { ...getConfig() };
+    const nextConfig = { ...adoptedConfig() };
     delete nextConfig.mcpProjectOverrides;
     saveConfigAndAdopt({ ...nextConfig, mcpServers: servers });
+    const saved = getConfig();
+    const pinned = withPinnedCollisionNames(saved, resolveMcpCatalog());
+    if (pinned !== saved) saveConfigAndAdopt(pinned);
+  };
+  const userServers = () => mcpServersOf(adoptedConfig());
+  const refusePluginServer = (name) => {
+    const owned = name ? pluginMcpServer(name) : null;
+    if (owned) throw pluginOwnedError(name, owned.owner);
+  };
+  // Peers reload config from disk on receipt: land the write before publishing.
+  const persisted = async () => {
+    await flushSkillsSave?.();
   };
 
   return {
+    /** One-time, idempotent: move server copies an earlier plugin enable wrote
+     *  into `mcpServers` to per-server plugin intent. Returns adopted names. */
+    migratePluginMcpCopies() {
+      const { adoption } = resolveMcpCatalog();
+      if (!adoption) return [];
+      saveConfigAndAdopt(withAdoptedCopies(getConfig(), adoption));
+      return adoption.removed;
+    },
     mcpStatus() {
       return decorate.mcp(mcpStatus());
     },
@@ -112,28 +158,76 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
       const { enabled } = getMcpServerConfig(serverName);
       return sync.reconnectMcpAndAnnounce({ only: serverName, enabled });
     },
+    /** `{ flowId, state: 'pending', url }` once the browser login starts
+     *  (`options.openBrowser === false` leaves opening `url` to the caller), or
+     *  `{ flowId, state: 'complete' }` when stored credentials sufficed. */
+    async beginMcpOAuthLogin(name, options = {}) {
+      const { serverName, cfg } = await oauthServerConfig(name);
+      if (cfg.enabled === false) throw new Error(`MCP server is disabled: ${serverName}`);
+      return oauthLogins.begin(serverName, options);
+    },
+    /** `{ flowId, state: 'pending' | 'complete' | 'failed' | 'cancelled', error? }` */
+    getMcpOAuthLoginStatus(flowId) {
+      return oauthLogins.status(flowId);
+    },
+    cancelMcpOAuthLogin(flowId) {
+      return oauthLogins.cancel(flowId);
+    },
+    /** Remote / headless sign-in: complete the pending flow with the redirect
+     *  URL pasted from the browser. `{ flowId, state: 'complete' | 'failed',
+     *  error? }`; an invalid paste throws a fixed message and stays pending. */
+    completeMcpOAuthLogin(flowId, callbackUrl) {
+      return oauthLogins.complete(flowId, callbackUrl);
+    },
+    /** Forget the server's stored OAuth credentials (shared by every server
+     *  with the same exact URL) and reconnect without a login, here and on
+     *  peers, so it reports sign-in required. */
+    async signOutMcpServer(name) {
+      const { serverName, cfg } = await oauthServerConfig(name);
+      // A begin issued meanwhile waits until the credentials are gone.
+      return oauthLogins.cancelServer(serverName, async () => {
+        await clearMcpServerOAuth(cfg);
+        return sync.reconnectMcpAndAnnounce({ only: serverName, enabled: cfg.enabled !== false });
+      });
+    },
+    /** `{ auth: 'oauth' | 'none' | 'configured' | 'unreachable', error? }` for an
+     *  HTTP/SSE config, without credentials or a browser. */
+    probeMcpServerAuth(cfg) {
+      if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) throw new TypeError('MCP server config is required');
+      const probe = {};
+      for (const key of ['type', 'url', 'headers', 'bearer_token_env_var', 'env_http_headers']) {
+        if (cfg[key] !== undefined) probe[key] = cfg[key];
+      }
+      if (probe.type !== 'http' && probe.type !== 'sse') throw new TypeError("type must be 'http' or 'sse'");
+      return probeMcpServerAuth(probe);
+    },
     async addMcpServer(input = {}) {
       const { name, config: serverConfig } = normalizeMcpServerInput(input);
-      const servers = mcpServersOf(getConfig());
+      const servers = userServers();
       if (Object.hasOwn(servers, name)) throw new Error(`MCP server already exists: ${name}`);
+      const owned = pluginMcpServer(name);
+      if (owned) throw new Error(`MCP server already exists: ${name} (provided by plugin "${owned.owner.id}")`);
       saveServers({ ...servers, [name]: serverConfig });
       const status = await sync.reconnectMcpAndAnnounce({ only: name, enabled: serverConfig.enabled !== false });
       return { name, status };
     },
     async saveMcpServer(input = {}) {
-      const servers = mcpServersOf(getConfig());
+      const servers = userServers();
       // An explicit originalName must exist; a bare name edits a matching
-      // server and otherwise creates a new one.
+      // server and otherwise creates a new one. Plugin servers are never
+      // edited, renamed or shadowed here.
       const explicitOriginal = clean(input.originalName);
       if (explicitOriginal && !Object.hasOwn(servers, explicitOriginal)) {
+        refusePluginServer(explicitOriginal);
         throw new Error(`MCP server not configured: ${explicitOriginal}`);
       }
       const bareName = clean(input.name);
+      if (!explicitOriginal && !Object.hasOwn(servers, bareName)) refusePluginServer(bareName);
       const originalName = explicitOriginal || (Object.hasOwn(servers, bareName) ? bareName : '');
       const existing = originalName ? servers[originalName] : {};
       const normalizedInput = normalizeMcpServerInput(mergedServerInput(input, existing, originalName));
       const name = originalName && clean(input.name) === originalName ? originalName : normalizedInput.name;
-      if (name !== originalName && Object.hasOwn(servers, name)) {
+      if (name !== originalName && (Object.hasOwn(servers, name) || pluginMcpServer(name))) {
         throw new Error(`MCP server already exists: ${name}`);
       }
       if (originalName && originalName !== name) delete servers[originalName];
@@ -149,21 +243,49 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     async removeMcpServer(name) {
       const serverName = clean(name);
       if (!serverName) throw new Error('MCP server name is required');
-      const servers = mcpServersOf(getConfig());
+      const servers = userServers();
       if (!Object.hasOwn(servers, serverName)) {
+        refusePluginServer(serverName);
         throw new Error(`MCP server not configured: ${serverName}`);
       }
+      const removed = servers[serverName];
       delete servers[serverName];
       saveServers(servers);
-      return sync.reconnectMcpAndAnnounce({ drop: [serverName] });
+      const status = await sync.reconnectMcpAndAnnounce({ drop: [serverName] });
+      // A removed server keeps no OAuth tokens or client registration, unless
+      // another configured server (plugin or disabled ones included, even
+      // with MCP disabled for this runtime) still uses them through the same
+      // exact URL.
+      const url = oauthUrlOf(removed);
+      if (url && !Object.values(resolveConfiguredMcpCatalog().servers).some((cfg) => oauthUrlOf(cfg) === url)) {
+        await clearMcpServerOAuth(removed);
+      }
+      return status;
     },
     async setMcpServerEnabled(name, enabled) {
       const serverName = clean(name);
       if (!serverName) throw new Error('MCP server name is required');
       const want = enabled !== false;
+      const owned = pluginMcpServer(serverName);
+      if (owned) {
+        // Server intent only: the effective state still requires the plugin.
+        // Only a choice that differs from the declared default is stored.
+        const { owner, pluginEnabled, declaredEnabled } = owned;
+        saveConfigAndAdopt(
+          withPluginServerIntent(adoptedConfig(), owner.id, owner.key, (intent) => ({
+            ...intent,
+            enabled: want === (declaredEnabled !== false) ? undefined : want,
+          }))
+        );
+        await persisted();
+        const effective = want && pluginEnabled;
+        const status = await sync.scheduleMcpToggle(serverName, effective);
+        await sync.publish('mcp', { mcpChanges: [{ name: serverName, enabled: effective }] });
+        return status;
+      }
       const shadowRow = mcpStatus().servers.find((s) => s.name === serverName);
       if (!shadowRow) throw new Error(`MCP server not configured: ${serverName}`);
-      const servers = mcpServersOf(getConfig());
+      const servers = userServers();
       const current = servers[serverName];
       if (!current || typeof current !== 'object' || Array.isArray(current)) {
         throw new Error(`MCP server not configured: ${serverName}`);
@@ -174,38 +296,36 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
       await sync.publish('mcp', { mcpChanges: [{ name: serverName, enabled: want }] });
       return status;
     },
+    /** Kept for older callers: plugin servers appear on their own once the
+     *  plugin is registered and enabled. This clears any per-server "off"
+     *  intent of the plugin's servers and reconnects them (here and on peers);
+     *  a disabled plugin stays disabled. */
     async enablePluginMcp(plugin = {}) {
-      const root = clean(plugin.root);
-      const script = pluginMcpEnableScript(root, plugin);
-      if (!root || !script) throw new Error('plugin has no MCP script');
-      const serverName = pluginMcpServerName(plugin);
-      const nextConfig = { ...getConfig() };
-      const manifestMcp = pluginRawMcpServers(root, script);
-      const env = pluginMcpEnv(cfgMod.getPluginData?.() || STANDALONE_DATA_DIR, plugin, serverName);
-      if (manifestMcp) {
-        nextConfig.mcpServers = manifestPluginMcpServers(nextConfig.mcpServers, manifestMcp, {
-          plugin,
-          serverName,
-          env,
-        });
-      } else {
-        const scriptPath = resolveContainedPluginPath(root, script);
-        if (!scriptPath || !existsSync(scriptPath))
-          throw new Error(`plugin MCP script not found: ${join(root, script)}`);
-        nextConfig.mcpServers = {
-          ...(nextConfig.mcpServers || {}),
-          [serverName]: {
-            command: 'node',
-            args: [scriptPath],
-            cwd: root,
-            env,
-            ...(plugin.enabled === false ? { _mixdogPluginDisabled: true } : {}),
-          },
-        };
+      const registered = findRegisteredPlugin(pluginsStatus, plugin) || plugin;
+      const id = clean(registered.id || registered.name);
+      const catalog = resolveMcpCatalog();
+      const row = catalog.plugins[id];
+      if (!row) throw new Error(`plugin not registered: ${clean(plugin.id || plugin.name || plugin) || id}`);
+      if (!row.servers.length) {
+        const detail = row.errors.map((error) => error.message).join('; ');
+        throw new Error(`plugin declares no MCP servers${detail ? `: ${detail}` : ''}`);
+      }
+      let next = withAdoptedCopies(getConfig(), catalog.adoption);
+      for (const name of row.servers) {
+        const { owner, declaredEnabled } = catalog.entries[name];
+        next = withPluginServerIntent(next, id, owner.key, (intent) => ({
+          ...intent,
+          enabled: declaredEnabled === false ? true : undefined,
+        }));
       }
-      saveConfigAndAdopt(nextConfig);
-      const status = await sync.reconnectMcpAndAnnounce();
-      return { serverName, status };
+      saveConfigAndAdopt(next);
+      await persisted();
+      const mcpChanges = row.servers.map((name) => ({ name, enabled: row.enabled }));
+      let status;
+      for (const change of mcpChanges)
+        status = await connectConfiguredMcp({ only: change.name, enabled: change.enabled });
+      await sync.announce('mcp', { detail: { mcpChanges } });
+      return { serverName: row.servers[0], serverNames: row.servers, status };
     },
   };
 }

package/src/session-runtime/resource-plugins-api.mjs

@@ -1,4 +1,6 @@
-// Plugin registry edits and the MCP entries a plugin owns.
+// Plugin registry edits. A plugin's MCP servers are derived from the registry
+// (mcp-glue/plugin-servers.mjs), so each edit reconciles this runtime's MCP
+// connections and then lets peer runtimes reconcile theirs.
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import {
   addPlugin as registryAddPlugin,
@@ -6,7 +8,7 @@ import {
   setPluginEnabled as registrySetPluginEnabled,
   updatePlugin as registryUpdatePlugin,
 } from './services/plugin-admin.mjs';
-import { pluginMcpServerName, pluginServerMatcher } from '../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
+import { withAdoptedCopies, withoutPluginIntents, withPinnedCollisionNames } from './mcp-glue/plugin-servers.mjs';
 
 const pluginKey = (plugin) => clean(plugin.id || plugin.name || plugin);
 
@@ -24,22 +26,22 @@ export function createPluginsResourceApi({ deps, sync, decorate }) {
     getConfig,
     cfgMod,
     saveConfigAndAdopt,
-    connectConfiguredMcp,
-    invalidatePreSessionToolSurface,
     pluginsStatus,
+    resolveMcpCatalog = () => ({ adoption: null }),
+    flushSkillsSave,
   } = deps;
   const pluginData = () => cfgMod.getPluginData?.();
 
-  /** Rewrite the plugin's MCP entries through `rewrite`; when any existed,
-   *  persist and reconnect so the connection registry matches the config. */
-  async function rewritePluginServers(plugin, rewrite) {
-    const nextConfig = { ...getConfig() };
-    const owned = pluginServerMatcher(pluginMcpServerName(plugin));
-    const current = nextConfig.mcpServers || {};
-    if (!Object.keys(current).some(owned)) return;
-    saveConfigAndAdopt({ ...nextConfig, mcpServers: rewrite(current, owned) });
-    await connectConfiguredMcp({ reset: true });
-    invalidatePreSessionToolSurface();
+  /** Persist any adoptable copies of plugin servers while the registry still
+   *  knows their plugin (a removal must not leave them stranded), and keep any
+   *  collision name a plugin server was just given. */
+  async function adoptPluginServerCopies(transform = (config) => config) {
+    const current = getConfig();
+    const catalog = resolveMcpCatalog();
+    const next = transform(withPinnedCollisionNames(withAdoptedCopies(current, catalog.adoption), catalog));
+    if (next === current) return;
+    saveConfigAndAdopt(next);
+    await flushSkillsSave?.();
   }
 
   return {
@@ -47,49 +49,35 @@ export function createPluginsResourceApi({ deps, sync, decorate }) {
       return decorate.plugins(pluginsStatus());
     },
     async reloadPlugins() {
-      await sync.announce('plugins');
+      await sync.reconcilePluginsAndAnnounce();
       return pluginsStatus();
     },
     async addPlugin(source) {
       const plugin = registryAddPlugin(source, { dataDir: pluginData() });
-      await sync.announce('plugins');
+      await adoptPluginServerCopies();
+      await sync.reconcilePluginsAndAnnounce();
       return { plugin, status: pluginsStatus() };
     },
     async updatePlugin(plugin = {}) {
       const updated = registryUpdatePlugin(pluginKey(plugin), { dataDir: pluginData() });
-      await sync.announce('plugins');
+      await adoptPluginServerCopies();
+      await sync.reconcilePluginsAndAnnounce();
       return { plugin: updated, status: pluginsStatus() };
     },
     async setPluginEnabled(plugin = {}, enabled = true) {
-      const owner = findRegisteredPlugin(pluginsStatus, plugin) || plugin;
+      await adoptPluginServerCopies();
       const updated = registrySetPluginEnabled(pluginKey(plugin), enabled, { dataDir: pluginData() });
-      await rewritePluginServers(owner, (servers, owned) => {
-        const next = {};
-        for (const [name, value] of Object.entries(servers)) {
-          const config = value && typeof value === 'object' && !Array.isArray(value) ? { ...value } : value;
-          if (owned(name) && config && typeof config === 'object' && !Array.isArray(config)) {
-            if (enabled === false) config._mixdogPluginDisabled = true;
-            else delete config._mixdogPluginDisabled;
-          }
-          next[name] = config;
-        }
-        return next;
-      });
-      await sync.announce('plugins');
+      await sync.reconcilePluginsAndAnnounce();
       return { plugin: updated, status: pluginsStatus() };
     },
     async removePlugin(plugin = {}) {
-      // Resolve before the registry forgets the plugin and its manifest name.
-      const owner = findRegisteredPlugin(pluginsStatus, plugin) || plugin;
+      const owner = findRegisteredPlugin(pluginsStatus, plugin);
+      const ownerId = clean(owner?.id);
+      // Adopt first (the registry still knows the plugin), then drop the
+      // plugin's per-server intent together with the plugin.
+      await adoptPluginServerCopies((config) => (ownerId ? withoutPluginIntents(config, ownerId) : config));
       const removed = registryRemovePlugin(pluginKey(plugin), { dataDir: pluginData() });
-      await rewritePluginServers(owner, (servers, owned) => {
-        const next = { ...servers };
-        for (const name of Object.keys(next)) {
-          if (owned(name)) delete next[name];
-        }
-        return next;
-      });
-      await sync.announce('plugins');
+      await sync.reconcilePluginsAndAnnounce();
       return { plugin: removed, status: pluginsStatus() };
     },
   };

package/src/session-runtime/resource-scope-decorate.mjs

@@ -7,19 +7,17 @@ import {
   cwdWithinProjects,
   extensionScopeProjects,
   extensionScopesFromConfig,
-  pluginIdForMcpServer,
 } from '../runtime/agent/orchestrator/runtime-core/extension-scopes.mjs';
 
 function listOf(status, key) {
   return Array.isArray(status?.[key]) ? status[key] : [];
 }
 
-export function createScopeDecorators({ getConfig, getCurrentCwd, pluginsStatus }) {
-  function scopeInfo(kind, name, pluginId = '') {
+export function createScopeDecorators({ getConfig, getCurrentCwd }) {
+  function scopeInfo(kind, name, pluginId = '', cwd = getCurrentCwd()) {
     const scopes = extensionScopesFromConfig(getConfig());
     const scope = extensionScopeProjects(scopes, kind, name);
     const inheritedScope = pluginId ? extensionScopeProjects(scopes, 'plugins', pluginId) : null;
-    const cwd = getCurrentCwd();
     const activeHere =
       (scope ? cwdWithinProjects(cwd, scope) : true) &&
       (inheritedScope ? cwdWithinProjects(cwd, inheritedScope) : true);
@@ -27,21 +25,21 @@ export function createScopeDecorators({ getConfig, getCurrentCwd, pluginsStatus
   }
   return {
     mcp(status) {
-      const plugins = pluginsStatus()?.plugins || [];
       return {
         ...status,
         servers: listOf(status, 'servers').map((server) => ({
           ...server,
-          ...scopeInfo('mcp', server.name, pluginIdForMcpServer(server.name, plugins)),
+          ...scopeInfo('mcp', server.name, server?.owner?.kind === 'plugin' ? clean(server.owner.id) : ''),
         })),
       };
     },
-    skills(status) {
+    /** `cwd`: decide `activeHere` for that folder instead of the current one. */
+    skills(status, cwd = getCurrentCwd()) {
       return {
         ...status,
         skills: listOf(status, 'skills').map((skill) => ({
           ...skill,
-          ...scopeInfo('skills', skill.name, skill?.owner?.kind === 'plugin' ? clean(skill.owner.id) : ''),
+          ...scopeInfo('skills', skill.name, skill?.owner?.kind === 'plugin' ? clean(skill.owner.id) : '', cwd),
         })),
       };
     },

package/src/session-runtime/resource-skills-api.mjs

@@ -1,4 +1,23 @@
 // Global Skill documents and the disabled-skill list.
+import { statSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+
+/** `skillsStatus({ cwd })`: the folder to list and scope skills for, in place
+ *  of the session's own. Only an existing absolute directory; it reads the
+ *  same skill roots a session opened there would, nothing wider. */
+function statusCwd(options) {
+  if (options == null) return '';
+  const cwd = options?.cwd;
+  if (typeof cwd !== 'string' || !cwd || cwd.includes('\0') || !isAbsolute(cwd)) {
+    throw new TypeError('skillsStatus cwd must be an absolute path.');
+  }
+  const folder = resolve(cwd);
+  if (!statSync(folder, { throwIfNoEntry: false })?.isDirectory()) {
+    throw new TypeError('skillsStatus cwd is not a directory.');
+  }
+  return folder;
+}
+
 export function createSkillsResourceApi({ deps, sync, decorate }) {
   const {
     skillsStatus,
@@ -11,8 +30,10 @@ export function createSkillsResourceApi({ deps, sync, decorate }) {
     flushSkillsSave,
   } = deps;
   return {
-    skillsStatus() {
-      return decorate.skills(skillsStatus());
+    skillsStatus(options) {
+      const cwd = statusCwd(options);
+      if (!cwd) return decorate.skills(skillsStatus());
+      return decorate.skills(skillsStatus({ cwd }), cwd);
     },
     skillContent(name) {
       return skillContent(name);

package/src/session-runtime/runtime-review-api.mjs

@@ -1,6 +1,7 @@
 import { registerCacheInvalidationListener } from '../runtime/agent/orchestrator/tools/builtin/cache-layers.mjs';
 import { turnReviewReply } from '../runtime/shared/turn-review-reply.mjs';
 import {
+  clearSessionChangeHistory,
   getSessionReviewDiff,
   getTurnChanges,
   getTurnReviewDiff,
@@ -10,6 +11,17 @@ import {
   revertTurnReviewFile,
 } from '../runtime/shared/turn-snapshot.mjs';
 import { noteTurnWorktreeChange } from '../runtime/shared/turn-worktree-snapshot.mjs';
+import { forgetSessionChangeHistoryMarker } from '../runtime/shared/turn-snapshot-store.mjs';
+import { forgetSessionBaselines } from '../runtime/shared/session-baseline-store.mjs';
+import { registerSessionPurgeHook } from '../runtime/agent/orchestrator/session/store.mjs';
+
+// A deleted history stays deleted for as long as its session exists; the
+// session's own deletion takes the marker — and its stored first-seen file
+// contents — with it.
+registerSessionPurgeHook((sessionId) => {
+  void forgetSessionChangeHistoryMarker(sessionId);
+  void forgetSessionBaselines(sessionId);
+});
 
 // Tool writes (apply_patch, mutating shell commands, git, watcher events)
 // reach the live review snapshot as its change signal: a review poll right
@@ -31,5 +43,6 @@ export function createRuntimeReviewApi({ getCwd, getSessionId }) {
       revertTurnChanges(getSessionId(), checkpointId, file, revision),
     reapplyTurnChanges: (checkpointId, file, revision) =>
       reapplyTurnChanges(getSessionId(), checkpointId, file, revision),
+    clearSessionChangeHistory: () => clearSessionChangeHistory(getSessionId()),
   };
 }

package/src/session-runtime/schedule-session-run.mjs

@@ -65,7 +65,7 @@ export async function runScheduleSession(schedule, { config = null, prompt: prom
   const result = await runAutomationTurns(
     session.id,
     () => askSession(session.id, content, null, null, cwd || undefined),
-    (completions) => askSession(session.id, completions, null, null, cwd || undefined)
+    (completions, askOpts) => askSession(session.id, completions, null, null, cwd || undefined, undefined, askOpts)
   );
   return { sessionId: session.id, result: String(result?.content || '') };
 }

package/src/session-runtime/services/agent-tool/job-task-reconcile.mjs

@@ -19,7 +19,7 @@
 // Every call is idempotent (the first terminal state wins, so the outer reject
 // path cannot double-notify) and absorbs its own errors, so reporting on a
 // turn can never break the turn.
-import { reconcileBackgroundTask } from '../../../runtime/shared/background-tasks.mjs';
+import { reconcileBackgroundTask, settleCancelledBackgroundTask } from '../../../runtime/shared/background-tasks.mjs';
 
 function reconcileJobTerminalResult(job, value) {
   if (!job?.taskId) return;
@@ -50,6 +50,8 @@ export function terminalResultHook({ job, turnReview, completionValue, notifyEar
     turnReview.complete();
     const value = completionValue(terminalResult);
     job._terminalResultValue = value;
+    // A cancelled job reports once, as `cancelled`, when its turn settles.
+    if (job.status === 'cancelled') return;
     notifyEarly(job, value, notifyContext || {});
     reconcileJobTerminalResult(job, value);
   };
@@ -67,6 +69,16 @@ export function reconcileJobWatchdogPartial(job, value) {
   } catch {}
 }
 
+/** The cancelled turn stopped: deliver the owner's single `cancelled`
+ *  notification, carrying the output the turn produced before it stopped
+ *  (header-only when it produced none). */
+export function reconcileJobCancelled(job, value) {
+  if (!job?.taskId) return;
+  try {
+    settleCancelledBackgroundTask(job.taskId, value?.content ? { result: value } : {});
+  } catch {}
+}
+
 export function reconcileJobStreamStalled(job, error) {
   if (!job?.taskId || job._terminalResultValue !== undefined) return;
   try {