mixdog 1.2.0 → 1.2.1

package/src/runtime/agent/orchestrator/providers/model-proxy-channel.d.mts

@@ -50,6 +50,7 @@ export class ModelProxyChannel {
   attachPublisher(publish: (snapshot: ModelProxySnapshot) => void): () => void;
   disconnect(reason?: string): void;
   setClientPresent(present: boolean): void;
+  onStateChange(listener: () => void): () => void;
   request(
     call: Record<string, unknown>,
     options?: { signal?: AbortSignal | null; callbacks?: Record<string, (...args: unknown[]) => unknown> }
@@ -65,3 +66,17 @@ export class ModelProxyChannel {
 }
 
 export function getModelProxyChannel(): ModelProxyChannel;
+
+/** The channel surface model-proxy providers use; the bridge child implements only this. */
+export interface ModelProxyChannelLike {
+  readonly connected: boolean;
+  readonly generation: number;
+  whenConnected(timeoutMs: number): Promise<boolean>;
+  request(
+    call: Record<string, unknown>,
+    options?: { signal?: AbortSignal | null; callbacks?: Record<string, (...args: unknown[]) => unknown> }
+  ): Promise<unknown>;
+}
+
+/** Swap the process-wide channel; the returned function restores the previous one. */
+export function installModelProxyChannel(channel: ModelProxyChannel | ModelProxyChannelLike): () => void;

package/src/runtime/agent/orchestrator/providers/model-proxy-channel.mjs

@@ -243,8 +243,24 @@ export class ModelProxyChannel {
     });
   }
 
+  #stateListeners = new Set();
+
+  /** `listener()` runs after every presence/generation change (the model
+   *  proxy bridge pushes it to its clients). Returns the unsubscribe. */
+  onStateChange(listener) {
+    this.#stateListeners.add(listener);
+    return () => this.#stateListeners.delete(listener);
+  }
+
   #connectionChanged() {
     this.#generation += 1;
+    for (const listener of [...this.#stateListeners]) {
+      try {
+        listener();
+      } catch {
+        /* a listener never breaks the transport that reported the change */
+      }
+    }
     if (!this.connected) return;
     for (const waiter of [...this.#connectionWaiters]) waiter(true);
   }
@@ -519,3 +535,22 @@ export function getModelProxyChannel() {
   globalThis[CHANNEL_KEY] ??= new ModelProxyChannel();
   return globalThis[CHANNEL_KEY];
 }
+
+/**
+ * Make `channel` the process-wide channel (a headless child talks through the
+ * daemon's model proxy bridge instead). The returned restore puts the previous
+ * channel back once, unless another install replaced this one since.
+ */
+export function installModelProxyChannel(channel) {
+  const hadPrevious = Object.hasOwn(globalThis, CHANNEL_KEY);
+  const previous = globalThis[CHANNEL_KEY];
+  globalThis[CHANNEL_KEY] = channel;
+  let restored = false;
+  return () => {
+    if (restored) return;
+    restored = true;
+    if (globalThis[CHANNEL_KEY] !== channel) return;
+    if (hadPrevious) globalThis[CHANNEL_KEY] = previous;
+    else delete globalThis[CHANNEL_KEY];
+  };
+}

package/src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs

@@ -181,6 +181,17 @@ function mimoOAuthState() {
   );
 }
 
+function commandCodeOAuthState() {
+  const paths = [
+    boundProviderAuthPath('command-code-oauth') ||
+      process.env.COMMAND_CODE_OAUTH_CREDENTIALS_PATH ||
+      join(resolvePluginData(), 'command-code-oauth.json'),
+  ];
+  return memoProbe('command-code-oauth', paths, () =>
+    resolveProbeState(paths, (docs) => docs.some((own) => typeof own?.apiKey === 'string' && !!own.apiKey.trim()))
+  );
+}
+
 function museCodeOAuthState() {
   const paths = [
     boundProviderAuthPath('muse-code-oauth') ||
@@ -255,6 +266,7 @@ const OAUTH_PROBE_STATES = new Map([
   ['openai-oauth', openAIOAuthState],
   ['grok-oauth', grokOAuthState],
   ['muse-code-oauth', museCodeOAuthState],
+  ['command-code-oauth', commandCodeOAuthState],
   ['mimo-oauth', mimoOAuthState],
   ['cursor-oauth', cursorOAuthState],
   ['antigravity-oauth', antigravityOAuthState],

package/src/runtime/agent/orchestrator/providers/oauth-usage.mjs

@@ -868,7 +868,8 @@ async function measureUsage(provider, providerObj, routeInfo) {
     (provider === 'cursor-oauth' ||
       provider === 'cursor-api' ||
       provider === 'antigravity-oauth' ||
-      provider === 'muse-code-oauth') &&
+      provider === 'muse-code-oauth' ||
+      provider === 'command-code-oauth') &&
     typeof providerObj?.getUsageSnapshot === 'function'
   ) {
     return await providerObj.getUsageSnapshot();
@@ -893,12 +894,12 @@ async function measureUsageWithAuthRetry(provider, providerObj, routeInfo) {
 // refresh cannot vouch for the reading it last produced: keeping a 100% meter
 // earned by a dead token would hold the account out of the roster until its
 // reset time, so the recorded quota goes with the credential.
-function usageAfterFailure(err, provider, accountId, log) {
+async function usageAfterFailure(err, provider, accountId, log) {
   const snapshot = provider === 'anthropic-oauth' && accountId === 'default' ? latestClaudeStatuslineUsage() : null;
   if (snapshot) return snapshot;
   if (isUsageAuthRejection(err) && ACCOUNT_PROVIDERS.includes(provider)) {
     try {
-      clearProviderAccountQuotaState(provider, accountId);
+      await clearProviderAccountQuotaState(provider, accountId);
     } catch (error) {
       log(`Account usage could not be cleared: ${error.message}`);
     }
@@ -952,7 +953,7 @@ export async function fetchOAuthUsageSnapshot(routeInfo, providerObj, log = () =
     try {
       snapshot = await measureUsageWithAuthRetry(provider, providerObj, routeInfo);
     } catch (err) {
-      snapshot = usageAfterFailure(err, provider, accountId, log);
+      snapshot = await usageAfterFailure(err, provider, accountId, log);
     }
     if (!isContentfulSnapshot(snapshot)) {
       cacheNegative(key, 'empty');
@@ -961,7 +962,7 @@ export async function fetchOAuthUsageSnapshot(routeInfo, providerObj, log = () =
     }
     if (ACCOUNT_PROVIDERS.includes(provider)) {
       try {
-        recordProviderAccountUsage(provider, accountId, snapshot);
+        await recordProviderAccountUsage(provider, accountId, snapshot);
       } catch (error) {
         log(`Account usage could not be saved: ${error.message}`);
       }

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-send.mjs

@@ -38,7 +38,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
   // global catalog must not shape a user-defined endpoint's request.
   let modelInfo = null;
   if (isCustom) modelInfo = provider.getCachedModelInfo(useModel) || null;
-  else if (provider.name === 'opencode-go')
+  else if (provider.name === 'opencode-go' || provider.name === 'command-code-oauth')
     modelInfo = provider.getCachedModelInfo(useModel) || getModelMetadataSync(useModel, provider.name);
   else if (profile?.resolveModelInfo) modelInfo = profile.resolveModelInfo(provider, useModel) || null;
   // Resolved before lowering: replay eligibility depends on the snapped level

package/src/runtime/agent/orchestrator/providers/openai-compat-models.mjs

@@ -1,3 +1,4 @@
+import { resolveProviderApiKey } from '../../../shared/provider-api-key.mjs';
 import { enrichModels } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { PROVIDER_GENERATE_TOTAL_TIMEOUT_MS, createTimeoutSignal, resolveTimeoutMs } from '../stall-policy.mjs';
@@ -10,12 +11,15 @@ const MODEL_LIST_TIMEOUT_MS = resolveTimeoutMs('MIXDOG_COMPAT_MODEL_LIST_TIMEOUT
 // `keyless` omits the Authorization header entirely (keyless endpoints);
 // `signal` aborts the request together with the list timeout.
 export async function fetchCompatModelItems(provider, { signal = null, keyless = false } = {}) {
-  const timeout = createTimeoutSignal(signal, MODEL_LIST_TIMEOUT_MS, `${provider.name} model list`);
+  const name = provider.name;
+  const timeout = createTimeoutSignal(signal, MODEL_LIST_TIMEOUT_MS, `${name} model list`);
   try {
     const res = await fetch(`${String(provider.baseURL || '').replace(/\/+$/, '')}/models`, {
       method: 'GET',
       headers: {
-        ...(keyless ? {} : { Authorization: `Bearer ${provider.apiKey || 'no-key'}` }),
+        ...(keyless
+          ? {}
+          : { Authorization: `Bearer ${resolveProviderApiKey(name, provider.config || provider) || 'no-key'}` }),
         ...(provider.defaultHeaders || {}),
       },
       signal: timeout.signal,

package/src/runtime/agent/orchestrator/providers/openai-compat-options.mjs

@@ -74,6 +74,17 @@ export function applyCompatProviderChatOptions(params, providerName, opts = {},
     }
     return params;
   }
+  if (providerName === 'command-code-oauth') {
+    // The API's field is undocumented; mirror the common `reasoning_effort`
+    // (levels the catalog row declares, else low/medium/high).
+    const rawEffort = opts.effort ?? config?.reasoningEffort;
+    const declared = modelInfo?.reasoningOptions?.some((option) => option?.type === 'effort');
+    const effort = declared
+      ? normalizeOpencodeGoReasoningEffort(rawEffort, modelInfo)
+      : normalizeReasoningEffort(rawEffort, ['low', 'medium', 'high']);
+    if (effort) params.reasoning_effort = effort;
+    return params;
+  }
   if (providerName === 'opencode-go') {
     const reasoningEffort = normalizeOpencodeGoReasoningEffort(opts.effort ?? config?.reasoningEffort, modelInfo);
     // OpenCode Go's OpenAI-compatible contract exposes reasoning_effort,

package/src/runtime/agent/orchestrator/providers/openai-compat-xai-send.mjs

@@ -1,3 +1,4 @@
+import { resolveProviderApiKey } from '../../../shared/provider-api-key.mjs';
 import { markProviderRecoveryExhausted, withRetry } from './retry-classifier.mjs';
 import { consumeCompatResponsesStream } from './openai-compat-stream.mjs';
 import { PROVIDER_FIRST_BYTE_TIMEOUT_MS, createPassthroughSignal } from '../stall-policy.mjs';
@@ -158,7 +159,7 @@ export async function sendXaiResponsesWebSocket(provider, messages, useModel, to
     const reason = signal.reason;
     throw reason instanceof Error ? reason : new Error('xAI Responses WebSocket request aborted by session close');
   }
-  const apiKey = provider.config?.apiKey || process.env.XAI_API_KEY;
+  const apiKey = resolveProviderApiKey('xai', provider.config);
   if (!apiKey) throw new Error('xAI API key not configured');
   messages = await preparePdfTextForProvider(messages, provider);
   const chatMessagesForTrace = toOpenAIMessages(messages, provider.name, { nativePdf: provider.nativePdf });

package/src/runtime/agent/orchestrator/providers/openai-compat.mjs

@@ -1,6 +1,6 @@
 import { createRequire } from 'node:module';
 import { noteErrorUsage } from './lib/note-error-usage.mjs';
-import { getAgentApiKey } from '../../../shared/provider-api-key.mjs';
+import { reloadProviderApiKey, resolveProviderApiKey } from '../../../shared/provider-api-key.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { appendAgentTrace } from '../agent-trace.mjs';
 import { OPENAI_COMPAT_PRESETS } from './openai-compat-presets.mjs';
@@ -69,7 +69,7 @@ export class OpenAICompatProvider {
   constructor(name, config) {
     const preset = PRESETS[name];
     const baseURL = assertSafeBaseURL(config.baseURL || preset?.baseURL || 'http://localhost:8080/v1', name);
-    const apiKey = config.apiKey || 'no-key';
+    const apiKey = resolveProviderApiKey(name, config) || 'no-key';
     this.name = name;
     this.config = config;
     this.baseURL = baseURL;
@@ -121,7 +121,7 @@ export class OpenAICompatProvider {
   reloadApiKey() {
     try {
       const preset = PRESETS[this.name];
-      const newKey = getAgentApiKey(this.name) || this.config.apiKey;
+      const newKey = reloadProviderApiKey(this.name, this.config);
       const baseURL = assertSafeBaseURL(
         this.config.baseURL || preset?.baseURL || 'http://localhost:8080/v1',
         this.name
@@ -138,6 +138,12 @@ export class OpenAICompatProvider {
     }
   }
   async send(messages, model, tools, sendOpts) {
+    // A keyless-constructed instance picks up the key once it is available.
+    const resolvedKey = resolveProviderApiKey(this.name, this.config) || 'no-key';
+    if (resolvedKey !== this.apiKey) {
+      this.apiKey = resolvedKey;
+      this.client = this._createClient(resolvedKey);
+    }
     try {
       return await this._doSend(messages, model, tools, sendOpts);
     } catch (err) {

package/src/runtime/agent/orchestrator/providers/openai-ws.mjs

@@ -23,7 +23,7 @@ import { resolveOpenAiTransportPolicy } from './openai-transport-policy.mjs';
 import { applyOpenAIDirectCachePolicy } from './openai-direct-request.mjs';
 import { streamCallbacks } from './lib/send-callbacks.mjs';
 import { noteErrorUsage } from './lib/note-error-usage.mjs';
-import { getAgentApiKey } from '../../../shared/provider-api-key.mjs';
+import { reloadProviderApiKey, resolveProviderApiKey } from '../../../shared/provider-api-key.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { noteRequestServiceTier } from '../../../shared/llm/usage-context.mjs';
 import { resolveProviderCacheKey, resolveProviderPromptCacheLane } from '../agent-runtime/cache-strategy.mjs';
@@ -86,7 +86,7 @@ export class OpenAIDirectProvider {
     this.config = config || {};
   }
   _ensureKey() {
-    const k = this.config.apiKey;
+    const k = resolveProviderApiKey('openai', this.config);
     if (!k) throw new Error('OPENAI_API_KEY not configured (providers.openai.apiKey)');
     return k;
   }
@@ -97,7 +97,7 @@ export class OpenAIDirectProvider {
   // the WS/HTTP transports take the key per-call via the `auth` object.
   reloadApiKey() {
     try {
-      const newKey = getAgentApiKey('openai') || this.config.apiKey;
+      const newKey = reloadProviderApiKey('openai', this.config);
       if (newKey) {
         this.config = { ...(this.config || {}), apiKey: newKey };
         return newKey;
@@ -295,6 +295,6 @@ export class OpenAIDirectProvider {
     }
   }
   async isAvailable() {
-    return !!this.config.apiKey;
+    return !!resolveProviderApiKey('openai', this.config);
   }
 }

package/src/runtime/agent/orchestrator/providers/registry.mjs

@@ -7,6 +7,7 @@ import { isInclusiveProvider } from '../../../shared/llm/cost.mjs';
 import { noEnabledProvidersError } from './registry-errors.mjs';
 import { providerTakesNativePdf } from '../../../attachments/store.mjs';
 import { modelProxyClientMode } from '../../../shared/model-proxy-mode.mjs';
+import { getModelProxyChannel } from './model-proxy-channel.mjs';
 // OpenAI-compat provider names are self-declared by openai-compat-presets.mjs via
 // OPENAI_COMPAT_PRESETS. No parallel list maintained here.
 const providers = new Map();
@@ -28,6 +29,7 @@ const OAUTH_PROVIDER_NAMES = new Set([
   'openai-oauth',
   'grok-oauth',
   'muse-code-oauth',
+  'command-code-oauth',
   'mimo-oauth',
   'cursor-oauth',
   'antigravity-oauth',
@@ -96,6 +98,28 @@ function configSignature(cfg) {
   }
 }
 
+// Remote mode: a proxy provider sends through the channel it was built on. A
+// headless boundary installs a fresh channel per run (model-proxy-bridge.mjs)
+// and closes it afterwards, so the channel's identity is part of every reuse
+// signature — an identical PC config behind a new channel is a rebuild, never
+// a provider bound to a closed channel. Local mode: '' (signatures unchanged).
+const _proxyChannelIds = new WeakMap();
+let _proxyChannelSeq = 0;
+function proxyChannelTag(channel) {
+  if (!channel) return '';
+  let id = _proxyChannelIds.get(channel);
+  if (!id) {
+    _proxyChannelSeq += 1;
+    id = _proxyChannelSeq;
+    _proxyChannelIds.set(channel, id);
+  }
+  return `\u0000model-proxy-channel:${id}`;
+}
+function reuseSignature(cfg, proxyChannel) {
+  const sig = configSignature(cfg);
+  return sig === null ? null : sig + proxyChannelTag(proxyChannel);
+}
+
 function abortError(signal) {
   return signal?.reason instanceof Error
     ? signal.reason
@@ -147,6 +171,7 @@ const PROVIDER_MODULES = {
   'anthropic-oauth': ['./anthropic-oauth.mjs', 'AnthropicOAuthProvider'],
   'grok-oauth': ['./grok-oauth.mjs', 'GrokOAuthProvider'],
   'muse-code-oauth': ['./muse-code-oauth.mjs', 'MuseCodeOAuthProvider'],
+  'command-code-oauth': ['./command-code-oauth.mjs', 'CommandCodeOAuthProvider'],
   'mimo-oauth': ['./mimo-oauth.mjs', 'MimoOAuthProvider'],
   'cursor-oauth': ['./cursor.mjs', 'CursorOAuthProvider'],
   'antigravity-oauth': ['./antigravity-oauth.mjs', 'AntigravityOAuthProvider'],
@@ -176,12 +201,12 @@ async function loadProviderCtor(name, signal = null, cfg = null) {
   throw new Error(`unknown enabled provider: ${name}`);
 }
 
-async function instantiateProvider(name, Ctor, cfg) {
+async function instantiateProvider(name, Ctor, cfg, proxyChannel = null) {
   // Remote mode: the client PC executes the call with its own credentials.
   // Admission and usage accounting still wrap the daemon-side stand-in.
   if (modelProxyClientMode()) {
     const { createModelProxyProvider } = await import('./model-proxy-provider.mjs');
-    return wrapProviderAdmission(createModelProxyProvider(name, cfg), name);
+    return wrapProviderAdmission(createModelProxyProvider(name, cfg, proxyChannel ?? getModelProxyChannel()), name);
   }
   if (isCustomProviderConfig(name, cfg)) return wrapProviderAdmission(await Ctor(name, cfg), name);
   if (Object.hasOwn(OPENAI_COMPAT_PRESETS, name) && name !== 'opencode-go') {
@@ -194,11 +219,12 @@ export async function initProviders(config, { signal = null } = {}) {
   throwIfAborted(signal);
   // Remote mode: provider availability and config are the PC's, never this
   // server's credential probes. No connected client fails here, clearly.
-  if (modelProxyClientMode()) {
+  const proxyChannel = modelProxyClientMode() ? getModelProxyChannel() : null;
+  if (proxyChannel) {
     const { loadModelProxyProviderConfig } = await import('./model-proxy-provider.mjs');
-    config = await awaitWithAbort(loadModelProxyProviderConfig(), signal);
+    config = await awaitWithAbort(loadModelProxyProviderConfig({ channel: proxyChannel }), signal);
   }
-  const sig = configSignature(config);
+  const sig = reuseSignature(config, proxyChannel);
   // Coalesce: an identical config is already mid-init — attach to it.
   if (sig !== null && _inFlightPromise && _inFlightSig === sig) {
     return awaitWithAbort(_inFlightPromise, signal);
@@ -212,7 +238,7 @@ export async function initProviders(config, { signal = null } = {}) {
   // signatures can never run their clear()+rebuild concurrently, regardless
   // of caller-side gating (agent-tool gateOnPrior may release a queued init
   // before the prior one settled). Errors do not poison the chain.
-  const run = () => _initProvidersUnsynchronized(config, signal);
+  const run = () => _initProvidersUnsynchronized(config, signal, proxyChannel);
   const next = _initChain.then(run, run);
   _initChain = next.then(
     () => {},
@@ -241,7 +267,7 @@ export async function initProviders(config, { signal = null } = {}) {
   return awaitWithAbort(tracked, signal);
 }
 
-async function _initProvidersUnsynchronized(config, signal = null) {
+async function _initProvidersUnsynchronized(config, signal = null, proxyChannel = null) {
   throwIfAborted(signal);
   // Invariant: never wipe the live registry based on an empty / all-disabled
   // config. Without this guard, a stale `loadAgentConfig()` (e.g. mid-reload
@@ -262,7 +288,7 @@ async function _initProvidersUnsynchronized(config, signal = null) {
       // Idempotent reuse: an enabled provider whose config signature is
       // unchanged from the live registry is carried forward as-is. Only
       // added or changed providers are (re)constructed below.
-      const sig = configSignature(cfg);
+      const sig = reuseSignature(cfg, proxyChannel);
       if (sig !== null && providers.has(name) && signatures.get(name) === sig) {
         return { name, inst: providers.get(name), sig };
       }
@@ -270,7 +296,7 @@ async function _initProvidersUnsynchronized(config, signal = null) {
         // A proxied provider never loads the real adapter module.
         const Ctor = modelProxyClientMode() ? null : await loadProviderCtor(name, signal, cfg);
         throwIfAborted(signal);
-        const inst = await instantiateProvider(name, Ctor, cfg);
+        const inst = await instantiateProvider(name, Ctor, cfg, proxyChannel);
         return { name, inst, sig };
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);

package/src/runtime/agent/orchestrator/runtime-core/effort.mjs

@@ -25,6 +25,9 @@ const EFFORT_OPTIONS_BY_PROVIDER = {
   // xAI Grok 4.6+: low/medium/high/xhigh. Reasoning cannot be disabled.
   xai: ['low', 'medium', 'high', 'xhigh'],
   'mimo-oauth': ['minimal', 'low', 'medium', 'high'],
+  // Command Code relays several vendors over Chat Completions; the common
+  // `reasoning_effort` levels are the fallback when no catalog row declares any.
+  'command-code-oauth': ['low', 'medium', 'high'],
 };
 const EFFORT_BY_FAMILY = {
   opus: ['low', 'medium', 'high', 'xhigh', 'max'],

package/src/runtime/agent/orchestrator/runtime-core/extension-scopes.mjs

@@ -1,11 +1,8 @@
 // extension-scopes.mjs — plugin-aware layer over the shared scope model. A
 // plugin's scope cascades to the skills it owns and to the MCP server(s) it
-// installed, so limiting the plugin limits everything it brought along.
-import { readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-
-import { pluginMcpServerName, pluginServerMatcher } from './plugin-mcp.mjs';
-import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
+// declares, so limiting the plugin limits everything it brought along. MCP
+// ownership comes from the tool's `mcpPluginId`, set when the plugin's server
+// connected, never from the server name.
 import { loadConfig } from '../config.mjs';
 import {
   extensionAllowedForCwd,
@@ -28,66 +25,29 @@ export {
   withExtensionScope,
 } from '../../../shared/extension-scopes.mjs';
 
-/** Plugin id that installed MCP server `serverName`, or ''. Plugin servers are
- *  named `plugin-<name>` or `plugin-<name>--<suffix>` (plugin-mcp.mjs). */
-export function pluginIdForMcpServer(serverName, plugins) {
-  const name = clean(serverName);
-  if (!name) return '';
-  for (const plugin of Array.isArray(plugins) ? plugins : []) {
-    if (pluginServerMatcher(pluginMcpServerName(plugin))(name)) return clean(plugin?.id || plugin?.name);
-  }
-  return '';
-}
-
-export function mcpServerAllowedForCwd(scopes, serverName, cwd, { plugins = [] } = {}) {
+/** Server scope ∩ owning plugin's scope (`pluginId` from owner metadata). */
+export function mcpServerAllowedForCwd(scopes, serverName, cwd, { pluginId = '' } = {}) {
   if (!extensionAllowedForCwd(scopes, 'mcp', serverName, cwd)) return false;
-  const pluginId = pluginIdForMcpServer(serverName, plugins);
-  if (pluginId && !extensionAllowedForCwd(scopes, 'plugins', pluginId, cwd)) return false;
+  const owner = clean(pluginId);
+  if (owner && !extensionAllowedForCwd(scopes, 'plugins', owner, cwd)) return false;
   return true;
 }
 
 /** Drop tools of MCP servers whose scope excludes cwd; non-MCP tools pass. */
-export function filterMcpToolsForCwd(tools, scopes, cwd, options = {}) {
+export function filterMcpToolsForCwd(tools, scopes, cwd) {
   const list = Array.isArray(tools) ? tools : [];
   const verdicts = new Map();
   return list.filter((tool) => {
-    const server = mcpServerNameOfTool(tool?.name);
+    // A name shortened for provider limits carries its server explicitly.
+    const server = mcpServerNameOfTool(tool);
     if (!server) return true;
-    if (!verdicts.has(server)) verdicts.set(server, mcpServerAllowedForCwd(scopes, server, cwd, options));
-    return verdicts.get(server);
+    const pluginId = clean(tool?.mcpPluginId);
+    const key = `${server}\0${pluginId}`;
+    if (!verdicts.has(key)) verdicts.set(key, mcpServerAllowedForCwd(scopes, server, cwd, { pluginId }));
+    return verdicts.get(key);
   });
 }
 
-// `{ id, name }` of every registered plugin, from <data>/plugins/registry.json.
-// mtime-cached: this runs on every session create and MCP catalog fold.
-let _registryCache = { path: '', mtime: -1, plugins: [] };
-export function registeredPluginIdentities(dataDir = null) {
-  let path = '';
-  try {
-    path = join(dataDir || resolvePluginData(), 'plugins', 'registry.json');
-  } catch {
-    return [];
-  }
-  let mtime = -1;
-  try {
-    mtime = statSync(path).mtimeMs;
-  } catch {
-    return [];
-  }
-  if (_registryCache.path === path && _registryCache.mtime === mtime) return _registryCache.plugins;
-  let plugins = [];
-  try {
-    const parsed = JSON.parse(readFileSync(path, 'utf8'));
-    plugins = (Array.isArray(parsed?.plugins) ? parsed.plugins : [])
-      .map((entry) => ({ id: clean(entry?.id || entry?.name), name: clean(entry?.name || entry?.id) }))
-      .filter((entry) => entry.id);
-  } catch {
-    plugins = [];
-  }
-  _registryCache = { path, mtime, plugins };
-  return plugins;
-}
-
 /** The MCP tools a session at `cwd` may see. No scopes configured → input
  *  returned as-is, so the global-only fast path costs one config read. */
 export function filterMcpToolsForSession(tools, cwd, config = null) {
@@ -95,5 +55,5 @@ export function filterMcpToolsForSession(tools, cwd, config = null) {
   if (!list.length) return list;
   const scopes = extensionScopesFromConfig(config || loadConfig({ secrets: false }));
   if (!hasExtensionScopes(scopes)) return list;
-  return filterMcpToolsForCwd(list, scopes, cwd, { plugins: registeredPluginIdentities() });
+  return filterMcpToolsForCwd(list, scopes, cwd);
 }

package/src/runtime/agent/orchestrator/runtime-core/goal-control.mjs

@@ -19,7 +19,7 @@ import {
   stopActiveClock,
   validateObjective,
 } from './goal-state.mjs';
-import { assertExpectedGoal } from './goal-mutations.mjs';
+import { assertExpectedGoal, goalFinished } from './goal-mutations.mjs';
 import { clean } from '../../../shared/clean.mjs';
 
 /** "12m remaining" for a budgeted Goal, "3m elapsed" for an open-ended one. */
@@ -109,6 +109,17 @@ const GOAL_CONTROL_ACTIONS = {
     const goal = await ctx.updateGoal(id, { status: 'complete' }, { user: true });
     return reply(action, goal, `Goal complete · ${goal.objective} · ${durationLabel(goal.timeUsedMs)} elapsed`);
   },
+  async dismiss(ctx, { id, goal, at, action }) {
+    // The user's acknowledgement of finished work: the same archive a new
+    // prompt applies, so the chrome lets go while the record stays.
+    if (!goalFinished(goal)) throw new Error('only a finished Goal can be dismissed; stop or complete it first');
+    if (!goal.archivedAt) {
+      goal.archivedAt = at;
+      goal.updatedAt = at;
+      await ctx.commit(id, goal);
+    }
+    return reply(action, null, `Goal dismissed · ${goal.objective}`);
+  },
 };
 
 export async function runGoalControl(ctx, sessionId, rawArgs = {}) {
@@ -146,7 +157,9 @@ export async function runGoalControl(ctx, sessionId, rawArgs = {}) {
     throw new Error('Goal changed while editing; reopen the editor before saving');
   }
   const at = ctx.now();
-  if (goal.status === 'stopped') throw new Error('a stopped Goal cannot be changed; create a new Goal');
+  if (goal.status === 'stopped' && action !== 'dismiss') {
+    throw new Error('a stopped Goal cannot be changed; create a new Goal');
+  }
   const handler = GOAL_CONTROL_ACTIONS[action];
   if (!handler) throw new Error(`unknown Goal action: ${action}`);
   return handler(ctx, { id, goal, args, at, expectedGoalId, action });