@yeaft/webchat-agent 1.0.408 → 1.0.410

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))
@@ -2219,7 +2269,7 @@ export class Engine {
     const runtimeThreadId = (typeof threadId === 'string' && threadId.trim())
       ? threadId.trim()
       : MAIN_THREAD_ID;
-    const executionOrigin = inboundEnvelope?.msg?.meta?.injectedBy === 'route_forward'
+    const executionOrigin = ['route_forward', 'route_forward_result'].includes(inboundEnvelope?.msg?.meta?.injectedBy)
       ? 'route_forward'
       : null;
     // The bridge-provided VP turn id is also persisted on assistant messages and
@@ -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);

package/yeaft/plugins.js

@@ -0,0 +1,170 @@
+/**
+ * plugins.js — Agent-level selectable Yeaft capabilities.
+ *
+ * An Agent owns installed tools, skills, and MCP configuration. Missing plugin
+ * fields retain historical behavior (everything enabled); explicit arrays are
+ * allowlists and may intentionally be empty.
+ */
+
+function normalizeNameList(value, field) {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value)) throw new Error(`plugins.${field} must be an array`);
+
+  const names = [];
+  const seen = new Set();
+  for (const raw of value) {
+    if (typeof raw !== 'string' || !raw.trim()) {
+      throw new Error(`plugins.${field} entries must be non-empty strings`);
+    }
+    const name = raw.trim();
+    if (!seen.has(name)) {
+      seen.add(name);
+      names.push(name);
+    }
+  }
+  return names;
+}
+
+/** Normalise persisted Agent plugin config while preserving inheritance. */
+export function normalizePluginConfig(value) {
+  // Only an omitted field inherits the legacy all-enabled behavior. An
+  // explicit `null` is persisted schema, not absence, and must be rejected
+  // so every reader can fail closed consistently.
+  if (value === undefined) return {};
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('plugins must be an object');
+  }
+
+  const out = {};
+  for (const field of ['tools', 'skills', 'mcpServers']) {
+    const names = normalizeNameList(value[field], field);
+    if (names !== undefined) out[field] = names;
+  }
+  for (const key of Object.keys(value)) {
+    if (!['tools', 'skills', 'mcpServers'].includes(key)) {
+      throw new Error(`unknown plugins key: ${key}`);
+    }
+  }
+  return out;
+}
+
+/**
+ * Return an explicit deny-all policy for a persisted plugins schema error.
+ * This is deliberately distinct from `{}`, whose missing fields inherit the
+ * historical all-enabled behavior.
+ */
+export function createDenyAllPluginConfig() {
+  return { tools: [], skills: [], mcpServers: [] };
+}
+
+export function isPluginNameEnabled(plugins, field, name) {
+  if (!plugins || !Array.isArray(plugins[field])) return true;
+  return plugins[field].includes(name);
+}
+
+/**
+ * Keep the configured MCP catalog separate from the runtime connection set.
+ * The catalog must retain disabled servers so users can enable them later;
+ * runtimes must receive only the effective allowlisted subset.
+ *
+ * The caller owns the raw configured catalog; this helper never connects it.
+ */
+export function resolveMcpPluginPolicy(mcpConfig, plugins) {
+  const configured = {
+    ...(mcpConfig || {}),
+    servers: Array.isArray(mcpConfig?.servers) ? mcpConfig.servers : [],
+  };
+  if (!Array.isArray(plugins?.mcpServers)) {
+    return { configured, effective: configured };
+  }
+
+  const allowed = new Set(plugins.mcpServers);
+  return {
+    configured,
+    effective: {
+      ...configured,
+      servers: configured.servers.filter(server => allowed.has(server?.name)),
+    },
+  };
+}
+
+/**
+ * Live delegating view over a SkillManager. It does not mutate the shared
+ * manager because Sessions and project runtimes reuse that manager.
+ */
+export function createPluginSkillManager(skillManager, plugins) {
+  if (!skillManager) return null;
+  const hasExplicitSkills = Array.isArray(plugins?.skills);
+  const allowed = hasExplicitSkills ? new Set(plugins.skills) : null;
+  const isAllowed = name => !allowed || allowed.has(name);
+  const has = name => isAllowed(name) && !!skillManager.has?.(name);
+  const list = (...args) => (skillManager.list?.(...args) || [])
+    .filter(skill => isAllowed(skill?.name));
+  const get = name => has(name) ? skillManager.get?.(name) || null : null;
+  const resolve = name => has(name) ? skillManager.resolve?.(name) || null : null;
+  const view = (name, filePath) => has(name) ? skillManager.view?.(name, filePath) || null : null;
+  const findRelevant = (...args) => (skillManager.findRelevant?.(...args) || [])
+    .filter(skill => isAllowed(skill?.name));
+  const getPromptContent = name => has(name) ? skillManager.getPromptContent?.(name) || '' : '';
+
+  return {
+    has,
+    get,
+    resolve,
+    list,
+    view,
+    findRelevant,
+    getPromptContent,
+    getRelevantPromptContent: (...args) => findRelevant(...args)
+      .map(skill => getPromptContent(skill.name))
+      .filter(Boolean)
+      .join('\n\n'),
+    listCategories: () => [...new Set(list().map(skill => skill.category).filter(Boolean))].sort(),
+    get size() { return list().length; },
+  };
+}
+
+/** Build a browser-safe catalog from already discovered Agent assets. */
+export function buildPluginCatalog({ toolRegistry, skillManager, mcpConfig, mcpManager } = {}) {
+  const tools = typeof toolRegistry?.getAllTools === 'function'
+    ? toolRegistry.getAllTools()
+      .filter(tool => !tool?.mcpServer)
+      .map(tool => ({ id: tool.name, label: tool.name }))
+      .sort((a, b) => a.label.localeCompare(b.label))
+    : [];
+
+  const skills = typeof skillManager?.list === 'function'
+    ? skillManager.list()
+      .map(skill => ({
+        id: skill.name,
+        label: skill.name,
+        description: skill.description || '',
+        category: skill.category || null,
+      }))
+      .sort((a, b) => a.label.localeCompare(b.label))
+    : [];
+
+  const statusByName = new Map((mcpManager?.status?.() || [])
+    .map(status => [status.name, status]));
+  // A configured catalog is authoritative, including an explicit empty array.
+  // Only callers that supplied no catalog at all use live status as a legacy
+  // fallback.
+  const configuredMcpServers = Array.isArray(mcpConfig?.servers)
+    ? mcpConfig.servers
+    : (mcpManager?.status?.() || []).map(status => ({ name: status.name, command: '' }));
+  const mcpServers = configuredMcpServers
+    .filter(server => typeof server?.name === 'string' && server.name)
+    .map(server => {
+      const status = statusByName.get(server.name);
+      return {
+        id: server.name,
+        label: server.name,
+        description: server.command || '',
+        ready: status ? !!status.ready : null,
+        toolCount: status?.toolCount || 0,
+      };
+    })
+    .sort((a, b) => a.label.localeCompare(b.label));
+
+  return { tools, skills, mcpServers };
+}

package/yeaft/routing/router.js

@@ -28,6 +28,39 @@
 import { resolveMemberId } from '../sessions/roster.js';
 import { createLoopGuard, extendCausedBy } from './loop-guard.js';
 
+function routeForwardParentFromEnvelope(envelope) {
+  const msg = envelope?.msg;
+  const meta = msg?.meta;
+  if (!meta || typeof meta !== 'object') return null;
+  if (meta.injectedBy === 'route_forward_result') {
+    return meta.routeForwardParent && typeof meta.routeForwardParent === 'object'
+      ? { ...meta.routeForwardParent }
+      : null;
+  }
+  if (meta.injectedBy !== 'route_forward') return null;
+  const forwardId = typeof msg.id === 'string' ? msg.id.trim() : '';
+  const sourceVpId = typeof meta.senderVpId === 'string' ? meta.senderVpId.trim() : '';
+  if (!forwardId || !sourceVpId) return null;
+  return {
+    forwardId,
+    sourceVpId,
+    sourceThreadId: typeof meta.sourceThreadId === 'string' && meta.sourceThreadId.trim()
+      ? meta.sourceThreadId.trim()
+      : 'main',
+    expectedVpIds: Array.isArray(meta.routeForwardExpectedTargets)
+      ? meta.routeForwardExpectedTargets.slice()
+      : [],
+    causedBy: Array.isArray(meta.causedBy) ? meta.causedBy.slice() : [],
+    dispatchErrors: Array.isArray(meta.routeForwardDispatchErrors)
+      ? meta.routeForwardDispatchErrors.slice()
+      : [],
+    truncatedAtFanOutCap: Boolean(meta.routeForwardTruncatedAtFanOutCap),
+    parentRouteForward: meta.routeForwardParent && typeof meta.routeForwardParent === 'object'
+      ? { ...meta.routeForwardParent }
+      : null,
+  };
+}
+
 /**
  * Build a router bound to a single GroupCoordinator + loop guard.
  *
@@ -112,6 +145,7 @@ export function createRouter(deps = {}) {
     // The guard runs against the *pre-dispatch* chain; that matches the
     // spec's intent ("depth of forwards already taken").
     const chain = extendCausedBy(args.inboundEnvelope || null, null);
+    const routeForwardParent = routeForwardParentFromEnvelope(args.inboundEnvelope);
 
     // Loop guard: for broadcast, use 'all' as the target key so one VP
     // spamming @all still gets throttled even if each cycle hits different
@@ -155,6 +189,7 @@ export function createRouter(deps = {}) {
           senderVpId: from,
           reason: args.reason || null,
           causedBy: chain,
+          ...(routeForwardParent ? { routeForwardParent } : {}),
           sourceThreadId: typeof args.sourceThreadId === 'string' && args.sourceThreadId.trim()
             ? args.sourceThreadId.trim()
             : null,
@@ -163,11 +198,35 @@ export function createRouter(deps = {}) {
       opts,
     );
 
+    // `deliver()` queues its work, so the target envelopes still share this
+    // stored message object when forward() returns. Record the accepted target
+    // set for the active runtime only: it lets a stream Session return one
+    // combined result to the caller after an @all fan-out finishes. The
+    // transient value is deliberately not required for durable replay.
+    if (report?.message?.meta && Array.isArray(report.dispatched)) {
+      report.message.meta.routeForwardExpectedTargets = report.dispatched.slice();
+      report.message.meta.routeForwardDispatchErrors = Array.isArray(report.errors)
+        ? report.errors.slice()
+        : [];
+      report.message.meta.routeForwardTruncatedAtFanOutCap = Boolean(report.truncatedAtFanOutCap);
+    }
+
     // Record AFTER Coordinator accepts. If Coordinator produced zero
     // dispatches (e.g. task.members gate) we still count it as a hit —
     // the forwarder still tried, and the guard's job is to throttle the
     // sender's ability to keep trying.
     guard.record({ sessionId: meta.id, targetVpId: guardKey });
+    if (!Array.isArray(report.dispatched) || report.dispatched.length === 0) {
+      return {
+        ok: false,
+        error: 'no_targets_dispatched',
+        detail: {
+          errors: Array.isArray(report.errors) ? report.errors : [],
+          truncatedAtFanOutCap: Boolean(report.truncatedAtFanOutCap),
+        },
+        report,
+      };
+    }
 
     return {
       ok: true,