mixdog 1.1.2 → 1.2.1

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

@@ -1,50 +1,25 @@
-// 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 { withAdoptedCopies, withPinnedCollisionNames, withPluginServerIntent } from './mcp-glue/plugin-servers.mjs';
+import { findRegisteredPlugin } from './resource-plugins-api.mjs';
 
 /** 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);
@@ -63,8 +38,13 @@ function mergedServerInput(input, existing, originalName) {
       if (Object.hasOwn(input, key)) maps[key] = { ...(existing[key] || {}), ...input[key] };
     }
   }
+  // Existing timeouts are kept by mergeMcpServerConfig; the normalizer must only
+  // see (and validate) newly supplied ones, so a stored 0/'off' never blocks
+  // an unrelated save.
+  const { ...base } = transportChanged ? {} : existing;
+  for (const field of MCP_TIMEOUT_FIELD_GROUPS.flat()) delete base[field];
   return {
-    ...(transportChanged ? {} : existing),
+    ...base,
     ...input,
     ...maps,
     name: clean(input.name) || originalName,
@@ -74,83 +54,142 @@ function mergedServerInput(input, existing, originalName) {
 export function createMcpResourceApi({ deps, sync, decorate }) {
   const {
     getConfig,
-    cfgMod,
-    STANDALONE_DATA_DIR,
     saveConfigAndAdopt,
     normalizeMcpServerInput,
     mcpStatus,
     getMcpServerConfig,
+    connectConfiguredMcp,
     reloadFullConfig,
     awaitKeychainPrewarm,
+    pluginsStatus,
+    resolveMcpCatalog = () => ({ adoption: null, plugins: {}, entries: {} }),
+    pluginMcpServer = () => null,
+    flushSkillsSave,
   } = deps;
 
-  /** Persist a new `mcpServers` map; project overrides never survive a global edit. */
+  /** 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());
     },
     getMcpServerConfig(name) {
       return getMcpServerConfig(name);
     },
-    async reconnectMcp() {
+    async reconnectMcp(name) {
       await awaitKeychainPrewarm();
       reloadFullConfig();
-      return sync.reconnectMcpAndAnnounce();
+      const serverName = clean(name);
+      if (!serverName) return sync.reconnectMcpAndAnnounce();
+      const { enabled } = getMcpServerConfig(serverName);
+      return sync.reconnectMcpAndAnnounce({ only: serverName, enabled });
     },
     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();
+      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];
       servers[name] = mergeMcpServerConfig(existing, normalizedInput.config);
       saveServers(servers);
-      const status = await sync.reconnectMcpAndAnnounce();
+      const status = await sync.reconnectMcpAndAnnounce({
+        only: name,
+        enabled: servers[name].enabled !== false,
+        drop: originalName && originalName !== name ? [originalName] : [],
+      });
       return { name, source: 'config', status };
     },
     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}`);
       }
       delete servers[serverName];
       saveServers(servers);
-      return sync.reconnectMcpAndAnnounce();
+      return sync.reconnectMcpAndAnnounce({ drop: [serverName] });
     },
     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}`);
@@ -158,41 +197,39 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
       servers[serverName] = { ...current, enabled: want };
       saveServers(servers);
       const status = await sync.scheduleMcpToggle(serverName, want);
-      await sync.publish('mcp');
+      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/route-resolution.mjs

@@ -5,6 +5,7 @@ import { ensureProviderEnabled } from '../runtime/agent/orchestrator/runtime-cor
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { effortItemsFor } from '../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import { runAbortable, throwIfAborted } from '../runtime/shared/abort-race.mjs';
+import { normalizeContextTokens } from '../runtime/shared/llm/default-context-window.mjs';
 import { resolveRouteContextState, resolveRouteEffortState, routeModelDisplay } from './route-state.mjs';
 
 export function createRouteResolution({ rt, collectProviderModels, ensureProvidersReady, lookupModelMeta }) {
@@ -53,14 +54,22 @@ export function createRouteResolution({ rt, collectProviderModels, ensureProvide
     const selectedContextWindow = [contextState.selectedContextWindow, contextOption?.contextWindow]
       .map(Number)
       .find((value) => value > 0);
+    // Without a known window the exact selection is kept as requested; with
+    // one it is the clamped value, absent when it is the default window.
+    const contextTokens =
+      contextState.contextDefaultPercent === undefined
+        ? normalizeContextTokens(targetRoute.contextTokens)
+        : contextState.contextTokens;
+    const { contextTokens: _requestedTokens, ...routeFields } = targetRoute;
     rt.route = {
-      ...targetRoute,
+      ...routeFields,
       fast: fastCapable ? targetRoute.fast === true : false,
       fastCapable,
       effectiveEffort,
       effortOptions: effortItemsFor(rt.route.provider, modelMeta, effectiveEffort),
       contextPercent: contextState.contextPercent,
       contextDefaultPercent: contextState.contextDefaultPercent,
+      ...(contextTokens ? { contextTokens } : {}),
       ...(selectedContextWindow ? { selectedContextWindow } : {}),
       ...(modelDisplay ? { modelDisplay } : {}),
     };

package/src/session-runtime/route-state.mjs

@@ -1,11 +1,14 @@
 // Pure route derivations: the effective effort / Fast capability of a route
 // against provider model metadata, and its context-window percentage.
-import { modelMetaLooksResolved, modelSettingsFor } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
+import {
+  modelMetaLooksResolved,
+  modelSettingsFor,
+} from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { clean, hasOwn } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { coerceEffortFor } from '../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import { fastCapableFor } from '../runtime/agent/orchestrator/runtime-core/model-capabilities.mjs';
 import { providerCachedModelMetadataSync } from '../runtime/agent/orchestrator/providers/provider-catalog-cache.mjs';
-import { contextWindowRange } from '../runtime/shared/llm/default-context-window.mjs';
+import { contextWindowRange, normalizeContextTokens } from '../runtime/shared/llm/default-context-window.mjs';
 
 export function resolveRouteEffortState(targetRoute = {}, modelMeta = null) {
   const requested = hasOwn(targetRoute, 'effort') ? targetRoute.effort : targetRoute.preset?.effort || null;
@@ -68,6 +71,17 @@ export function resolveRouteContextState(targetRoute = {}, modelMeta = null, win
     return { contextPercent: undefined, contextDefaultPercent: undefined, selectedContextWindow: undefined };
   }
   const contextDefaultPercent = Math.max(10, Math.min(100, Math.round((defaultWindow / maxWindow) * 10) * 10));
+  // An exact token selection overrides the 10% stops. It is clamped to the
+  // selectable range; one that lands on the default window is the default.
+  const requestedTokens = normalizeContextTokens(targetRoute?.contextTokens);
+  if (requestedTokens) {
+    const contextTokens = Math.max(Math.ceil(maxWindow * 0.1), Math.min(maxWindow, requestedTokens));
+    if (contextTokens === defaultWindow) {
+      return { contextPercent: contextDefaultPercent, contextDefaultPercent, selectedContextWindow: defaultWindow };
+    }
+    const contextPercent = Math.max(10, Math.min(100, Math.round((contextTokens / maxWindow) * 10) * 10));
+    return { contextPercent, contextDefaultPercent, selectedContextWindow: contextTokens, contextTokens };
+  }
   const requested = Number(targetRoute?.contextPercent);
   const contextPercent =
     Number.isFinite(requested) && requested > 0

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

@@ -20,6 +20,7 @@ function bootParams({
   fast,
   modelParameters,
   contextPercent,
+  contextTokens,
   selectedContextWindow,
   cwd = process.cwd(),
   toolMode = 'full',
@@ -30,6 +31,7 @@ function bootParams({
   initialConfig = null,
   desktopSession = null,
   sessionProfile = null,
+  worktree = null,
   executeAgentControl = null,
 } = {}) {
   return {
@@ -39,6 +41,7 @@ function bootParams({
     fast,
     modelParameters,
     contextPercent,
+    contextTokens,
     selectedContextWindow,
     cwd,
     toolMode,
@@ -49,6 +52,8 @@ function bootParams({
     initialConfig,
     desktopSession,
     sessionProfile,
+    // Creation-time worktree intent (workspace/transitions.mjs creationIntent).
+    worktree,
     executeAgentControl,
   };
 }

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

@@ -74,6 +74,10 @@ export function createRuntimeFacade({
     get fast() {
       return state.route.fast === true;
     },
+    // The route's Auto effort switch; absent means on.
+    get autoEffort() {
+      return state.route.autoEffort !== false;
+    },
     get fastCapable() {
       return state.route.fastCapable === true;
     },
@@ -94,6 +98,10 @@ export function createRuntimeFacade({
       // Picker preference for a new/inherited session, not the live gauge.
       return state.route?.contextPercent ?? state.session?.contextPercent ?? null;
     },
+    get contextTokens() {
+      // Exact window preference in tokens; null when the route uses a percent stop.
+      return state.route ? state.route.contextTokens || null : state.session?.contextTokens || null;
+    },
     get rawContextWindow() {
       return state.session?.rawContextWindow || state.session?.contextWindow || null;
     },

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

@@ -2,7 +2,10 @@ import { registerCacheInvalidationListener } from '../runtime/agent/orchestrator
 import { turnReviewReply } from '../runtime/shared/turn-review-reply.mjs';
 import {
   getSessionReviewDiff,
+  getTurnChanges,
   getTurnReviewDiff,
+  reapplyTurnChanges,
+  revertTurnChanges,
   revertTurnReview,
   revertTurnReviewFile,
 } from '../runtime/shared/turn-snapshot.mjs';
@@ -22,5 +25,11 @@ export function createRuntimeReviewApi({ getCwd, getSessionId }) {
     getSessionReviewDiff: () => getSessionReviewDiff(getCwd(), getSessionId()),
     revertTurnReview: (checkpointId) => revertTurnReview(getCwd(), getSessionId(), checkpointId),
     revertTurnReviewFile: (file, checkpointId) => revertTurnReviewFile(getCwd(), getSessionId(), file, checkpointId),
+    // Historical per-turn changes, addressed by checkpointId (TurnChangesReply).
+    getTurnChanges: (options = {}) => getTurnChanges(getSessionId(), options),
+    revertTurnChanges: (checkpointId, file, revision) =>
+      revertTurnChanges(getSessionId(), checkpointId, file, revision),
+    reapplyTurnChanges: (checkpointId, file, revision) =>
+      reapplyTurnChanges(getSessionId(), checkpointId, file, revision),
   };
 }