mixdog 0.9.104 → 0.9.106

package/README.md

@@ -103,7 +103,7 @@ every number above live under `benchmarks/terminal-bench-2.1/`.
   role mode for scripting.
 - Mixdog Desktop: a full agent workbench for Windows/macOS/Linux (see
   below).
-- Web/mobile companion over relay pairing — scan a QR code to open your
+- Installable web app over relay pairing — scan a QR code to open your
   running sessions in a phone browser and keep going from any network.
 - Optional Discord/Telegram channels, webhook endpoints, and cron schedules
   with quiet hours for remote/event-driven workflows; channel voice messages
@@ -246,7 +246,7 @@ wizard covers first-run setup. For development run `npm run dev` inside
 - **Automation** — visual editors for workflow and agent packs, cron
   schedules, webhooks, and channel integrations.
 - **Settings hub** — provider auth, capability sweep, git identity, and
-  QR device pairing for the web/mobile companion, preloaded so every
+  QR device pairing for the installable web app, preloaded so every
   category opens instantly.
 
 ## Scripts
@@ -302,8 +302,7 @@ src/
   rules/         # Lead and agent instructions
 apps/
   desktop/       # Mixdog Desktop — Electron workbench (main/preload/renderer)
-  mobile/        # mobile companion shell
-  relay/         # relay server for remote/web/mobile access
+  relay/         # relay server for remote web-app access
 scripts/
   smoke*.mjs     # smoke checks
   *test.mjs      # focused node:test checks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.104",
+  "version": "0.9.106",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/src/rules/shared/01-tool.md

@@ -14,7 +14,9 @@
   facets in one query array. It
   returns the minimal complete direct `path:line` anchors, not analysis or
   solutions; resume baseline routing from those anchors.
-- Use verified paths (cwd/project/user/tool); explicit paths may be outside cwd;
+- Use verified paths (cwd/project/user/tool). Within the current project, pass
+  project-relative paths and omit optional scopes equal to its root; explicit
+  paths may be outside cwd only for targets outside the project;
   stay focused on the requested outcome. Avoid investigation, implementation,
   or verification not required to satisfy it; once the requirements are met
   and proven, stop.

package/src/runtime/agent/orchestrator/agent-runtime/session-builder.mjs

@@ -64,6 +64,7 @@ function normalizeAgentCompactionConfig(value = {}, { memoryEnabled = true } = {
  * @param {number}  [opts.maxLoopIterations]
  * @param {string}  [opts.parentSessionId]
  * @param {string|null} [opts.ownerSessionId] - owning Mixdog MCP instance id for statusline isolation
+ * @param {string|null} [opts.mcpScopeId] - owning session-runtime MCP registry scope
  * @returns {{ session: object, effectiveCwd: string|null }}
  */
 export function prepareAgentSession({
@@ -86,6 +87,7 @@ export function prepareAgentSession({
     cacheKeyOverride,
     schemaAllowedTools,
     sessionId,
+    mcpScopeId,
 }) {
     const effectivePermission = resolveAgentSessionPermission(agent, permission);
     // No per-agent loop caps: sessions either pin maxLoopIterations explicitly
@@ -121,6 +123,7 @@ export function prepareAgentSession({
         ownerSessionId: effectiveOwnerSessionId || null,
         clientHostPid: clientHostPid || null,
         compaction: compaction || undefined,
+        mcpScopeId: mcpScopeId || null,
     };
     if (agentTag) sessionOpts.agentTag = agentTag;
     if (effectivePermission) sessionOpts.permission = effectivePermission;

package/src/runtime/agent/orchestrator/mcp/client.mjs

@@ -28,6 +28,10 @@ const DEFAULT_MCP_STARTUP_TIMEOUT_MS = 10000;
 const servers = new Map();
 const reconnects = createKeyedSingleflight();
 const callAdmissions = new Map();
+const DEFAULT_MCP_SCOPE_ID = 'global';
+const _knownMcpScopes = new Set([DEFAULT_MCP_SCOPE_ID]);
+const _connectAbortGenerations = new Map();
+const _pendingConnects = new Set();
 let mcpSdkPromise = null;
 // Memo for mcpToolHasField(name, field) — keyed by `${toolName}|${field}`.
 // The lookup (regex parse + servers Map get + tools.find + schema property
@@ -39,6 +43,30 @@ const _mcpToolFieldMemo = new Map();
 function _invalidateMcpToolFieldMemo() {
     _mcpToolFieldMemo.clear();
 }
+function normalizeMcpScopeId(value) {
+    const raw = value && typeof value === 'object' ? value.scopeId : value;
+    const scopeId = String(raw || '').trim();
+    return scopeId || DEFAULT_MCP_SCOPE_ID;
+}
+function mcpServerRegistryKey(scopeId, name) {
+    return `${normalizeMcpScopeId(scopeId)}\u0000${String(name || '')}`;
+}
+function scopedServer(scopeId, name) {
+    return servers.get(mcpServerRegistryKey(scopeId, name));
+}
+function scopedServerEntries(scopeId) {
+    const normalized = normalizeMcpScopeId(scopeId);
+    return [...servers.entries()].filter(([, server]) => server?.scopeId === normalized);
+}
+function currentConnectAbortGeneration(scopeId) {
+    return _connectAbortGenerations.get(normalizeMcpScopeId(scopeId)) || 0;
+}
+function bumpConnectAbortGeneration(scopeId) {
+    const normalized = normalizeMcpScopeId(scopeId);
+    const next = currentConnectAbortGeneration(normalized) + 1;
+    _connectAbortGenerations.set(normalized, next);
+    return next;
+}
 function mcpLog(line) {
     if (process.env.MIXDOG_QUIET_MCP_LOG) return;
     process.stderr.write(line);
@@ -106,12 +134,14 @@ export function resolveMcpTransportKind(cfg) {
  * Connect to MCP servers defined in config.
  * Supports stdio (child process) and http (Streamable HTTP) transports.
  */
-export async function connectMcpServers(config) {
+export async function connectMcpServers(config, options = {}) {
+    const scopeId = normalizeMcpScopeId(options);
+    _knownMcpScopes.add(scopeId);
     // Capture the abort generation SYNCHRONOUSLY at entry: the boot path fires
     // this un-awaited, so a runtime close can land while connectServer is still
     // loading the SDK. A capture taken any later would already see the bumped
     // generation and register the server anyway (leaking its stdio child).
-    const genAtStart = _connectAbortGeneration;
+    const genAtStart = currentConnectAbortGeneration(scopeId);
     const failures = [];
     const entries = Object.entries(config).filter(([name, cfg]) => {
         if (cfg?.enabled === false) {
@@ -123,7 +153,7 @@ export async function connectMcpServers(config) {
     // Connect all servers in PARALLEL: a slow/hung server (bounded by its
     // per-server startup timeout) must never delay the others' handshakes.
     const settled = await Promise.allSettled(
-        entries.map(([name, cfg]) => connectServer(name, cfg, genAtStart)),
+        entries.map(([name, cfg]) => connectServer(name, cfg, scopeId, genAtStart)),
     );
     settled.forEach((res, i) => {
         if (res.status !== 'rejected') return;
@@ -143,15 +173,15 @@ export async function connectMcpServers(config) {
  * Get all tool definitions from connected MCP servers.
  * Tool names are prefixed: `mcp__{serverName}__{toolName}`
  */
-export function getMcpTools() {
+export function getMcpTools(scopeId = DEFAULT_MCP_SCOPE_ID) {
     const tools = [];
-    for (const server of servers.values()) {
+    for (const [, server] of scopedServerEntries(scopeId)) {
         tools.push(...server.tools);
     }
     return tools;
 }
-export function getMcpServerStatus() {
-    return [...servers.values()].map((server) => ({
+export function getMcpServerStatus(scopeId = DEFAULT_MCP_SCOPE_ID) {
+    return scopedServerEntries(scopeId).map(([, server]) => ({
         name: server.name,
         connected: true,
         toolCount: Array.isArray(server.tools) ? server.tools.length : 0,
@@ -173,7 +203,8 @@ function positiveInt(value, fallback) {
     return Number.isFinite(parsed) && parsed >= 1 ? parsed : fallback;
 }
 function callAdmissionFor(server) {
-    let gate = callAdmissions.get(server.name);
+    const registryKey = server.registryKey || mcpServerRegistryKey(server.scopeId, server.name);
+    let gate = callAdmissions.get(registryKey);
     if (gate) return gate;
     const cfg = server?.cfg || {};
     gate = createOwnerFairGate({
@@ -192,44 +223,53 @@ function callAdmissionFor(server) {
             30_000,
         ),
     });
-    callAdmissions.set(server.name, gate);
+    gate.mcpServerName = server.name;
+    gate.mcpScopeId = server.scopeId;
+    callAdmissions.set(registryKey, gate);
     return gate;
 }
-function closeCallAdmission(name, reason) {
-    const gate = callAdmissions.get(name);
+function closeCallAdmission(scopeId, name, reason) {
+    const registryKey = mcpServerRegistryKey(scopeId, name);
+    const gate = callAdmissions.get(registryKey);
     if (!gate) return;
-    callAdmissions.delete(name);
+    callAdmissions.delete(registryKey);
     gate.close(reason || `MCP ${name} disconnected`);
 }
-export function getMcpAdmissionSnapshot() {
-    return [...callAdmissions.entries()].map(([name, gate]) => ({
-        name,
+export function getMcpAdmissionSnapshot(options = undefined) {
+    const scoped = options !== undefined;
+    const scopeId = scoped ? normalizeMcpScopeId(options) : null;
+    return [...callAdmissions.values()]
+      .filter((gate) => !scoped || gate.mcpScopeId === scopeId)
+      .map((gate) => ({
+        name: gate.mcpServerName,
+        scopeId: gate.mcpScopeId,
         ...gate.snapshot(),
     }));
 }
 
 /** Snapshot of MCP initialize `instructions` per connected server (handshake time). */
-export function getMcpServerInstructionsMap() {
+export function getMcpServerInstructionsMap(scopeId = DEFAULT_MCP_SCOPE_ID) {
     const out = {};
-    for (const server of servers.values()) {
+    for (const [, server] of scopedServerEntries(scopeId)) {
         const text = typeof server.instructions === 'string' ? server.instructions.trim() : '';
         if (text) out[server.name] = text;
     }
     return out;
 }
 
-async function reconnectMcpServer(serverName, failedServer) {
-    return reconnects.run(serverName, async () => {
-        const current = servers.get(serverName);
+async function reconnectMcpServer(scopeId, serverName, failedServer) {
+    const registryKey = mcpServerRegistryKey(scopeId, serverName);
+    return reconnects.run(registryKey, async () => {
+        const current = servers.get(registryKey);
         // A peer already completed the replacement while this failed call was
         // unwinding. Reuse it immediately instead of closing a fresh transport.
         if (current && current !== failedServer) return current;
         if (current) {
             await _closeServer(current);
-            if (servers.get(serverName) === current) servers.delete(serverName);
+            if (servers.get(registryKey) === current) servers.delete(registryKey);
         }
-        await connectServer(serverName, failedServer.cfg);
-        const replacement = servers.get(serverName);
+        await connectServer(serverName, failedServer.cfg, scopeId);
+        const replacement = servers.get(registryKey);
         if (!replacement) {
             throw new Error(`reconnect succeeded but server "${serverName}" entry is missing from registry`);
         }
@@ -247,7 +287,8 @@ export async function executeMcpTool(name, args, options = {}) {
     if (!match)
         throw new Error(`Not an MCP tool name: ${name}`);
     const [, serverName, toolName] = match;
-    const server = servers.get(serverName);
+    const scopeId = normalizeMcpScopeId(options);
+    const server = scopedServer(scopeId, serverName);
     if (!server)
         throw new Error(`MCP server "${serverName}" not connected`);
     const gate = callAdmissionFor(server);
@@ -264,7 +305,7 @@ export async function executeMcpTool(name, args, options = {}) {
             mcpLog(`[mcp-client] Tool call failed, attempting shared reconnect...\n`);
             let retryServer;
             try {
-                retryServer = await reconnectMcpServer(serverName, server);
+                retryServer = await reconnectMcpServer(scopeId, serverName, server);
             } catch (reconnectErr) {
                 const reconnectMsg = reconnectErr instanceof Error ? reconnectErr.message : String(reconnectErr);
                 throw new Error(`Tool call failed: ${firstMsg}; reconnect also failed: ${reconnectMsg}`);
@@ -415,12 +456,12 @@ export function isMcpTool(name) {
     return name.startsWith('mcp__');
 }
 /** True when the prefixed name exists on a connected MCP server. */
-export function isRegisteredMcpTool(name) {
+export function isRegisteredMcpTool(name, scopeId = DEFAULT_MCP_SCOPE_ID) {
     if (!isMcpTool(name)) return false;
     const match = name.match(/^mcp__(.+?)__(.+)$/);
     if (!match) return false;
     const [, serverName] = match;
-    const server = servers.get(serverName);
+    const server = scopedServer(scopeId, serverName);
     if (!server || !Array.isArray(server.tools)) return false;
     return server.tools.some((t) => t?.name === name);
 }
@@ -430,14 +471,15 @@ export function isRegisteredMcpTool(name) {
  * (e.g. cwd) into the args before dispatch — schemas that don't declare the
  * field would reject the unknown argument.
  */
-export function mcpToolHasField(name, field) {
-    const memoKey = `${name}|${field}`;
+export function mcpToolHasField(name, field, scopeId = DEFAULT_MCP_SCOPE_ID) {
+    const normalizedScopeId = normalizeMcpScopeId(scopeId);
+    const memoKey = `${normalizedScopeId}|${name}|${field}`;
     const memoized = _mcpToolFieldMemo.get(memoKey);
     if (memoized !== undefined) return memoized;
     const match = name.match(/^mcp__(.+?)__(.+)$/);
     if (!match) { _mcpToolFieldMemo.set(memoKey, false); return false; }
     const [, serverName] = match;
-    const server = servers.get(serverName);
+    const server = scopedServer(normalizedScopeId, serverName);
     if (!server) { _mcpToolFieldMemo.set(memoKey, false); return false; }
     const tool = server.tools.find((t) => t.name === name);
     if (!tool) { _mcpToolFieldMemo.set(memoKey, false); return false; }
@@ -449,14 +491,24 @@ export function mcpToolHasField(name, field) {
 /**
  * Disconnect all MCP servers.
  */
-export async function disconnectAll() {
+export async function disconnectAll(options = undefined) {
+    const hasExplicitScope = options && typeof options === 'object'
+        && Object.prototype.hasOwnProperty.call(options, 'scopeId');
+    const scopes = hasExplicitScope
+        ? new Set([normalizeMcpScopeId(options)])
+        : new Set([
+            ..._knownMcpScopes,
+            ...[...servers.values()].map((server) => server.scopeId),
+            ...[..._pendingConnects].map((entry) => entry.scopeId),
+        ]);
     // Abort handshakes still in flight: bump the generation so a connect that
     // completes after this point tears itself down instead of registering, and
     // reap any already-spawned stdio child now so its ref'd ChildProcess handle
     // can't keep the event loop alive (close-during-connect previously leaked
     // the uvx/npx wrapper tree and hung process exit).
-    _connectAbortGeneration++;
+    for (const scopeId of scopes) bumpConnectAbortGeneration(scopeId);
     for (const entry of [..._pendingConnects]) {
+        if (!scopes.has(entry.scopeId)) continue;
         _pendingConnects.delete(entry);
         // Mid-handshake child: nothing to shut down gracefully — hard-kill the
         // tree without holding the event loop (this path runs during process
@@ -466,13 +518,14 @@ export async function disconnectAll() {
         try { void entry.client.close().catch(() => { /* ignore */ }); }
         catch { /* ignore */ }
     }
-    for (const [name, server] of servers) {
+    for (const [registryKey, server] of [...servers]) {
+        if (!scopes.has(server.scopeId)) continue;
         try {
             await _closeServer(server);
         }
         catch { /* ignore */ }
-        servers.delete(name);
-        closeCallAdmission(name, `MCP ${name} disconnected`);
+        servers.delete(registryKey);
+        closeCallAdmission(server.scopeId, server.name, `MCP ${server.name} disconnected`);
     }
     _invalidateMcpToolFieldMemo();
 }
@@ -482,15 +535,17 @@ export async function disconnectAll() {
  * it, and invalidates the tool-field memo. Lets callers toggle one server
  * without a full disconnectAll()/reconnect cycle.
  */
-export async function disconnectMcpServer(name) {
-    const server = servers.get(name);
+export async function disconnectMcpServer(name, options = {}) {
+    const scopeId = normalizeMcpScopeId(options);
+    const registryKey = mcpServerRegistryKey(scopeId, name);
+    const server = servers.get(registryKey);
     if (!server) return false;
     try {
         await _closeServer(server);
     }
     catch { /* ignore */ }
-    servers.delete(name);
-    closeCallAdmission(name, `MCP ${name} disconnected`);
+    servers.delete(registryKey);
+    closeCallAdmission(scopeId, name, `MCP ${name} disconnected`);
     _invalidateMcpToolFieldMemo();
     return true;
 }
@@ -515,9 +570,9 @@ async function _closeServer(server) {
 // to see (and tear down) their transports, because `servers` only lists fully
 // handshaken entries. Generation token aborts a connect that outlives a
 // disconnectAll() issued mid-handshake (runtime close during boot connect).
-let _connectAbortGeneration = 0;
-const _pendingConnects = new Set();
-async function connectServer(name, cfg, genAtStart = _connectAbortGeneration) {
+async function connectServer(name, cfg, scopeId = DEFAULT_MCP_SCOPE_ID, genAtStart = currentConnectAbortGeneration(scopeId)) {
+    scopeId = normalizeMcpScopeId(scopeId);
+    _knownMcpScopes.add(scopeId);
     const {
         Client,
         StdioClientTransport,
@@ -525,7 +580,7 @@ async function connectServer(name, cfg, genAtStart = _connectAbortGeneration) {
         SSEClientTransport,
         WebSocketClientTransport,
     } = await loadMcpSdk();
-    if (genAtStart !== _connectAbortGeneration) {
+    if (genAtStart !== currentConnectAbortGeneration(scopeId)) {
         // disconnectAll() ran while the SDK was loading: nothing spawned yet —
         // abort before creating a transport/child at all.
         throw new Error(`MCP server "${name}" connect aborted by shutdown`);
@@ -623,7 +678,7 @@ async function connectServer(name, cfg, genAtStart = _connectAbortGeneration) {
     else {
         throw new Error(`Invalid config for "${name}": need autoDetect, type (stdio/http/sse/ws), url (http), or command (stdio)`);
     }
-    const pending = { name, client, transport };
+    const pending = { scopeId, name, client, transport };
     _pendingConnects.add(pending);
     try {
         // Bound the connect + listTools handshake so a slow/hung server can't
@@ -682,7 +737,7 @@ async function connectServer(name, cfg, genAtStart = _connectAbortGeneration) {
         if (!toolsResult || !Array.isArray(toolsResult.tools)) {
             throw new Error(`[mcp-client] ListTools returned invalid shape for "${name}": missing or non-array tools field`);
         }
-        if (genAtStart !== _connectAbortGeneration) {
+        if (genAtStart !== currentConnectAbortGeneration(scopeId)) {
             // disconnectAll() ran mid-handshake: never register — tear down.
             try { await _closeServer({ client, transport }); }
             catch { /* ignore */ }
@@ -695,7 +750,18 @@ async function connectServer(name, cfg, genAtStart = _connectAbortGeneration) {
             ...(t.annotations && typeof t.annotations === 'object' ? { annotations: t.annotations } : {}),
         }));
         const toolNames = tools.map(t => t.name);
-        servers.set(name, { name, client, transport, tools, cfg, instructions, generation: genAtStart });
+        const registryKey = mcpServerRegistryKey(scopeId, name);
+        servers.set(registryKey, {
+            scopeId,
+            registryKey,
+            name,
+            client,
+            transport,
+            tools,
+            cfg,
+            instructions,
+            generation: genAtStart,
+        });
         _invalidateMcpToolFieldMemo();
         mcpLog(`[mcp] connected: ${tools.length} tools — ${toolNames.join(', ')}\n`);
     }
@@ -703,3 +769,36 @@ async function connectServer(name, cfg, genAtStart = _connectAbortGeneration) {
         _pendingConnects.delete(pending);
     }
 }
+
+// Test seam for registry scoping without launching an MCP transport.
+export function _registerMcpServerForTest(scopeId, name, rawTools = [], options = {}) {
+    const normalizedScopeId = normalizeMcpScopeId(scopeId);
+    const registryKey = mcpServerRegistryKey(normalizedScopeId, name);
+    const tools = rawTools.map((tool) => ({
+        ...tool,
+        name: String(tool?.name || '').startsWith('mcp__')
+            ? String(tool.name)
+            : `mcp__${name}__${String(tool?.name || '')}`,
+        inputSchema: tool?.inputSchema || { type: 'object', properties: {} },
+    }));
+    const server = {
+        scopeId: normalizedScopeId,
+        registryKey,
+        name,
+        tools,
+        cfg: options.cfg || {},
+        instructions: options.instructions || '',
+        transport: null,
+        client: {
+            callTool: typeof options.callTool === 'function'
+                ? options.callTool
+                : async () => ({ content: [{ type: 'text', text: 'ok' }] }),
+            close: async () => {},
+        },
+        generation: currentConnectAbortGeneration(normalizedScopeId),
+    };
+    _knownMcpScopes.add(normalizedScopeId);
+    servers.set(registryKey, server);
+    _invalidateMcpToolFieldMemo();
+    return server;
+}

package/src/runtime/agent/orchestrator/providers/anthropic-effort.mjs

@@ -292,20 +292,13 @@ export function applyAnthropicEffortToBody(
         // Adaptive-thinking models (4.6+) require `thinking:{type:"adaptive"}`
         // rather than the legacy budget_tokens shape — sending
         // `thinking:{type:"enabled"}` here 400s on sonnet-5/opus-4-7/4-8.
-        // display:"summarized" keeps reasoning blocks populated (4.7+ defaults
-        // to "omitted", silently hiding reasoning text). Gated on the same
-        // modelSupportsEffort() allowlist so older models never receive it.
-        // Set unconditionally (independent of `normalized`) so effort-capable
-        // turns always carry adaptive thinking + round-trip signatures.
-        // MIXDOG_ANTHROPIC_THINKING_DISPLAY=omitted (operator/bench knob):
-        // thinking blocks are omitted entirely, so nothing is
-        // replayed into later requests (saves the 1h cache-write + re-read on
-        // accumulated thinking) at the cost of losing visible reasoning and
-        // cross-iteration thinking continuity. Default stays summarized.
-        const display = (process.env.MIXDOG_ANTHROPIC_THINKING_DISPLAY || '').trim() === 'omitted'
-            ? 'omitted'
-            : 'summarized';
-        body.thinking = { type: 'adaptive', display };
+        // Match Claude Code's default wire shape: omit `display` and let the
+        // model/API choose its default. Operators and benchmarks can explicitly
+        // request either supported display mode.
+        const display = (process.env.MIXDOG_ANTHROPIC_THINKING_DISPLAY || '').trim();
+        body.thinking = display === 'summarized' || display === 'omitted'
+            ? { type: 'adaptive', display }
+            : { type: 'adaptive' };
         // Adaptive/4.7+ models reject any non-default sampling param with a 400.
         delete body.temperature;
         delete body.top_p;

package/src/runtime/agent/orchestrator/session/loop/compact-policy.mjs

@@ -199,6 +199,22 @@ function compactPressureTokens(messageTokensEst, policy) {
     return Math.max(0, Math.round((messageTokensEst + requestReserve) * calibration) + otherReserve);
 }
 
+// Provider-visible context estimate without operator-only compaction reserve.
+// Request/schema reserve remains included because those bytes are sent to the
+// model; configured reserve is merely local headroom and must not inflate the
+// user-facing context gauge.
+function currentContextEstimateTokens(messageTokensEst, policy) {
+    if (messageTokensEst === null) return 0;
+    const calibration = Number(policy?.tokenCalibration) > 0 ? Number(policy.tokenCalibration) : 1;
+    const configured = Math.max(0, Number(policy?.configuredReserveTokens) || 0);
+    const totalReserve = Math.max(0, Number(policy?.reserveTokens) || 0);
+    const requestReserve = Math.min(
+        totalReserve,
+        Math.max(0, Number(policy?.requestReserveTokens ?? (totalReserve - configured)) || 0),
+    );
+    return Math.max(0, Math.round((messageTokensEst + requestReserve) * calibration));
+}
+
 function providerPressureTokens(sessionRef, usage) {
     if (!usage || typeof usage !== 'object') return 0;
     const input = Math.max(0, Number(usage.mainInputTokens ?? usage.inputTokens) || 0);
@@ -268,7 +284,9 @@ export function invalidateProviderContextBaseline(sessionRef) {
 // transcript did NOT grow keeps its baseline regardless of age.
 const BASELINE_MAX_STALE_GROWTH_MS = 30 * 60 * 1000;
 
-function providerBaselinePressureTokens(messages, sessionRef, policy) {
+function providerBaselinePressureTokens(messages, sessionRef, policy, {
+    includeConfiguredReserve = true,
+} = {}) {
     if (!Array.isArray(messages) || !sessionRef
         || sessionRef.lastContextTokensStaleAfterCompact === true) return null;
     let tokens = positiveTokenInt(sessionRef.contextPressureBaselineTokens);
@@ -303,16 +321,31 @@ function providerBaselinePressureTokens(messages, sessionRef, policy) {
         const growth = count < messages.length
             ? Math.round(estimateMessagesTokens(messages.slice(count)) * calibration)
             : 0;
-        return Math.max(0, tokens + growth + Math.max(0, Number(policy?.configuredReserveTokens) || 0));
+        const configuredReserve = includeConfiguredReserve
+            ? Math.max(0, Number(policy?.configuredReserveTokens) || 0)
+            : 0;
+        return Math.max(0, tokens + growth + configuredReserve);
     } catch {
         return null;
     }
 }
 
+function preferAlignedBaseline(baseline, estimate) {
+    if (baseline == null) return estimate;
+    if (Number.isFinite(estimate) && estimate > 0 && baseline * 2 < estimate) return estimate;
+    return baseline;
+}
+
+export function resolveCurrentContextTokens(messageTokensEst, policy, { messages, sessionRef } = {}) {
+    const baseline = providerBaselinePressureTokens(messages, sessionRef, policy, {
+        includeConfiguredReserve: false,
+    });
+    return preferAlignedBaseline(baseline, currentContextEstimateTokens(messageTokensEst, policy));
+}
+
 export function resolveCompactionPressureTokens(messageTokensEst, policy, { messages, sessionRef } = {}) {
     const baseline = providerBaselinePressureTokens(messages, sessionRef, policy);
     const estimate = compactPressureTokens(messageTokensEst, policy);
-    if (baseline == null) return estimate;
     // Sanity band: the baseline exists to correct OVER-counting estimates
     // (dense-data floors can inflate the estimate up to ~2x real usage), so a
     // lower baseline is normally preferred. But a corrupt/stale baseline below
@@ -322,8 +355,7 @@ export function resolveCompactionPressureTokens(messageTokensEst, policy, { mess
     // both the gauge and the compaction decision. Erring toward the estimate
     // may compact somewhat early; erring toward a rotten baseline blows past
     // the context window at full token cost.
-    if (Number.isFinite(estimate) && estimate > 0 && baseline * 2 < estimate) return estimate;
-    return baseline;
+    return preferAlignedBaseline(baseline, estimate);
 }
 
 /** Telemetry pressure when a reactive overflow retry forces the next compact. */

package/src/runtime/agent/orchestrator/session/loop/tool-exec.mjs

@@ -178,7 +178,8 @@ async function executeToolOwned(name, args, cwd, callerSessionId, sessionRef, ex
         return viewSkill(cwd, args?.name);
     }
     if (isMcpTool(name)) {
-        if (!isOnDeferredToolSurface(sessionRef, name) && !isRegisteredMcpTool(name)) {
+        const mcpScopeId = sessionRef?.mcpScopeId || null;
+        if (!isOnDeferredToolSurface(sessionRef, name) && !isRegisteredMcpTool(name, mcpScopeId)) {
             return formatUnknownBuiltinToolMessage(name, args, 'tool');
         }
         // 24h trace data shows ~24% of external MCP calls are cwd-sensitive
@@ -187,12 +188,13 @@ async function executeToolOwned(name, args, cwd, callerSessionId, sessionRef, ex
         // inputSchema declares the field — schemas without it would reject
         // an unknown argument.
         const needsCwdInjection = cwd
-            && mcpToolHasField(name, 'cwd')
+            && mcpToolHasField(name, 'cwd', mcpScopeId)
             && (args == null || args.cwd == null);
         const finalArgs = needsCwdInjection ? { ...(args || {}), cwd } : args;
         return executeMcpTool(name, finalArgs, {
             signal: executeOpts.signal || null,
             ownerKey: callerSessionId,
+            scopeId: mcpScopeId,
         });
     }
     if (name === 'code_graph') {

package/src/runtime/agent/orchestrator/session/manager/session-lifecycle.mjs

@@ -249,7 +249,10 @@ export function createSession(opts) {
     const toolSpec = ownerIsAgent
         ? (isReadOnlyAgentBundle ? 'readonly' : 'full')
         : (Array.isArray(profile?.tools) ? profile.tools : toolPreset);
-    let toolsForRouting = resolveSessionTools(toolSpec, skills, { ownerIsAgentSession: ownerIsAgent });
+    let toolsForRouting = resolveSessionTools(toolSpec, skills, {
+        ownerIsAgentSession: ownerIsAgent,
+        mcpScopeId: opts.mcpScopeId || null,
+    });
     // Fail-closed permission intersection: when a session declares an explicit
     // object-form permission, intersect the
     // resolved tool list with the permission's allow/deny lists. If the
@@ -371,6 +374,7 @@ export function createSession(opts) {
         agent: opts.agent,
         owner: opts.owner || 'user',
         mcpPid: process.pid,
+        mcpScopeId: opts.mcpScopeId || null,
         scopeKey: opts.scopeKey || null,
         lane: opts.lane || 'agent',
         cwd: opts.cwd,
@@ -530,7 +534,10 @@ function _prepareResumeTools(session, preset) {
             if (!ownerIsAgent && Array.isArray(profile?.tools)) toolSpec = profile.tools;
         } catch { /* ignore lookup failures, keep preset fallback */ }
     }
-    let toolsForRouting = resolveSessionTools(toolSpec, skills, { ownerIsAgentSession: ownerIsAgent });
+    let toolsForRouting = resolveSessionTools(toolSpec, skills, {
+        ownerIsAgentSession: ownerIsAgent,
+        mcpScopeId: session.mcpScopeId || null,
+    });
     if (ownerIsAgent) {
         toolsForRouting = applyToolPermissionNarrowing(toolsForRouting, session.toolPermission, session.agent || null);
     }
@@ -563,8 +570,10 @@ function _rememberPreparedResume(sessionId, prepared) {
 
 function _preparedResumeForSession(session, preset) {
     const cached = _preparedResumes.get(session.id);
-    if (cached?.session === session && cached?.preset === preset) return cached;
+    if (cached?.session === session && cached?.preset === preset
+        && cached?.mcpScopeId === (session.mcpScopeId || null)) return cached;
     const prepared = _prepareResumeTools(session, preset);
+    prepared.mcpScopeId = session.mcpScopeId || null;
     _rememberPreparedResume(session.id, prepared);
     return prepared;
 }
@@ -745,6 +754,9 @@ export async function resumeSession(sessionId, preset, options = {}) {
         session.desktopSession = expectedDesktop;
     }
     if (!session.owner) session.owner = 'user';
+    if (Object.prototype.hasOwnProperty.call(options, 'mcpScopeId')) {
+        session.mcpScopeId = String(options.mcpScopeId || '').trim() || null;
+    }
     if (_isActivelyOwnedElsewhere(session, sessionId)) {
         // ATTACH (viewer mode, zero ownership): hand back the live transcript
         // under the SAME id, flagged remoteAttached. No tool refresh, no save,
@@ -764,6 +776,7 @@ export async function resumeSession(sessionId, preset, options = {}) {
     const cached = _preparedResumes.get(sessionId);
     _preparedResumes.delete(sessionId);
     const prepared = cached?.session === session && cached?.preset === preset
+        && cached?.mcpScopeId === (session.mcpScopeId || null)
         ? cached
         : _prepareResumeTools(session, preset);
     // Keep the persisted tool mode in sync on resume (see createSession note).