mixdog 0.9.51 → 0.9.52

package/src/runtime/shared/resource-admission.mjs

@@ -0,0 +1,359 @@
+import { freemem, totalmem } from 'node:os';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+const MB = 1024 * 1024;
+
+export const RESOURCE_ADMISSION_DEFAULTS = Object.freeze({
+  maxAgents: 4,
+  maxShells: 4,
+  maxHighLoad: 6,
+  maxQueue: 32,
+  minFreeMemoryMb: 1024,
+  maxRssMb: 3072,
+});
+
+function positiveInt(value, fallback) {
+  const parsed = Math.floor(Number(value));
+  return Number.isFinite(parsed) && parsed >= 1 ? parsed : fallback;
+}
+
+function nonNegativeInt(value, fallback) {
+  const parsed = Math.floor(Number(value));
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+
+function envLimits(env = process.env) {
+  return {
+    maxAgents: positiveInt(env.MIXDOG_MAX_CONCURRENT_AGENTS, RESOURCE_ADMISSION_DEFAULTS.maxAgents),
+    maxShells: positiveInt(env.MIXDOG_MAX_CONCURRENT_SHELLS, RESOURCE_ADMISSION_DEFAULTS.maxShells),
+    maxHighLoad: positiveInt(env.MIXDOG_MAX_CONCURRENT_HIGH_LOAD, RESOURCE_ADMISSION_DEFAULTS.maxHighLoad),
+    maxQueue: nonNegativeInt(env.MIXDOG_RESOURCE_MAX_QUEUE, RESOURCE_ADMISSION_DEFAULTS.maxQueue),
+    minFreeMemoryMb: nonNegativeInt(env.MIXDOG_MIN_FREE_MEMORY_MB, RESOURCE_ADMISSION_DEFAULTS.minFreeMemoryMb),
+    maxRssMb: nonNegativeInt(env.MIXDOG_MAX_RSS_MB, RESOURCE_ADMISSION_DEFAULTS.maxRssMb),
+  };
+}
+
+function defaultMetrics() {
+  const usage = process.memoryUsage();
+  return {
+    rssBytes: usage.rss,
+    heapUsedBytes: usage.heapUsed,
+    freeMemoryBytes: freemem(),
+    totalMemoryBytes: totalmem(),
+  };
+}
+
+function abortError(signal) {
+  return signal?.reason instanceof Error
+    ? signal.reason
+    : new Error(String(signal?.reason || 'resource admission canceled'));
+}
+
+export class ResourcePressureError extends Error {
+  constructor(message, details = {}) {
+    super(`resource pressure: ${message}`);
+    this.name = 'ResourcePressureError';
+    this.code = 'ERESOURCEPRESSURE';
+    Object.assign(this, details);
+  }
+}
+
+export class ResourceAdmissionQueueFullError extends ResourcePressureError {
+  constructor(maxQueue) {
+    super(`high-load admission queue full (maximum ${maxQueue}); retry after running work completes`, {
+      maxQueue,
+    });
+    this.name = 'ResourceAdmissionQueueFullError';
+    this.code = 'ERESOURCEQUEUEFULL';
+  }
+}
+
+/**
+ * Process-wide admission for memory-heavy agent/explorer work and child shells.
+ * Running work is never revoked: pressure only rejects a new request or keeps a
+ * concurrency-blocked request in the bounded FIFO queue.
+ */
+export class ResourceAdmissionController {
+  constructor({
+    limits = {},
+    metrics = defaultMetrics,
+    now = Date.now,
+    env = process.env,
+  } = {}) {
+    this.limits = { ...envLimits(env), ...limits };
+    this.metrics = metrics;
+    this.now = now;
+    this.active = { agent: 0, shell: 0 };
+    this.queue = [];
+    this.context = new AsyncLocalStorage();
+  }
+
+  _memoryError(kind) {
+    let sample;
+    try { sample = this.metrics() || {}; }
+    catch (error) {
+      return new ResourcePressureError(`memory metrics unavailable; refusing new ${kind} work`, {
+        kind,
+        cause: error,
+      });
+    }
+    const rssMb = Number(sample.rssBytes) / MB;
+    const freeMb = Number(sample.freeMemoryBytes) / MB;
+    if (this.limits.maxRssMb > 0 && Number.isFinite(rssMb) && rssMb >= this.limits.maxRssMb) {
+      return new ResourcePressureError(
+        `Mixdog RSS ${Math.ceil(rssMb)} MB reached ${this.limits.maxRssMb} MB limit; retry after memory recovers`,
+        { kind, rssMb, limitMb: this.limits.maxRssMb, metric: 'rss' },
+      );
+    }
+    if (this.limits.minFreeMemoryMb > 0 && Number.isFinite(freeMb) && freeMb < this.limits.minFreeMemoryMb) {
+      return new ResourcePressureError(
+        `host free memory ${Math.floor(freeMb)} MB is below ${this.limits.minFreeMemoryMb} MB minimum; retry after memory recovers`,
+        { kind, freeMb, limitMb: this.limits.minFreeMemoryMb, metric: 'free-memory' },
+      );
+    }
+    return null;
+  }
+
+  _canStart(kind) {
+    const total = this.active.agent + this.active.shell;
+    const kindLimit = kind === 'shell' ? this.limits.maxShells : this.limits.maxAgents;
+    return total < this.limits.maxHighLoad && this.active[kind] < kindLimit;
+  }
+
+  _suspendParent(parent) {
+    if (!parent || parent.controller !== this || parent.released) return null;
+    parent.dependencyDepth += 1;
+    if (parent.counted) {
+      parent.counted = false;
+      this.active[parent.kind] = Math.max(0, this.active[parent.kind] - 1);
+    }
+    return parent;
+  }
+
+  _resumeParent(parent) {
+    if (!parent) return Promise.resolve();
+    parent.dependencyDepth = Math.max(0, parent.dependencyDepth - 1);
+    if (parent.dependencyDepth > 0 || parent.released || parent.counted) return Promise.resolve();
+    if (parent.restorePending) return parent.restorePending.promise;
+    const pending = Promise.withResolvers();
+    const item = {
+      restore: true,
+      kind: parent.kind,
+      label: `restore:${parent.label || parent.kind}`,
+      queuedAt: this.now(),
+      signal: parent.signal,
+      parent,
+      resolve: pending.resolve,
+      reject: pending.reject,
+      canceled: false,
+      onAbort: null,
+    };
+    parent.restorePending = { ...pending, item };
+    if (item.signal) {
+      item.onAbort = () => {
+        const index = this.queue.indexOf(item);
+        if (index >= 0) this.queue.splice(index, 1);
+        this._detach(item);
+        parent.restorePending = null;
+        item.reject(abortError(item.signal));
+        this._drain();
+      };
+      item.signal.addEventListener('abort', item.onAbort, { once: true });
+    }
+    this.queue.push(item);
+    this._drain();
+    return pending.promise;
+  }
+
+  _lease(kind, queuedAt = null, parent = null) {
+    this.active[kind] += 1;
+    const lease = {
+      controller: this,
+      kind,
+      label: null,
+      signal: null,
+      counted: true,
+      released: false,
+      dependencyDepth: 0,
+      restorePending: null,
+      parent,
+      releasePromise: null,
+      queuedMs: queuedAt == null ? 0 : Math.max(0, this.now() - queuedAt),
+      release: () => {
+        if (lease.released) return lease.releasePromise || Promise.resolve();
+        lease.released = true;
+        if (lease.restorePending) {
+          const item = lease.restorePending.item;
+          const index = this.queue.indexOf(item);
+          if (index >= 0) this.queue.splice(index, 1);
+          this._detach(item);
+          lease.restorePending = null;
+          item.resolve();
+        }
+        if (lease.counted) {
+          lease.counted = false;
+          this.active[kind] = Math.max(0, this.active[kind] - 1);
+        }
+        lease.releasePromise = this._resumeParent(lease.parent);
+        this._drain();
+        return lease.releasePromise;
+      },
+      detachDependency: () => {
+        if (!lease.parent) return Promise.resolve();
+        const dependencyParent = lease.parent;
+        lease.parent = null;
+        const restored = this._resumeParent(dependencyParent);
+        this._drain();
+        return restored;
+      },
+    };
+    return lease;
+  }
+
+  runWithLease(lease, task) {
+    if (!lease || lease.controller !== this || typeof task !== 'function') {
+      return Promise.resolve().then(task);
+    }
+    return this.context.run(lease, task);
+  }
+
+  acquire(kind, { signal = null, label = null, dependency = 'scoped' } = {}) {
+    const lane = kind === 'shell' ? 'shell' : 'agent';
+    if (signal?.aborted) return Promise.reject(abortError(signal));
+    const pressure = this._memoryError(lane);
+    if (pressure) return Promise.reject(pressure);
+    const ambientParent = this.context.getStore();
+    const detachedDependency = dependency === 'detached' && ambientParent?.controller === this;
+    const parent = detachedDependency ? null : this._suspendParent(ambientParent);
+    if (detachedDependency && (!this._canStart(lane) || this.queue.length > 0)) {
+      const error = new ResourcePressureError(
+        `detached nested ${lane} work has no admission capacity; retry after running work completes`,
+        { kind: lane },
+      );
+      error.code = 'ERESOURCEDEPENDENCY';
+      return Promise.reject(error);
+    }
+    if (this._canStart(lane) && this.queue.length === 0) {
+      const lease = this._lease(lane, null, parent);
+      lease.label = label;
+      lease.signal = signal;
+      return Promise.resolve(lease);
+    }
+    if (this.queue.length >= this.limits.maxQueue) {
+      const error = new ResourceAdmissionQueueFullError(this.limits.maxQueue);
+      return this._resumeParent(parent).then(
+        () => Promise.reject(error),
+        (restoreError) => Promise.reject(restoreError),
+      );
+    }
+    return new Promise((resolve, reject) => {
+      const item = {
+        kind: lane,
+        label,
+        queuedAt: this.now(),
+        signal,
+        resolve,
+        reject,
+        canceled: false,
+        onAbort: null,
+        parent,
+      };
+      if (signal) {
+        item.onAbort = () => {
+          if (item.canceled) return;
+          item.canceled = true;
+          const index = this.queue.indexOf(item);
+          if (index >= 0) this.queue.splice(index, 1);
+          this._detach(item);
+          const error = abortError(signal);
+          this._resumeParent(item.parent).then(
+            () => reject(error),
+            (restoreError) => reject(restoreError),
+          );
+          this._drain();
+        };
+        signal.addEventListener('abort', item.onAbort, { once: true });
+      }
+      this.queue.push(item);
+      this._drain();
+    });
+  }
+
+  _detach(item) {
+    if (item.onAbort && item.signal) {
+      try { item.signal.removeEventListener('abort', item.onAbort); } catch {}
+      item.onAbort = null;
+    }
+  }
+
+  _drain() {
+    for (let index = 0; index < this.queue.length;) {
+      const item = this.queue[index];
+      if (item.restore) {
+        if (item.parent.released) {
+          this.queue.splice(index, 1);
+          this._detach(item);
+          item.parent.restorePending = null;
+          item.resolve();
+          continue;
+        }
+        if (item.signal?.aborted) {
+          this.queue.splice(index, 1);
+          this._detach(item);
+          item.parent.restorePending = null;
+          item.reject(abortError(item.signal));
+          continue;
+        }
+        if (!this._canStart(item.kind)) {
+          index += 1;
+          continue;
+        }
+        this.queue.splice(index, 1);
+        this._detach(item);
+        item.parent.restorePending = null;
+        item.parent.counted = true;
+        this.active[item.kind] += 1;
+        item.resolve();
+        continue;
+      }
+      if (item.canceled || item.signal?.aborted) {
+        this.queue.splice(index, 1);
+        this._detach(item);
+        const error = abortError(item.signal);
+        this._resumeParent(item.parent).then(
+          () => item.reject(error),
+          (restoreError) => item.reject(restoreError),
+        );
+        continue;
+      }
+      if (!this._canStart(item.kind)) {
+        index += 1;
+        continue;
+      }
+      const pressure = this._memoryError(item.kind);
+      this.queue.splice(index, 1);
+      this._detach(item);
+      if (pressure) {
+        this._resumeParent(item.parent).then(
+          () => item.reject(pressure),
+          (restoreError) => item.reject(restoreError),
+        );
+        continue;
+      }
+      const lease = this._lease(item.kind, item.queuedAt, item.parent);
+      lease.label = item.label;
+      lease.signal = item.signal;
+      item.resolve(lease);
+    }
+  }
+
+  snapshot() {
+    return {
+      active: { ...this.active },
+      queued: this.queue.length,
+      limits: { ...this.limits },
+    };
+  }
+}
+
+export const resourceAdmission = new ResourceAdmissionController();

package/src/runtime/shared/staged-child-result.mjs

@@ -0,0 +1,19 @@
+'use strict';
+
+import { finishProcessLifecycle } from './process-lifecycle.mjs';
+
+const SIGNAL_EXIT_CODES = {
+  SIGHUP: 129,
+  SIGINT: 130,
+  SIGTERM: 143,
+};
+
+export function stagedChildExitCode(result) {
+  if (!result || result.error) return null;
+  if (result.signal) {
+    const exitCode = SIGNAL_EXIT_CODES[result.signal] || 1;
+    finishProcessLifecycle('forced-cleanup', exitCode);
+    return exitCode;
+  }
+  return Number.isInteger(result.status) ? result.status : 1;
+}

package/src/session-runtime/context-status.mjs

@@ -10,27 +10,29 @@ import {
   resolveCompactionPressureTokens,
   resolveWorkerCompactPolicy,
 } from '../runtime/agent/orchestrator/session/loop/compact-policy.mjs';
-import { estimateToolSchemaBreakdown } from './tool-catalog.mjs';
-
-const DEFERRED_CATALOG_TOOL_PROVIDERS = new Set(['anthropic', 'anthropic-oauth']);
+import {
+  estimateToolSchemaBreakdown,
+  snapshotProviderRequestTools,
+} from './tool-catalog.mjs';
+import { scopedProviderRequestTools } from './provider-request-tools.mjs';
 
 // Mirrors the tool-list portion of the Anthropic adapters without changing
 // their wire serialization. Other native-deferred providers expose the
 // catalog through BP1/system content, which is already metered there.
-export function requestSerializedToolsForContext(session, provider) {
-  const activeTools = Array.isArray(session?.tools) ? session.tools : [];
-  const normalizedProvider = String(provider || '').trim().toLowerCase();
-  if (!DEFERRED_CATALOG_TOOL_PROVIDERS.has(normalizedProvider)
-    || session?.deferredNativeTools !== true
-    || activeTools.length === 0) {
-    return activeTools;
-  }
-  const activeNames = new Set(activeTools.map((tool) => String(tool?.name || '').trim()).filter(Boolean));
-  const catalog = Array.isArray(session?.deferredToolCatalog) ? session.deferredToolCatalog : [];
-  const deferredTools = catalog
-    .filter((tool) => tool?.name && !activeNames.has(String(tool.name)))
-    .map((tool) => ({ ...tool, deferLoading: true }));
-  return deferredTools.length ? [...activeTools, ...deferredTools] : activeTools;
+export function requestSerializedToolsForContext(
+  session,
+  provider,
+  messages = session?.messages,
+  { nativeTools = [] } = {},
+) {
+  return scopedProviderRequestTools(session, provider, messages)?.requestTools
+    || snapshotProviderRequestTools({
+    provider,
+    tools: session?.tools,
+    nativeTools,
+    messages,
+    session,
+  });
 }
 
 // Live /context gauge computation + its self-owned memoization cache. Extracted
@@ -38,13 +40,18 @@ export function requestSerializedToolsForContext(session, provider) {
 // the mutable session/route/cwd/mode locals. The cache (key + value) is owned
 // here now, so invalidateContextStatusCache() is returned for the runtime to
 // call from the same places it used to clear the inline locals.
-export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMode }) {
+export function createContextStatus({
+  getSession,
+  getRoute,
+  getCurrentCwd,
+  getMode,
+  getNativeTools = () => [],
+}) {
   let contextStatusCacheKey = null;
   let contextStatusCacheValue = null;
 
   function contextStatusCacheKeyFor({
     messages,
-    tools,
     messagesRevision,
     toolsSignature,
     requestProvider,
@@ -68,8 +75,7 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
       lastMessage,
       lastMessageRole: lastMessage?.role || null,
       lastMessageContent: lastMessage?.content || null,
-      tools,
-      toolCount: tools.length,
+      toolCount: requestToolCount,
       toolsSignature,
       requestProvider,
       requestToolCount,
@@ -132,17 +138,20 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     // authoritative committed transcript.
     const liveTurnMessages = Array.isArray(session?.liveTurnMessages) ? session.liveTurnMessages : null;
     const messages = liveTurnMessages || (Array.isArray(session?.messages) ? session.messages : []);
-    const tools = Array.isArray(session?.tools) ? session.tools : [];
     const requestProvider = session?.provider || route.provider;
-    const requestTools = requestSerializedToolsForContext(session, requestProvider);
+    // Do not even evaluate live native definitions when an in-flight request
+    // scope owns the complete immutable provider surface.
+    const scopedRequest = scopedProviderRequestTools(session, requestProvider, messages);
+    const requestTools = scopedRequest?.requestTools
+      || requestSerializedToolsForContext(session, requestProvider, messages, {
+        nativeTools: getNativeTools(),
+      });
     const messagesRevision = contextMessagesRevision(messages);
-    const toolsSignature = toolSchemaSignature(tools);
     const requestToolsSignature = toolSchemaSignature(requestTools);
     const cacheKey = contextStatusCacheKeyFor({
       messages,
-      tools,
       messagesRevision,
-      toolsSignature,
+      toolsSignature: requestToolsSignature,
       requestProvider,
       requestToolCount: requestTools.length,
       requestToolsSignature,
@@ -171,7 +180,9 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     // Use the worker policy when a boundary is available so target/reserve
     // headroom, trigger, buffer tokens, and buffer ratio stay identical to the
     // auto-compact decision. Fall back only for incomplete session metadata.
-    const workerCompactPolicy = resolveWorkerCompactPolicy(session, tools);
+    // Meter the same pure provider-visible projection used by pre-send
+    // compaction and the actual agent-loop send/baseline fingerprint.
+    const workerCompactPolicy = resolveWorkerCompactPolicy(session, requestTools);
     const compactPolicy = workerCompactPolicy?.boundaryTokens
       ? workerCompactPolicy
       : resolveSessionCompactPolicy(session || {}, compactBoundaryTokens);

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

@@ -12,6 +12,20 @@ import {
 import { toolSpecForMode, deferredSurfaceModeForLead } from './effort.mjs';
 import { unregisterLiveSession } from '../runtime/shared/staged-update.mjs';
 
+export function resolveResumeCwd(session, currentCwd) {
+  const desktop = session?.desktopSession;
+  if (desktop?.classification === 'project') {
+    return clean(desktop.projectPath) || session?.cwd || currentCwd;
+  }
+  if (desktop?.classification === 'task') {
+    // Desktop task sessions deliberately stay in the app-managed unclassified
+    // workspace selected by the host, even if an old transcript recorded a
+    // transient cwd. CLI/TUI sessions have no metadata and retain old behavior.
+    return currentCwd;
+  }
+  return session?.cwd || currentCwd;
+}
+
 // Session lifecycle surface: teardown (close/abort), resume/new, and the
 // resumable-session listing. Extracted verbatim from the runtime API object;
 // stateless helpers are imported directly and the runtime injects live
@@ -30,7 +44,7 @@ export function createLifecycleApi(deps) {
     invalidateContextStatusCache, invalidatePreSessionToolSurface,
     applyResolvedCwd, resolveRoute, applyDeferredToolSurface, standaloneTools,
     pushTranscriptRebind,
-    notificationListeners, remoteStateListeners,
+    notificationListeners, remoteStateListeners, desktopSession,
   } = deps;
   return {
     async close(reason = 'cli-exit', options = {}) {
@@ -99,7 +113,7 @@ export function createLifecycleApi(deps) {
       try { agentTool.closeAll(reason); } catch {}
       let mcpStop = null;
       try { mcpStop = mcpClient.disconnectAll?.(); } catch {}
-      const openaiWsStop = globalThis.__mixdogOpenaiWsRuntimeLoaded === true
+      const openaiWsStop = isProcessExit && globalThis.__mixdogOpenaiWsRuntimeLoaded === true
         ? import('../runtime/agent/orchestrator/providers/openai-oauth-ws.mjs')
           .then((mod) => mod?.drainOpenaiWsPool?.(reason))
           .catch(() => {})
@@ -174,8 +188,10 @@ export function createLifecycleApi(deps) {
       if (!session?.id) return false;
       return mgr.abortSessionTurn(session.id, reason);
     },
-    listSessions() {
-      return mgr.listSessions({}).map(s => {
+    listSessions(options = {}) {
+      return mgr.listSessions({
+        refreshFromStorage: options?.refreshFromStorage === true,
+      }).map(s => {
         const owner = clean(s.owner || 'user').toLowerCase();
         if (owner && !['cli', 'user', 'mixdog', 'legacy'].includes(owner)) return null;
         const sourceType = clean(s.sourceType || '').toLowerCase();
@@ -206,6 +222,7 @@ export function createLifecycleApi(deps) {
           provider: s.provider,
           messageCount,
           preview,
+          desktopSession: s.desktopSession || null,
         };
       }).filter(Boolean);
     },
@@ -230,7 +247,10 @@ export function createLifecycleApi(deps) {
       const previousId = prev?.id || null;
       const previousMessages = prev?.messages || null;
       const previousLive = prev?.liveTurnMessages || null;
-      const resumed = await mgr.resumeSession(id, toolSpecForMode(getMode()));
+      const resumeOptions = desktopSession && typeof desktopSession === 'object'
+        ? { desktopSession }
+        : undefined;
+      const resumed = await mgr.resumeSession(id, toolSpecForMode(getMode()), resumeOptions);
       if (!resumed) return null;
       if (previousId && previousId !== resumed.id) {
         statusRoutes?.clearGatewaySessionRoute?.(previousId);
@@ -239,7 +259,7 @@ export function createLifecycleApi(deps) {
         mgr.closeSession(previousId, 'cli-resume', { tombstone });
       }
       setSession(resumed);
-      applyResolvedCwd(resumed.cwd || getCurrentCwd(), { markRefresh: false });
+      applyResolvedCwd(resolveResumeCwd(resumed, getCurrentCwd()), { markRefresh: false });
       const route = getRoute();
       const resumeEffort = hasOwn(route, 'effort') ? route.effort : resumed.effort;
       setRoute(resolveRoute(getConfig(), { provider: resumed.provider, model: resumed.model, effort: resumeEffort }));

package/src/session-runtime/provider-request-tools.mjs

@@ -0,0 +1,72 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+const requestToolScope = new AsyncLocalStorage();
+const NATIVE_PREFIX_COUNT = Symbol('mixdog.providerNativeToolPrefixCount');
+let requestToolScopeGeneration = 0;
+
+function normalizedProvider(provider) {
+  return String(provider || '').trim().toLowerCase();
+}
+
+export function providerNativeToolPrefixCount(requestTools, fallback = 0) {
+  const raw = Array.isArray(requestTools) && Number.isInteger(requestTools[NATIVE_PREFIX_COUNT])
+    ? requestTools[NATIVE_PREFIX_COUNT]
+    : fallback;
+  return Math.max(0, Math.min(Array.isArray(requestTools) ? requestTools.length : 0, Number(raw) || 0));
+}
+
+export function finalizeProviderRequestTools(requestTools, nativePrefixCount = 0) {
+  Object.defineProperty(requestTools, NATIVE_PREFIX_COUNT, {
+    value: Math.max(0, Math.min(requestTools.length, Number(nativePrefixCount) || 0)),
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  });
+  return Object.freeze(requestTools);
+}
+
+export function runWithProviderRequestToolsScope(scope, callback) {
+  const store = {
+    session: scope.session,
+    provider: normalizedProvider(scope.provider),
+    messages: scope.messages,
+    requestTools: scope.requestTools,
+    nativePrefixCount: providerNativeToolPrefixCount(
+      scope.requestTools,
+      scope.nativePrefixCount,
+    ),
+    generation: ++requestToolScopeGeneration,
+    active: true,
+  };
+  return requestToolScope.run(store, () => {
+    let result;
+    try {
+      result = callback();
+    } catch (error) {
+      store.active = false;
+      throw error;
+    }
+    if (result && typeof result.then === 'function') {
+      return Promise.resolve(result).finally(() => {
+        store.active = false;
+      });
+    }
+    store.active = false;
+    return result;
+  });
+}
+
+export function invalidateProviderRequestToolsScope(scope = requestToolScope.getStore()) {
+  if (scope && typeof scope === 'object') scope.active = false;
+}
+
+export function scopedProviderRequestTools(session, provider, messages) {
+  const scope = requestToolScope.getStore();
+  return scope
+    && scope.active === true
+    && scope.session === session
+    && scope.provider === normalizedProvider(provider)
+    && scope.messages === messages
+    ? scope
+    : null;
+}

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

@@ -363,6 +363,7 @@ export async function createMixdogSessionRuntime({
   cwd = process.cwd(),
   toolMode = 'full',
   remote = false,
+  desktopSession = null,
 } = {}) {
   bootProfile('session-runtime:start', { provider, model, toolMode, cwd });
   let remoteEnabled = remote === true;
@@ -1555,6 +1556,7 @@ export async function createMixdogSessionRuntime({
         clientHostPid: process.pid,
         disallowedTools: LEAD_DISALLOWED_TOOLS,
         cwd: currentCwd,
+        ...(desktopSession && typeof desktopSession === 'object' ? { desktopSession } : {}),
         coreMemoryContext,
         workflow,
         workflowContext,
@@ -1569,11 +1571,11 @@ export async function createMixdogSessionRuntime({
       session = mgr.createSession(sessionOpts);
       sessionNeedsCwdRefresh = false;
       attachSessionHooks(session, { hooks, hookCommonPayload, getCwd: () => currentCwd });
-      // Every-create MCP fold (NO blocking): seed the INITIAL deferred surface +
-      // BP1 manifest from whatever MCP servers are ALREADY connected at create
+      // Every-create MCP fold (NO blocking): seed the INITIAL provider-visible
+      // surface (and native BP1 manifest) from MCP servers connected at create
       // time. There is no await — a boot connect still mid-handshake is caught on
       // the first user turn by refreshInitialDeferredMcpSurface (session-turn-api),
-      // which re-folds the live registry into the initial manifest before the
+      // which re-folds the live registry into the first-turn surface before the
       // prompt renders. This fold keeps recreate paths (cwd change with MCP
       // already connected) seeding their manifest instead of re-announcing late.
       let connectedMcpTools = [];
@@ -2155,6 +2157,7 @@ export async function createMixdogSessionRuntime({
     resolveRoute,
     applyDeferredToolSurface,
     standaloneTools,
+    desktopSession,
   });
   const resourceApi = createResourceApi({
     getConfig: () => config,