@yeaft/webchat-agent 1.0.409 → 1.0.411

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.409",
+  "version": "1.0.411",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/config-api.js

@@ -13,8 +13,33 @@ import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
 import { normalizeProviderModels, parseModelRef, serializeModelForPersistence } from './models.js';
 import { normaliseTelemetrySection, normaliseYeaftSection } from './config.js';
+import { normalizePluginConfig } from './plugins.js';
 import { isGitHubCopilotProvider, serializeKnownProviderForPersistence } from './llm/known-providers.js';
 
+/**
+ * Read config.json before any public mutation. A missing file is a valid
+ * first-run state, but an existing malformed file, non-object root, or invalid
+ * Plugins schema must never be replaced by an unrelated Settings/MCP write.
+ * Otherwise the runtime's fail-closed policy could silently become inheritance
+ * (all capabilities enabled) on the next config reload.
+ *
+ * @param {string} configPath
+ * @returns {Record<string, unknown>}
+ * @throws {Error} when an existing config cannot be safely preserved
+ */
+function readConfigForWrite(configPath) {
+  if (!existsSync(configPath)) return {};
+  const json = JSON.parse(readFileSync(configPath, 'utf8'));
+  if (!json || typeof json !== 'object' || Array.isArray(json)
+    || Object.getPrototypeOf(json) !== Object.prototype) {
+    throw new Error('config.json must contain an object');
+  }
+  if (Object.prototype.hasOwnProperty.call(json, 'plugins')) {
+    normalizePluginConfig(json.plugins);
+  }
+  return json;
+}
+
 /**
  * Read the LLM-relevant portion of config.json.
  *
@@ -119,15 +144,13 @@ export function updateLlmConfig(update, dir) {
   const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
   const configPath = join(root, 'config.json');
 
-  // Read existing config (preserve non-LLM fields)
-  let existing = {};
-  if (existsSync(configPath)) {
-    try {
-      existing = JSON.parse(readFileSync(configPath, 'utf8'));
-    } catch {
-      // Start fresh if corrupt
-      existing = {};
-    }
+  // Preserve all existing fields only when the on-disk document and its
+  // Plugins policy are valid. Never turn a failed read into a fresh config.
+  let existing;
+  try {
+    existing = readConfigForWrite(configPath);
+  } catch (err) {
+    return { error: `Failed to read config.json: ${err?.message || err}` };
   }
 
   // Validate providers structure
@@ -265,14 +288,14 @@ export function updateYeaftSettings(update, dir) {
     }
   }
 
-  // Read existing config (preserve LLM and other top-level fields).
-  let existing = {};
-  if (existsSync(configPath)) {
-    try {
-      existing = JSON.parse(readFileSync(configPath, 'utf8'));
-    } catch {
-      existing = {};
-    }
+  // Preserve all existing fields only when the on-disk document and its
+  // Plugins policy are valid. A Settings update must not repair bad JSON into
+  // a config whose missing Plugins fields inherit all capabilities.
+  let existing;
+  try {
+    existing = readConfigForWrite(configPath);
+  } catch (err) {
+    return { error: `Failed to read config.json: ${err?.message || err}` };
   }
 
   const prev = normaliseYeaftSection(existing.yeaft);
@@ -336,7 +359,12 @@ export function updateTelemetrySettings(update, dir) {
   }
   const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
   const configPath = join(root, 'config.json');
-  const existing = readConfigJson(configPath);
+  let existing;
+  try {
+    existing = readConfigForWrite(configPath);
+  } catch (err) {
+    return { error: `Failed to read config.json: ${err?.message || err}` };
+  }
   const merged = normaliseTelemetrySection({
     ...(existing.telemetry && typeof existing.telemetry === 'object' ? existing.telemetry : {}),
     ...update,
@@ -427,13 +455,11 @@ export function updateSearchSettings(update, dir) {
     return { error: 'tavilyApiKey must be a string' };
   }
 
-  let existing = {};
-  if (existsSync(configPath)) {
-    try {
-      existing = JSON.parse(readFileSync(configPath, 'utf8'));
-    } catch {
-      existing = {};
-    }
+  let existing;
+  try {
+    existing = readConfigForWrite(configPath);
+  } catch (err) {
+    return { error: `Failed to read config.json: ${err?.message || err}` };
   }
   const prev = (existing && typeof existing.search === 'object' && existing.search) || {};
   const merged = { ...prev };
@@ -500,6 +526,49 @@ export async function fetchTavilyUsage(dir) {
   }
 }
 
+// ─── Agent plugin selection ────────────────────────────────────
+
+/**
+ * Read the Agent-local plugin allowlists. Missing category fields mean
+ * inheritance (all discovered capabilities remain available).
+ */
+export function getPluginConfig(dir) {
+  const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
+  const configPath = join(root, 'config.json');
+  try {
+    const json = readConfigForWrite(configPath);
+    return { plugins: normalizePluginConfig(json.plugins) };
+  } catch (err) {
+    return { error: `Failed to read plugin config: ${err?.message || err}` };
+  }
+}
+
+/**
+ * Persist Agent-local plugin allowlists without touching providers, MCP server
+ * definitions, or any other config.json field.
+ */
+export function updatePluginConfig(plugins, dir) {
+  const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
+  const configPath = join(root, 'config.json');
+  let normalized;
+  let existing;
+  try {
+    existing = readConfigForWrite(configPath);
+    normalized = normalizePluginConfig(plugins);
+  } catch (err) {
+    return { error: `Failed to read plugin config: ${err?.message || err}` };
+  }
+
+  if (Object.keys(normalized).length === 0) delete existing.plugins;
+  else existing.plugins = normalized;
+  try {
+    writeFileSync(configPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+  } catch (err) {
+    return { error: `Failed to write plugin config: ${err?.message || err}` };
+  }
+  return { plugins: normalized };
+}
+
 // ─── MCP server config (mcpServers array in config.json) ──
 
 /**
@@ -579,24 +648,6 @@ function validateMcpServer(entry) {
   return null;
 }
 
-/**
- * Read existing config.json (silently start fresh on missing / corrupt).
- * Internal helper used by the MCP CRUD trio to share one parse path.
- *
- * @param {string} configPath
- * @returns {object}
- */
-function readConfigJson(configPath) {
-  if (!existsSync(configPath)) return {};
-  try {
-    const raw = readFileSync(configPath, 'utf8');
-    const json = JSON.parse(raw);
-    return (json && typeof json === 'object') ? json : {};
-  } catch {
-    return {};
-  }
-}
-
 /**
  * List MCP servers currently saved in config.json. Returns an array — empty
  * when none configured. Each entry is the normalised on-disk shape, NOT
@@ -609,12 +660,12 @@ export function listMcpServers(dir) {
   const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
   const configPath = join(root, 'config.json');
   try {
-    const json = readConfigJson(configPath);
+    const json = readConfigForWrite(configPath);
     const raw = Array.isArray(json.mcpServers) ? json.mcpServers : [];
     const servers = raw.map(normaliseMcpServer).filter(Boolean);
     return { servers };
-  } catch (e) {
-    return { error: `Failed to read config.json: ${e.message}` };
+  } catch (err) {
+    return { error: `Failed to read config.json: ${err?.message || err}` };
   }
 }
 
@@ -634,7 +685,12 @@ export function upsertMcpServer(server, dir) {
 
   const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
   const configPath = join(root, 'config.json');
-  const existing = readConfigJson(configPath);
+  let existing;
+  try {
+    existing = readConfigForWrite(configPath);
+  } catch (err) {
+    return { error: `Failed to read config.json: ${err?.message || err}` };
+  }
   const list = Array.isArray(existing.mcpServers) ? existing.mcpServers.slice() : [];
 
   const normalised = normaliseMcpServer(server);
@@ -677,7 +733,12 @@ export function removeMcpServer(name, dir) {
   const target = name.trim();
   const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
   const configPath = join(root, 'config.json');
-  const existing = readConfigJson(configPath);
+  let existing;
+  try {
+    existing = readConfigForWrite(configPath);
+  } catch (err) {
+    return { error: `Failed to read config.json: ${err?.message || err}` };
+  }
   const list = Array.isArray(existing.mcpServers) ? existing.mcpServers.slice() : [];
   const next = list.filter(s => !(s && typeof s === 'object' && s.name === target));
   const removed = next.length !== list.length;

package/yeaft/config.js

@@ -26,6 +26,7 @@ import { DEFAULT_YEAFT_DIR } from './init.js';
 import { getModelEffortOptions, getThinkingCapability, modelSupportsEffort, resolveModel, parseModelRef, normalizeProviderModels, resolveContextWindow, resolveMaxOutputTokens } from './models.js';
 import { inferProtocolFromModelId } from './llm/router.js';
 import { normalizeKnownProviderForRuntime } from './llm/known-providers.js';
+import { createDenyAllPluginConfig, normalizePluginConfig } from './plugins.js';
 import { readWorkspaceFile } from './workspace-file.js';
 
 /** Default configuration values. */
@@ -367,6 +368,7 @@ function loadLegacyConfig(dir, overrides) {
     // task-318: legacy path never had the `yeaft` section — defaults.
     yeaft: normaliseYeaftSection(null),
     telemetry: normaliseTelemetrySection(null),
+    plugins: {},
     providers: null,
     primaryModel: null,
     fastModel: null,
@@ -413,12 +415,20 @@ export function loadConfig(overrides = {}) {
   // Determine data directory
   const dir = overrides.dir || process.env.YEAFT_DIR || DEFAULTS.dir;
 
-  // Try config.json first
+  // Try config.json first. A missing file preserves legacy behavior, but an
+  // existing file that cannot be parsed (or is not an object) must not reopen
+  // a persisted Plugin restriction through the legacy fallback.
+  const configPath = join(dir, 'config.json');
+  const hasConfigFile = existsSync(configPath);
   const jsonConfig = readConfigJson(dir);
 
-  if (!jsonConfig) {
-    // No config.json → legacy path
-    return loadLegacyConfig(dir, overrides);
+  if (!jsonConfig || typeof jsonConfig !== 'object' || Array.isArray(jsonConfig)) {
+    const config = loadLegacyConfig(dir, overrides);
+    if (hasConfigFile) {
+      config.plugins = createDenyAllPluginConfig();
+      config.pluginConfigError = 'config.json is invalid or must contain an object';
+    }
+    return config;
   }
 
   // ─── Build config from config.json ────────────────────────
@@ -461,6 +471,18 @@ export function loadConfig(overrides = {}) {
   const resolvedMaxOutput = overrides.maxOutputTokens ?? jsonConfig.maxOutputTokens
     ?? resolveMaxOutputTokens(modelIdForInfo, { modelInfo });
 
+  // Missing plugins keeps the historical all-enabled behavior. A present but
+  // invalid schema must not collapse to `{}` because that is also all-enabled;
+  // use explicit empty allowlists until the user repairs config.json instead.
+  let plugins;
+  let pluginConfigError = null;
+  try {
+    plugins = normalizePluginConfig(jsonConfig.plugins);
+  } catch (err) {
+    plugins = createDenyAllPluginConfig();
+    pluginConfigError = err?.message || String(err);
+  }
+
   const config = {
     // Model
     model: overrides.model || model,
@@ -503,6 +525,13 @@ export function loadConfig(overrides = {}) {
     yeaft: normaliseYeaftSection(jsonConfig.yeaft),
     telemetry: normaliseTelemetrySection(jsonConfig.telemetry),
 
+    // Agent-level tools / skills / MCP server allowlists. Missing fields mean
+    // all currently discovered capabilities remain enabled. A persisted schema
+    // error is represented by explicit empty allowlists so runtime policy fails
+    // closed instead of reopening every capability.
+    plugins,
+    pluginConfigError,
+
     // Legacy fields (null when using config.json)
     apiKey: overrides.apiKey || null,
     openaiApiKey: null,
@@ -600,7 +629,7 @@ export function loadConfig(overrides = {}) {
  * @returns {{ servers: object[], skipped: { name: string, reason: string, source: string }[] }}
  */
 export function loadMCPConfig(yeaftDir, jsonConfig, workDir, options = {}) {
-  const yeaftGlobal = loadGlobalMCPServers(yeaftDir, jsonConfig);
+  const yeaftGlobal = loadAgentMCPConfig(yeaftDir, jsonConfig);
   const externalUser = loadExternalUserMCPServers();
   const project = workDir
     ? loadProjectMCPServers(workDir, options)
@@ -608,7 +637,7 @@ export function loadMCPConfig(yeaftDir, jsonConfig, workDir, options = {}) {
 
   const servers = [];
   const seen = new Set();
-  for (const tier of [yeaftGlobal, externalUser.servers, project.servers]) {
+  for (const tier of [yeaftGlobal.servers, externalUser.servers, project.servers]) {
     for (const s of tier) {
       if (!s?.name || seen.has(s.name)) continue;
       seen.add(s.name);
@@ -619,6 +648,24 @@ export function loadMCPConfig(yeaftDir, jsonConfig, workDir, options = {}) {
   return { servers, skipped: [...externalUser.skipped, ...project.skipped] };
 }
 
+/**
+ * Load only the Agent-owned MCP configuration tier. Plugin Center uses this
+ * catalog source so it reflects current Agent configuration rather than
+ * borrowed user/project MCP sources or a live runtime snapshot.
+ *
+ * An explicitly present `config.json.mcpServers` array is authoritative,
+ * including an empty array. The legacy `mcp.json` fallback applies only when
+ * that field is absent.
+ *
+ * @param {string} yeaftDir
+ * @param {object} [jsonConfig] — Already-parsed config.json (optional, avoids re-read)
+ * @returns {{ servers: object[], skipped: object[] }}
+ */
+export function loadAgentMCPConfig(yeaftDir, jsonConfig) {
+  const configured = jsonConfig === undefined ? readConfigJson(yeaftDir) : jsonConfig;
+  return { servers: loadGlobalMCPServers(yeaftDir, configured), skipped: [] };
+}
+
 /**
  * Load the global (~/.yeaft) MCP server list.
  *
@@ -631,10 +678,10 @@ export function loadMCPConfig(yeaftDir, jsonConfig, workDir, options = {}) {
  * @returns {object[]}
  */
 function loadGlobalMCPServers(yeaftDir, jsonConfig) {
-  // Check config.json mcpServers field
+  // An explicitly present config.json array is authoritative, even when it
+  // is empty. Falling back in that case would resurrect removed MCP servers.
   if (jsonConfig && Array.isArray(jsonConfig.mcpServers)) {
-    const valid = jsonConfig.mcpServers.filter(s => s.name && s.command);
-    if (valid.length > 0) return valid;
+    return jsonConfig.mcpServers.filter(s => s.name && s.command);
   }
 
   // Fallback: standalone mcp.json

package/yeaft/engine.js

@@ -56,6 +56,7 @@ import { COLLAB_TOOL_POLICY, isToolErrorOutput, localizeVisibleText, normalizeTo
 import { CONDITIONAL_BUILTIN_TOOL_NAMES, resolveActiveToolNames } from './tools/activation.js';
 import { discoverToolCapabilities } from './tools/discover-tools.js';
 import { agentBelongsToScope, getAgentRegistry } from './tools/agent.js';
+import { createPluginSkillManager } from './plugins.js';
 import { extractDisplayImages, stripDisplayImageData } from './image-assets.js';
 import { acknowledgePendingNotifications, formatNotificationsForPrompt, peekPendingNotifications } from './sub-agent/notifications.js';
 import {
@@ -203,6 +204,39 @@ function stripLeadingSkillCommandFromPromptParts(promptParts, skillManager) {
   });
 }
 
+function resolveSkillPromptState({ skillManager, prompt, explicitSkillName }) {
+  let resolvedSkillContent = '';
+  let resolvedSkills = [];
+  let skillResolutionError = null;
+  if (!skillManager) {
+    return { resolvedSkillContent, resolvedSkills, skillResolutionError };
+  }
+
+  if (explicitSkillName) {
+    resolvedSkillContent = skillManager.getPromptContent(explicitSkillName);
+    const skill = skillManager.list?.().find(item => item.name === explicitSkillName)
+      || (resolvedSkillContent ? { name: explicitSkillName } : null);
+    if (resolvedSkillContent && skill) {
+      resolvedSkills = [{ ...skill, explicit: true }];
+    } else {
+      skillResolutionError = `Requested skill "${explicitSkillName}" was not found.`;
+      resolvedSkillContent = `## Skill command error\n\n${skillResolutionError} Continue without that skill and tell the user it is unavailable.`;
+    }
+  } else if (prompt && typeof skillManager.findRelevant === 'function') {
+    resolvedSkills = skillManager.findRelevant(prompt).map(skill => ({
+      name: skill.name,
+      description: skill.description || '',
+      trigger: skill.trigger || '',
+      category: skill.category,
+      tier: skill._tier,
+      explicit: false,
+    }));
+    resolvedSkillContent = resolvedSkills.map(skill => skillManager.getPromptContent(skill.name)).join('\n\n');
+  }
+
+  return { resolvedSkillContent, resolvedSkills, skillResolutionError };
+}
+
 function resolveRetryPolicy(config) {
   const raw = config?.llmRetry || {};
   const num = (v, d) => (Number.isFinite(v) && v >= 0 ? v : d);
@@ -617,6 +651,9 @@ export class Engine {
   /** @type {import('./skills.js').SkillManager|null} */
   #skillManager;
 
+  /** @type {import('./skills.js').SkillManager|null} */
+  #baseSkillManager;
+
   /** @type {import('./mcp.js').MCPManager|null} */
   #mcpManager;
 
@@ -838,7 +875,10 @@ export class Engine {
     this.#amsRegistry = amsRegistry || null;
     this.#toolRegistry = toolRegistry || null;
     this.#taskManager = taskManager || null;
-    this.#skillManager = skillManager || null;
+    this.#baseSkillManager = skillManager || null;
+    this.#skillManager = this.#baseSkillManager && Array.isArray(config?.plugins?.skills)
+      ? createPluginSkillManager(this.#baseSkillManager, config.plugins)
+      : this.#baseSkillManager;
     this.#mcpManager = mcpManager || null;
     this.#yeaftDir = yeaftDir || null;
     this.#managedCliReady = managedCliReady || null;
@@ -939,6 +979,9 @@ export class Engine {
   refreshConfig(config) {
     if (!config || typeof config !== 'object') return;
     this.#config = config;
+    this.#skillManager = this.#baseSkillManager && Array.isArray(config.plugins?.skills)
+      ? createPluginSkillManager(this.#baseSkillManager, config.plugins)
+      : this.#baseSkillManager;
     const fastModelId = config.fastModelId || config.model;
     this.#fastConfig = fastModelId !== config.model
       ? { ...config, model: fastModelId }
@@ -954,7 +997,10 @@ export class Engine {
    */
   setRuntimeManagers(managers = {}) {
     if (Object.prototype.hasOwnProperty.call(managers, 'skillManager')) {
-      this.#skillManager = managers.skillManager || null;
+      this.#baseSkillManager = managers.skillManager || null;
+      this.#skillManager = this.#baseSkillManager && Array.isArray(this.#config?.plugins?.skills)
+        ? createPluginSkillManager(this.#baseSkillManager, this.#config.plugins)
+        : this.#baseSkillManager;
     }
     if (Object.prototype.hasOwnProperty.call(managers, 'mcpManager')) {
       this.#mcpManager = managers.mcpManager || null;
@@ -984,6 +1030,7 @@ export class Engine {
     if (this.#toolRegistry) {
       return this.#toolRegistry.getToolDefs(this.#config?.language || 'en', {
         collabToolPolicy,
+        plugins: this.#config?.plugins,
         activeToolNames,
       });
     }
@@ -1220,10 +1267,11 @@ export class Engine {
    * @param {string} [args.explicitSkillName] — leading /skill:<name> command, if present
    * @returns {string}
    */
-  #buildSystemPrompt({ prompt, memoryInjection, vpPersona, activeScope, sessionAnnouncement, projectInstruction, projectLabel, workCenterInstructions, projectDoc, taskCtx, activeTasks, activeToolNames = null, promptNotices = [], explicitSkillName, resolvedSkillContent = null } = {}) {
-    // Skill selection is normally resolved once by #runQuery so the prompt and
-    // emitted protocol events describe the exact same skills. Keep the local
-    // fallback for internal callers that do not need selection events.
+  #buildSystemPrompt({ prompt, memoryInjection, vpPersona, activeScope, sessionAnnouncement, projectInstruction, projectLabel, workCenterInstructions, projectDoc, taskCtx, activeTasks, collabToolPolicy = null, activeToolNames = null, promptNotices = [], explicitSkillName, resolvedSkillContent = null } = {}) {
+    // #runQuery resolves Skill selection at each provider-request boundary so
+    // a live Plugin policy change cannot leave stale content in the next prompt.
+    // Keep the local fallback for internal callers that do not need selection
+    // events.
     let skillContent = typeof resolvedSkillContent === 'string' ? resolvedSkillContent : '';
     if (resolvedSkillContent === null && this.#skillManager) {
       if (explicitSkillName) {
@@ -1234,11 +1282,13 @@ export class Engine {
       }
     }
 
-    // Use the same active set for the prompt and provider schema. The prompt
-    // only needs these names to select scoped guidance; it does not repeat the
-    // catalogue because the API tool definitions are already authoritative.
+    // Prompt guidance must describe the same canonical capability
+    // intersection that reaches provider schemas and execution.
     const registeredToolNames = this.#toolRegistry
-      ? this.#toolRegistry.getToolNames()
+      ? this.#toolRegistry.getToolNames({
+          plugins: this.#config?.plugins,
+          collabToolPolicy,
+        })
       : Array.from(this.#tools.keys());
     const toolNames = activeToolNames instanceof Set
       ? registeredToolNames.filter(name => activeToolNames.has(name))
@@ -2422,8 +2472,12 @@ export class Engine {
         })
       : '';
     const registeredToolNames = this.#toolRegistry
-      ? this.#toolRegistry.getToolNames()
+      ? this.#toolRegistry.getToolNames({
+          collabToolPolicy: effectiveCollabToolPolicy,
+          plugins: this.#config?.plugins,
+        })
       : Array.from(this.#tools.keys());
+    const registeredToolNameSet = new Set(registeredToolNames);
     const resolveCurrentActiveToolNames = () => this.#toolRegistry
       ? resolveActiveToolNames({
           toolNames: registeredToolNames,
@@ -2444,6 +2498,7 @@ export class Engine {
     const discoveryTraversals = new Map();
     const currentDiscoverableTools = () => this.#toolRegistry
       ? this.#toolRegistry.getAllTools()
+          .filter(tool => registeredToolNameSet.has(tool.name))
           .filter(tool => CONDITIONAL_BUILTIN_TOOL_NAMES.has(tool.name) || tool.name.startsWith('mcp__'))
       : [];
     const discoveryDirectorySnapshot = (tools, language) => tools
@@ -2469,32 +2524,11 @@ export class Engine {
       }
     };
     let activeToolNames = resolveCurrentActiveToolNames();
-    let resolvedSkillContent = '';
-    let resolvedSkills = [];
-    let skillResolutionError = null;
-    if (this.#skillManager) {
-      if (explicitSkillName) {
-        resolvedSkillContent = this.#skillManager.getPromptContent(explicitSkillName);
-        const skill = this.#skillManager.list?.().find(item => item.name === explicitSkillName)
-          || (resolvedSkillContent ? { name: explicitSkillName } : null);
-        if (resolvedSkillContent && skill) {
-          resolvedSkills = [{ ...skill, explicit: true }];
-        } else {
-          skillResolutionError = `Requested skill "${explicitSkillName}" was not found.`;
-          resolvedSkillContent = `## Skill command error\n\n${skillResolutionError} Continue without that skill and tell the user it is unavailable.`;
-        }
-      } else if (prompt && typeof this.#skillManager.findRelevant === 'function') {
-        resolvedSkills = this.#skillManager.findRelevant(prompt).map(skill => ({
-          name: skill.name,
-          description: skill.description || '',
-          trigger: skill.trigger || '',
-          category: skill.category,
-          tier: skill._tier,
-          explicit: false,
-        }));
-        resolvedSkillContent = resolvedSkills.map(skill => this.#skillManager.getPromptContent(skill.name)).join('\n\n');
-      }
-    }
+    let { resolvedSkillContent, resolvedSkills, skillResolutionError } = resolveSkillPromptState({
+      skillManager: this.#skillManager,
+      prompt,
+      explicitSkillName,
+    });
 
     let promptNotices = [];
     const buildCurrentSystemPrompt = () => this.#buildSystemPrompt({
@@ -2508,6 +2542,7 @@ export class Engine {
       workCenterInstructions,
       projectDoc: projectDocContext.text,
       activeTasks,
+      collabToolPolicy: effectiveCollabToolPolicy,
       activeToolNames,
       promptNotices,
       explicitSkillName,
@@ -2678,12 +2713,10 @@ export class Engine {
       sessionId: sessionId || null,
       at: queryStartedAt,
     };
-    for (const skill of resolvedSkills) {
-      yield { type: 'skill_loaded', turnId: queryTurnId, skill };
-    }
-    if (skillResolutionError) {
-      yield { type: 'skill_error', turnId: queryTurnId, skillName: explicitSkillName, message: skillResolutionError };
-    }
+    // Skill selection is emitted at the provider-request boundary below. A
+    // persisted Plugin update may replace the filtered SkillManager while this
+    // query is paused on a tool, so reporting it before that boundary could
+    // claim a Skill was loaded even though its content never reached a request.
 
     // Surface the exact memory that entered the prompt. This must be based on
     // the AMS snapshot, not raw FTS candidates, otherwise debug can claim memory
@@ -2729,6 +2762,11 @@ export class Engine {
     let cumulativeInputTokens = 0;
     let cumulativeOutputTokens = 0;
     let activeProviderRequest = null;
+    // Skill events describe the selection injected into each provider request.
+    // The first request must report its initial selection; later loops report
+    // only newly added Skills or a newly introduced explicit-command error.
+    let reportedSkillNames = new Set();
+    let reportedSkillError = null;
     // task-707: tool-callable end-turn signal. Tools (currently only
     // `route_forward`) can set this via toolCtx.requestEndTurn(reason)
     // to break out of the tool-loop after the current batch finishes
@@ -2936,6 +2974,22 @@ export class Engine {
         else discoveredToolNames.delete(name);
       }
       toolDefs = this.#getToolDefs(effectiveCollabToolPolicy, activeToolNames);
+      ({ resolvedSkillContent, resolvedSkills, skillResolutionError } = resolveSkillPromptState({
+        skillManager: this.#skillManager,
+        prompt,
+        explicitSkillName,
+      }));
+      const currentSkillNames = new Set(resolvedSkills.map(skill => skill.name));
+      for (const skill of resolvedSkills) {
+        if (!reportedSkillNames.has(skill.name)) {
+          yield { type: 'skill_loaded', turnId: queryTurnId, skill };
+        }
+      }
+      if (skillResolutionError && skillResolutionError !== reportedSkillError) {
+        yield { type: 'skill_error', turnId: queryTurnId, skillName: explicitSkillName, message: skillResolutionError };
+      }
+      reportedSkillNames = currentSkillNames;
+      reportedSkillError = skillResolutionError;
       systemPrompt = buildCurrentSystemPrompt();
 
       try {
@@ -4187,6 +4241,7 @@ export class Engine {
         const hasTool = this.#toolRegistry
           ? this.#toolRegistry.isAllowed(tc.name, {
               collabToolPolicy: effectiveCollabToolPolicy,
+              plugins: this.#config?.plugins,
               activeToolNames,
             })
           : this.#tools.has(tc.name);