mixdog 1.1.1 → 1.2.0

package/src/session-runtime/internal-tool-executor.mjs

@@ -31,6 +31,7 @@ export function createInternalToolExecutor({
   mcpStatus,
   applyResolvedCwd,
   skillToolContent,
+  getWorkspaceApi,
 }) {
   const handlers = {
     ...createBridgeToolHandlers({ rt }),
@@ -46,7 +47,14 @@ export function createInternalToolExecutor({
       mcpStatus,
       skillToolContent,
     }),
-    ...createWorkspaceToolHandlers({ rt, goalRuntime, agentTool, notifyFnForSession, applyResolvedCwd }),
+    ...createWorkspaceToolHandlers({
+      rt,
+      goalRuntime,
+      agentTool,
+      notifyFnForSession,
+      applyResolvedCwd,
+      getWorkspaceApi,
+    }),
   };
 
   // Settings-disabled features are refused for model-initiated calls before

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

@@ -8,7 +8,12 @@ import {
   isRootLeadSession,
 } from '../../runtime/agent/orchestrator/session/store-summary-visibility.mjs';
 import { listSessionHeartbeatMtimes } from '../../runtime/agent/orchestrator/session/store/paths-heartbeat.mjs';
-import { sessionMessageText, isSessionPreviewNoise, cleanSessionPreview, clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import {
+  sessionMessageText,
+  isSessionPreviewNoise,
+  cleanSessionPreview,
+  clean,
+} from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 
 const VISIBLE_OWNERS = ['cli', 'user', 'mixdog'];
 
@@ -58,6 +63,8 @@ function leadSessionRow(s, heartbeatMtimes) {
   // it remains an ordinary resumable session, not a child dispatch.
   if (!isRootLeadSession(s) && owner && !VISIBLE_OWNERS.includes(owner)) return null;
   const sourceType = clean(s.sourceType || '').toLowerCase();
+  // One-shot `mixdog exec` runs are never resumable conversations.
+  if (sourceType === 'exec') return null;
   if (!isLeadShaped(s, owner, sourceType)) return null;
   const { preview, messageCount } = previewOf(s);
   if (!preview && messageCount === 0) return null;

package/src/session-runtime/lifecycle/session-switch/context-switch.mjs

@@ -3,6 +3,7 @@
  * new desktop context (cwd + desktop session) or a fresh session.
  */
 import { isScratchSession } from '../shared.mjs';
+import { replacementSessionCwd } from '../../workspace/workspace-state.mjs';
 
 export function createContextSwitch(deps, { ingestSessionIntoMemory, closeSurfaceSession, releaseSessionWork }) {
   const {
@@ -59,11 +60,15 @@ export function createContextSwitch(deps, { ingestSessionIntoMemory, closeSurfac
   async function newSession() {
     deps.assertNotAddressed?.('newSession');
     const session = getSession();
+    // Leaving a worktree-bound Lead: the new session starts in the Project
+    // folder, never in the worktree the old session retains.
+    const projectFolder = replacementSessionCwd(session);
     if (session?.id) {
       void ingestSessionIntoMemory(session);
       closeSurfaceSession(session, 'cli-new', { tombstone: isScratchSession(session) });
       setSession(null);
     }
+    if (projectFolder) await applyResolvedCwd(projectFolder);
     invalidateContextStatusCache();
     await createCurrentSession();
     return getSession().id;

package/src/session-runtime/lifecycle/session-switch/resume.mjs

@@ -10,8 +10,16 @@ import {
   deferredSurfaceModeForLead,
 } from '../../../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import { isScratchConversation } from '../shared.mjs';
+import { compactionArchiveRange } from '../../../runtime/agent/orchestrator/session/compaction-archive.mjs';
+import { stampCompactionMessageIds } from '../../../runtime/agent/orchestrator/session/compaction-archive-capture.mjs';
+import { boundWorkspaceCwd, restoreWorkspaceAfterResume } from '../../workspace/workspace-state.mjs';
 
 export function resolveResumeCwd(session, currentCwd) {
+  // A worktree-bound Lead resumes in its worktree whatever its desktop class;
+  // a vanished worktree resumes in the Project folder in `recovery`, where
+  // turns are refused (restoreWorkspaceAfterResume) rather than silently run.
+  const bound = boundWorkspaceCwd(session);
+  if (bound) return bound.cwd;
   const desktop = session?.desktopSession;
   if (desktop?.classification === 'project') {
     // `session.cwd` is the execution source of truth. Older builds updated it
@@ -60,9 +68,9 @@ export function createSessionResume(deps, { ingestSessionIntoMemory, closeSurfac
   }
 
   // The resumed session's OWN effort wins. resolveRoute always returns an
-  // effort key, so this used to reinstate the effort of whichever session
-  // happened to be open before — a schedule/webhook session opened with a
-  // different effort than the one it actually ran with.
+  // effort key, so the route's effort applies only when the session has none —
+  // otherwise a schedule/webhook session would reopen with the effort of
+  // whichever session happened to be open before.
   function resumedRouteFor(resumed) {
     const route = getRoute();
     const resumeEffort = resumed.effort || (hasOwn(route, 'effort') ? route.effort : undefined);
@@ -71,6 +79,7 @@ export function createSessionResume(deps, { ingestSessionIntoMemory, closeSurfac
       model: resumed.model,
       effort: resumeEffort,
       fast: resumed.fast === true,
+      autoEffort: resumed.autoEffort !== false,
       modelParameters: resumed.modelParameters || {},
     });
   }
@@ -92,6 +101,8 @@ export function createSessionResume(deps, { ingestSessionIntoMemory, closeSurfac
       const activeSession = getSession();
       activeSession.effort = getRoute().effectiveEffort || null;
       activeSession.fast = getRoute().fast === true;
+      if (getRoute().autoEffort === false) activeSession.autoEffort = false;
+      else delete activeSession.autoEffort;
       activeSession.cwd = getCurrentCwd();
       restoreResumedToolSurface(activeSession, getRoute());
       writeStatuslineRoute(statusRoutes, activeSession, getRoute());
@@ -124,11 +135,16 @@ export function createSessionResume(deps, { ingestSessionIntoMemory, closeSurfac
     };
     const resumed = await mgr.resumeSession(id, toolSpecForMode(getMode()), resumeOptions);
     if (!resumed) return null;
+    // Restored rows carry their messages' stable ids (legacy transcripts are
+    // stamped here and persisted), so a live compaction can grey exactly the
+    // rows of what it drops.
+    stampCompactionMessageIds(resumed.messages, resumed.id || id);
     retirePrevious(previous, resumed);
     setSession(resumed);
     // Resume is not work: the Lead pool row is written only by turn
     // start/settle, so opening an old conversation never re-lists it in the
     // Agent window for another reap window (user report).
+    restoreWorkspaceAfterResume(resumed);
     applyResolvedCwd(resolveResumeCwd(resumed, getCurrentCwd()));
     // Commit the applied cwd before returning the resume transcript.
     resumed.cwd = getCurrentCwd();
@@ -154,6 +170,8 @@ export function createSessionResume(deps, { ingestSessionIntoMemory, closeSurfac
       cwd: getCurrentCwd(),
       provider: resumed.provider,
       model: resumed.model,
+      // The display-only compaction archive above the restored rows.
+      transcriptArchive: compactionArchiveRange(resumed),
     };
   }
 

package/src/session-runtime/lifecycle/session-switch/session-delete.mjs

@@ -7,6 +7,7 @@ import { clean } from '../../../runtime/agent/orchestrator/runtime-core/session-
 import { forgetSessionSearch } from '../../../runtime/session-search/session-search-ingest.mjs';
 import { listLeadSessions } from '../session-catalog.mjs';
 import { SESSION_ID_PATTERN } from '../shared.mjs';
+import { replacementSessionCwd } from '../../workspace/workspace-state.mjs';
 
 export function createSessionDelete(deps, { cancelBackgroundTasks }) {
   const {
@@ -49,6 +50,14 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
     }
   }
 
+  // The deleted task's worktree: the autoCleanup setting decides (clean and
+  // merged → removed; otherwise kept). Off the deletion path; never fails it.
+  function releaseDeletedWorktree(sessionId) {
+    return Promise.resolve()
+      .then(() => deps.cleanupDeletedSessionWorktree?.(sessionId))
+      .catch(() => {});
+  }
+
   async function deleteSession(id) {
     const sessionId = clean(id);
     if (!sessionId || !SESSION_ID_PATTERN.test(sessionId)) return false;
@@ -68,8 +77,12 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
           mgr.deleteSession(childId);
         } catch {}
       }
+      void releaseDeletedWorktree(sessionId);
       return true;
     }
+    // Leaving a worktree-bound Lead: the replacement starts in the Project
+    // folder, and the worktree can go once nothing runs in it.
+    const projectFolder = replacementSessionCwd(current);
     const cleanupReason = 'desktop-session-delete';
     releaseSessionWork(sessionId, cleanupReason);
     // Active sessions retain a tombstone until the normal sweep. Unlinking
@@ -86,15 +99,18 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
       } catch {}
     }
     setSession(null);
+    if (projectFolder) await deps.applyResolvedCwd?.(projectFolder);
     invalidateContextStatusCache();
     invalidatePreSessionToolSurface();
     // An addressed runtime never mints a replacement under the deleted
     // address: it becomes terminal and a new conversation needs a new entry.
     if (deps.getAddressedSessionId?.()) {
       deps.markAddressTerminal?.();
+      void releaseDeletedWorktree(sessionId);
       return true;
     }
     await createCurrentSession();
+    void releaseDeletedWorktree(sessionId);
     return true;
   }
 

package/src/session-runtime/mcp-glue/connect.mjs

@@ -24,11 +24,10 @@ export function createMcpConnect({ mcpClient, getMcpScopeId, state, resolveEffec
     }
     const cfg = servers[target];
     if (!cfg) return;
-    // Drop any existing live entry first so connectMcpServers doesn't overwrite
-    // the registry Map entry and leak the old transport/process.
-    await mcpClient.disconnectMcpServer?.(target, scopeOptions());
+    // Close-then-connect as one generation-guarded op: a shutdown landing
+    // between the close and the connect never resurrects the server.
     try {
-      await mcpClient.connectMcpServers({ [target]: cfg }, scopeOptions());
+      await mcpClient.reconnectSingleMcpServer(getMcpScopeId(), target, cfg);
     } catch (error) {
       const failures = Array.isArray(error?.failures)
         ? error.failures
@@ -126,8 +125,14 @@ export function createMcpConnect({ mcpClient, getMcpScopeId, state, resolveEffec
     if (!inFlight) return;
     let budgetMs = 10000;
     try {
-      const resolved = mcpClient.resolveMcpStartupTimeoutMs?.({});
-      if (Number.isFinite(resolved)) budgetMs = resolved;
+      // The gate must outlast the slowest enabled server's own startup budget;
+      // a server with its budget disabled (0) means the connect may never
+      // settle, so the whole gate is disabled (handled below).
+      const configs = Object.values(resolveEffectiveMcpServers().servers).filter((cfg) => cfg?.enabled !== false);
+      const budgets = (configs.length > 0 ? configs : [{}])
+        .map((cfg) => mcpClient.resolveMcpStartupTimeoutMs?.(cfg))
+        .filter((value) => Number.isFinite(value));
+      if (budgets.length > 0) budgetMs = budgets.includes(0) ? 0 : Math.max(...budgets);
     } catch {
       /* fall back to default budget */
     }

package/src/session-runtime/mcp-glue/server-catalog.mjs

@@ -68,13 +68,17 @@ export function createMcpServerCatalog({ mcpClient, getConfig, getMcpScopeId, st
     const servers = [];
     for (const [name, cfg] of Object.entries(configured)) {
       const live = connected.get(name);
-      const fail = failures.get(name);
+      // A registered server whose client reports it not alive (runtime
+      // failure after connect) is surfaced as failed, not connected.
+      const dead = live && (live.alive === false || live.connected === false);
+      const fail =
+        failures.get(name) || (dead ? { msg: live.error || live.lastError || 'MCP server is not alive' } : undefined);
       servers.push({
         name,
         configured: true,
         enabled: cfg?.enabled !== false,
-        connected: Boolean(live),
-        status: mcpServerStatus(cfg, live, fail),
+        connected: Boolean(live) && !dead,
+        status: mcpServerStatus(cfg, live && !dead, fail),
         transport: mcpTransportLabel(cfg),
         toolCount: live?.toolCount || 0,
         tools: live?.tools || [],

package/src/session-runtime/mcp-glue/server-input.mjs

@@ -26,8 +26,37 @@ function coerceStringArray(value) {
   return Array.isArray(value) ? value.map((entry) => clean(entry)).filter(Boolean) : [];
 }
 
+function positiveNumber(value, label) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) throw new Error(`${label} must be a positive number`);
+  return n;
+}
+
+// Per-server timeouts, stored under the keys client-config.mjs already reads:
+// startupTimeoutSec/startupTimeoutMs and timeoutMs. A stored value (save
+// merges the existing entry into the input) round-trips unchanged unless the
+// setup-facing startupTimeoutSec/toolTimeoutSec overrides it.
+function timeoutFields(input) {
+  const out = {};
+  const startupSec = input.startupTimeoutSec ?? input.startup_timeout_sec;
+  if (startupSec != null && startupSec !== '') out.startupTimeoutSec = positiveNumber(startupSec, 'startupTimeoutSec');
+  else if (input.startupTimeoutMs != null && input.startupTimeoutMs !== '')
+    out.startupTimeoutMs = positiveNumber(input.startupTimeoutMs, 'startupTimeoutMs');
+  if (input.toolTimeoutSec != null && input.toolTimeoutSec !== '')
+    out.timeoutMs = Math.round(positiveNumber(input.toolTimeoutSec, 'toolTimeoutSec') * 1000);
+  else if (input.timeoutMs != null && input.timeoutMs !== '')
+    out.timeoutMs = Math.round(positiveNumber(input.timeoutMs, 'timeoutMs'));
+  return out;
+}
+
 export function createMcpServerInput({ mcpClient, getCurrentCwd }) {
   function normalizeMcpServerInput(input = {}) {
+    const result = normalizeTransport(input);
+    Object.assign(result.config, timeoutFields(input));
+    return result;
+  }
+
+  function normalizeTransport(input) {
     const currentCwd = getCurrentCwd();
     const name = clean(input.name)
       .toLowerCase()

package/src/session-runtime/model-route/route-persist.mjs

@@ -52,6 +52,9 @@ export function createRoutePersistence(deps) {
       // A selection for the heir must not leak its tuning into the source model.
       if (!sessionUsesRoute(session, route)) return;
       session.fast = route.fast === true;
+      // Absent means on; only the off state is stored on the session.
+      if (route.autoEffort === false) session.autoEffort = false;
+      else delete session.autoEffort;
       session.effort = route.effectiveEffort || null;
       // The request path reads session.modelParameters; keep only serviceTier in step.
       const { serviceTier: _previous, ...otherParameters } = session.modelParameters || {};

package/src/session-runtime/model-route/set-route.mjs

@@ -55,12 +55,23 @@ async function resolveSelectedRoute(deps, next) {
     selectedRoute.effort,
     selectedRoute.modelParameters
   );
+  const contextState = resolveRouteContextState(selectedRoute, modelMeta);
+  // An exact selection is saved clamped, and not at all when it is the
+  // default window; an unknown window keeps it as requested.
+  const contextTokens =
+    contextState.contextDefaultPercent === undefined ? selectedRoute.contextTokens : contextState.contextTokens;
+  const { contextTokens: requestedTokens, ...routeFields } = selectedRoute;
+  // Tokens that land on the default window select the default, whatever
+  // percent travelled with them.
+  const tokensAtDefault = requestedTokens && !contextTokens && contextState.contextDefaultPercent !== undefined;
   return {
     selectedRoute: {
-      ...selectedRoute,
+      ...routeFields,
+      ...(tokensAtDefault ? { contextPercent: contextState.contextDefaultPercent } : {}),
       fast: fastCapable ? selectedRoute.fast === true : false,
       // Lets the saved model settings tell a chosen window from the default.
-      contextDefaultPercent: resolveRouteContextState(selectedRoute, modelMeta).contextDefaultPercent,
+      contextDefaultPercent: contextState.contextDefaultPercent,
+      ...(contextTokens ? { contextTokens } : {}),
     },
     fastCapable,
     modelMeta,
@@ -92,9 +103,11 @@ function updateSessionInPlace(deps, session, updateOptions) {
     provider: route.provider,
     model: route.model,
     fast: route.fast === true,
+    autoEffort: route.autoEffort !== false,
     effort: route.effectiveEffort || null,
     modelParameters: route.modelParameters || {},
     contextPercent: route.contextPercent,
+    contextTokens: route.contextTokens || null,
     selectedContextWindow: route.selectedContextWindow || null,
   };
   const updated = mgr.updateSessionRoute?.(session.id, fields, updateOptions);

package/src/session-runtime/notification-bus.mjs

@@ -29,7 +29,7 @@ function cleanSessionId(value) {
 // the wake would leave its durable entry parked until the next user message.
 // A completion whose owner is no longer the live session is still dropped (the
 // durable queue carries it into that session's next turn).
-export function createCompletionWakeScheduler({ getCurrentSessionId, getTurnApi, getOwnerLifecycle }) {
+export function createCompletionWakeScheduler({ getCurrentSessionId, getTurnApi, getOwnerLifecycle, beforeWake }) {
   // A closing/terminal owner never starts inference from a completion; the
   // check runs at request time and again inside the delayed callback.
   const ownerOpen = (sessionId) => {
@@ -55,6 +55,14 @@ export function createCompletionWakeScheduler({ getCurrentSessionId, getTurnApi,
               ` executionId=${executionId || 'unknown'} queuedMs=${delayMs}\n`
           );
         }
+        // Surface hook (idle auto-clear): compacts a cold-cache session before
+        // the wake sends it. A failing hook never blocks the wake.
+        if (typeof beforeWake === 'function') {
+          try {
+            await beforeWake(ownerSessionId);
+          } catch {}
+          if (cleanSessionId(getCurrentSessionId()) !== ownerSessionId || !ownerOpen(ownerSessionId)) return;
+        }
         // The wake continues the user turn that launched the worker, so its
         // review keeps that turn's Lead edits and worker diffs.
         await turnApi.ask('', { submittedAt: queuedAt, continueTurn: true });

package/src/session-runtime/provider-models/row-hydration.mjs

@@ -65,8 +65,10 @@ export function hydrateProviderModelRow(cfg, row) {
       ) || customAutoEffortCapable(row.provider, cfg?.providers?.[row.provider]?.protocol, row),
     savedEffort: saved.effort || null,
     savedFast: Object.hasOwn(saved, 'fast') ? saved.fast === true : undefined,
+    savedAutoEffort: Object.hasOwn(saved, 'autoEffort') ? saved.autoEffort !== false : undefined,
     savedModelParameters: saved.modelParameters || {},
     savedContextPercent: Number(saved.contextPercent) || undefined,
+    savedContextTokens: Number(saved.contextTokens) || undefined,
   };
 }
 

package/src/session-runtime/resource-extension-sync.mjs

@@ -28,17 +28,27 @@ export function createExtensionSync({
     }
   }
 
-  async function refreshState(kind) {
+  // Apply per-server MCP changes in order; every other server stays untouched.
+  async function applyMcpChanges(changes) {
+    let status;
+    for (const { name, enabled } of changes) status = await connectConfiguredMcp({ only: name, enabled });
+    return status;
+  }
+
+  async function refreshState(kind, detail = null) {
     reloadFullConfig?.();
     if (kind === 'skills' || kind === 'plugins') invalidateSkills?.();
-    if (kind === 'mcp' || kind === 'plugins') {
+    const mcpChanges = kind === 'mcp' ? detail?.mcpChanges : null;
+    if (Array.isArray(mcpChanges)) {
+      await applyMcpChanges(mcpChanges);
+    } else if (kind === 'mcp' || kind === 'plugins') {
       await connectConfiguredMcp({ reset: true });
     }
     await refreshSurface(kind);
   }
 
   const subscription = subscribeGlobalExtensionChanges(refreshState);
-  const publish = (kind) => publishGlobalExtensionChange(kind, subscription.id);
+  const publish = (kind, detail = null) => publishGlobalExtensionChange(kind, subscription.id, detail);
 
   function scheduleMcpToggle(serverName, enabled) {
     const chain = mcpToggleChains.get(serverName) || { desired: enabled, running: null };
@@ -65,14 +75,27 @@ export function createExtensionSync({
 
   /** Skills/plugins invalidate the skill cache; every kind rebuilds the
    *  pre-session surface and notifies the other runtimes. */
-  async function announce(kind, { invalidate = kind !== 'mcp' } = {}) {
+  async function announce(kind, { invalidate = kind !== 'mcp', detail = null } = {}) {
     if (invalidate) invalidateSkills?.();
     await refreshSurface(kind);
-    await publish(kind);
+    await publish(kind, detail);
   }
 
-  /** Reconnect every configured MCP server after a config write, then announce. */
-  async function reconnectMcpAndAnnounce() {
+  /** Reconnect MCP after a config write, then announce. With `only`, just that
+   *  server is (re)connected (or disconnected when `enabled` is false) and
+   *  `drop` names (e.g. a renamed/removed server) are disconnected; every other
+   *  server stays untouched. Without `only`, every configured server reconnects. */
+  async function reconnectMcpAndAnnounce({ only = null, enabled = true, drop = [] } = {}) {
+    if (only || drop.length > 0) {
+      // Other runtimes receive the same scoped change list, not a full reset.
+      const mcpChanges = [
+        ...drop.map((name) => ({ name, enabled: false })),
+        ...(only ? [{ name: only, enabled }] : []),
+      ];
+      const status = await applyMcpChanges(mcpChanges);
+      await announce('mcp', { detail: { mcpChanges } });
+      return status;
+    }
     const status = await connectConfiguredMcp({ reset: true });
     await announce('mcp');
     return status;

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

@@ -11,6 +11,7 @@ import {
   pluginServerMatcher,
   resolveContainedPluginPath,
   mergeMcpServerConfig,
+  MCP_TIMEOUT_FIELD_GROUPS,
 } from '../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
 
 /** The `mcpServers` map of a config as a fresh object (never the live one). */
@@ -63,8 +64,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,
@@ -98,25 +104,32 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     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());
       if (Object.hasOwn(servers, name)) throw new Error(`MCP server already exists: ${name}`);
       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 originalName = clean(input.originalName) || clean(input.name);
-      if (originalName && !Object.hasOwn(servers, originalName)) {
-        throw new Error(`MCP server not configured: ${originalName}`);
+      // An explicit originalName must exist; a bare name edits a matching
+      // server and otherwise creates a new one.
+      const explicitOriginal = clean(input.originalName);
+      if (explicitOriginal && !Object.hasOwn(servers, explicitOriginal)) {
+        throw new Error(`MCP server not configured: ${explicitOriginal}`);
       }
+      const bareName = clean(input.name);
+      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;
@@ -126,7 +139,11 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
       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) {
@@ -138,7 +155,7 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
       }
       delete servers[serverName];
       saveServers(servers);
-      return sync.reconnectMcpAndAnnounce();
+      return sync.reconnectMcpAndAnnounce({ drop: [serverName] });
     },
     async setMcpServerEnabled(name, enabled) {
       const serverName = clean(name);
@@ -154,7 +171,7 @@ 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;
     },
     async enablePluginMcp(plugin = {}) {

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-bootstrap.mjs

@@ -10,7 +10,6 @@ import {
   RUNTIME,
   WEB_SEARCH_TOOL_DEFS,
   MEMORY_TOOL_DEFS,
-  CHANNEL_TOOL_DEFS,
   CODE_GRAPH_TOOL_DEFS,
   STATUSLINE_SESSION_ROUTES,
   STANDALONE_ROOT,
@@ -49,7 +48,6 @@ export async function loadRuntimeModules() {
     statusRoutes,
     webSearchToolDefs,
     memoryToolDefs,
-    channelToolDefs,
     codeGraphToolDefs,
   ] = await Promise.all([
     profiledImport('config', `${RUNTIME}/config.mjs`),
@@ -62,7 +60,6 @@ export async function loadRuntimeModules() {
     profiledImport('status-routes', STATUSLINE_SESSION_ROUTES, { optional: true }),
     profiledImport('web-search-tool-defs', WEB_SEARCH_TOOL_DEFS, { optional: true }),
     profiledImport('memory-tool-defs', MEMORY_TOOL_DEFS, { optional: true }),
-    profiledImport('channel-tool-defs', CHANNEL_TOOL_DEFS, { optional: true }),
     profiledImport('code-graph-tool-defs', CODE_GRAPH_TOOL_DEFS, { optional: true }),
   ]);
   bootProfile('imports:ready', { ms: (performance.now() - startedAt).toFixed(1) });
@@ -88,7 +85,6 @@ export async function loadRuntimeModules() {
     statusRoutes,
     webSearchToolDefs,
     memoryToolDefs,
-    channelToolDefs,
     codeGraphToolDefs,
   };
 }