@yeaft/webchat-agent 1.0.70 → 1.0.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.70",
+  "version": "1.0.71",
   "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/engine.js

@@ -100,19 +100,27 @@ const RETRY_DEFAULTS = Object.freeze({
 // Autocomplete prefers /yeaft-skills:<name>; /skill:<name> remains supported
 // for older clients and typed history.
 const EXPLICIT_SKILL_COMMAND_RE = /^\/(?:skill|yeaft-skills):([^\s]+)(\s+|$)/;
+const BARE_SKILL_COMMAND_RE = /^\/([A-Za-z0-9][A-Za-z0-9_.-]*)(\s+|$)/;
 
-function parseExplicitSkillCommand(prompt) {
+function parseExplicitSkillCommand(prompt, skillManager) {
   if (typeof prompt !== 'string') {
     return { skillName: null, cleanedPrompt: prompt };
   }
   const match = prompt.match(EXPLICIT_SKILL_COMMAND_RE);
-  if (!match) {
-    return { skillName: null, cleanedPrompt: prompt };
+  if (match) {
+    return {
+      skillName: match[1],
+      cleanedPrompt: prompt.slice(match[0].length),
+    };
   }
-  return {
-    skillName: match[1],
-    cleanedPrompt: prompt.slice(match[0].length),
-  };
+  const bareMatch = prompt.match(BARE_SKILL_COMMAND_RE);
+  if (bareMatch && typeof skillManager?.has === 'function' && skillManager.has(bareMatch[1])) {
+    return {
+      skillName: bareMatch[1],
+      cleanedPrompt: prompt.slice(bareMatch[0].length),
+    };
+  }
+  return { skillName: null, cleanedPrompt: prompt };
 }
 
 function stripLeadingSkillCommandFromPromptParts(promptParts) {
@@ -1641,7 +1649,7 @@ export class Engine {
     // the merge, so an invalid caller value (e.g. 'ULTRA') does not shadow a
     // valid prompt prefix.
     const parsed = parseEffortPrefix(prompt);
-    const parsedSkill = parseExplicitSkillCommand(parsed.cleanedPrompt);
+    const parsedSkill = parseExplicitSkillCommand(parsed.cleanedPrompt, this.#skillManager);
     const effectivePrompt = parsedSkill.cleanedPrompt;
     const effectivePromptParts = parsedSkill.skillName
       ? stripLeadingSkillCommandFromPromptParts(promptParts)

package/yeaft/web-bridge.js

@@ -78,6 +78,8 @@ import { perfNowMs, recordAgentPerfTrace } from './perf-trace.js';
 
 const LEGACY_SKILL_COMMAND_PREFIX = 'skill:';
 const YEAFT_SKILL_COMMAND_PREFIX = 'yeaft-skills:';
+const PROJECT_SKILL_TIERS = new Set(['project', 'project-claude', 'project-codex']);
+const BASE_RUNTIME_KEY = '__base__';
 
 /** @type {import('./session.js').Session | null} */
 let session = null;
@@ -423,6 +425,9 @@ const vpThreads = new Map();
 const routePromisesByMsgId = new Map();
 /** @type {Map<string, { workDir: string, skillManager: import('./skills.js').SkillManager, mcpManager: import('./mcp.js').MCPManager, mcpStatus: object, mcpConfig: object, status: { skills: number, mcpServers: string[], mcpFailed: object[], mcpSkipped: object[], tools: number } }>} */
 const projectRuntimes = new Map();
+/** @type {Map<string, Promise<any>>} */
+const baseRuntimeLoadPromises = new Map();
+let activeRuntimeKey = BASE_RUNTIME_KEY;
 
 function replaceSessionMcpTools(mcpManager) {
   if (!session?.toolRegistry || typeof session.toolRegistry.replaceMcpTools !== 'function') {
@@ -438,6 +443,9 @@ function replaceSessionMcpTools(mcpManager) {
 }
 
 function retargetVpEngines({ skillManager, mcpManager }) {
+  try {
+    session?.engine?.setRuntimeManagers?.({ skillManager, mcpManager });
+  } catch { /* best-effort default-engine retarget */ }
   for (const eng of vpEngines.values()) {
     try {
       eng.setRuntimeManagers?.({ skillManager, mcpManager });
@@ -446,17 +454,26 @@ function retargetVpEngines({ skillManager, mcpManager }) {
 }
 
 function activateBaseRuntime() {
+  activeRuntimeKey = BASE_RUNTIME_KEY;
   const swap = replaceSessionMcpTools(session?.mcpManager);
   retargetVpEngines({
     skillManager: session?.skillManager || null,
     mcpManager: session?.mcpManager || null,
   });
+  const status = session?.status || null;
+  if (status) {
+    status.skills = session?.skillManager?.size || 0;
+    status.mcpServers = Array.isArray(status.mcpServers) ? status.mcpServers : [];
+    status.mcpFailed = Array.isArray(status.mcpFailed) ? status.mcpFailed : [];
+    status.tools = session?.toolRegistry?.size || status.tools || 0;
+  }
   broadcastSkillSlashCommands(session);
   return swap;
 }
 
 function activateProjectRuntime(runtime) {
   if (!runtime) return activateBaseRuntime();
+  activeRuntimeKey = projectRuntimeKey(runtime.workDir);
   const swap = replaceSessionMcpTools(runtime.mcpManager);
   retargetVpEngines({
     skillManager: runtime.skillManager,
@@ -473,6 +490,8 @@ function activateProjectRuntime(runtime) {
 async function shutdownProjectRuntimes() {
   const runtimes = Array.from(projectRuntimes.values());
   projectRuntimes.clear();
+  projectRuntimeLoadPromises.clear();
+  baseRuntimeLoadPromises.clear();
   await Promise.all(runtimes.map(async (runtime) => {
     try { await runtime?.mcpManager?.disconnectAll?.(); } catch { /* best-effort shutdown */ }
   }));
@@ -728,6 +747,9 @@ let yeaftConversationId = null;
  *  creates/replaces the virtual Yeaft conversation id so `/` autocomplete never
  *  falls back to built-ins while full Session metadata is still loading. */
 let lastYeaftSlashCommandSnapshot = null;
+let lastYeaftGeneratedSlashCommands = new Set();
+/** @type {Map<string, Promise<any>>} */
+const projectRuntimeLoadPromises = new Map();
 
 /** task-334-followup-batch-b: stored unsubscribe fn from VP subscribe,
  *  called on session reset to prevent stale subscriber leaks. */
@@ -1859,35 +1881,42 @@ function sendSessionOutputFrame(data, { sessionId, chatId, vpId, turnId, threadI
   });
 }
 
+function isProjectSkill(skill) {
+  return PROJECT_SKILL_TIERS.has(String(skill?.tier || '').trim());
+}
+
 export function buildSkillSlashCommands(skillManager) {
   if (!skillManager || typeof skillManager.list !== 'function') return { commands: [], descriptions: {} };
   const commands = [];
   const descriptions = {};
   for (const skill of skillManager.list()) {
     if (!skill?.name || typeof skill.name !== 'string') continue;
-    const commandName = `${YEAFT_SKILL_COMMAND_PREFIX}${skill.name}`;
+    const description = skill.description || skill.trigger || 'Load Yeaft skill';
+    const commandName = isProjectSkill(skill)
+      ? skill.name
+      : `${YEAFT_SKILL_COMMAND_PREFIX}${skill.name}`;
     commands.push(commandName);
-    descriptions[commandName] = skill.description || skill.trigger || 'Load Yeaft skill';
+    descriptions[commandName] = description;
 
-    // Legacy alias for older typed commands and persisted drafts. Do not add it
-    // to the visible command list; autocomplete should show the same plugin-style
-    // names users see in Claude Code, e.g. /yeaft-skills:code-review.
-    const legacyCommandName = `${LEGACY_SKILL_COMMAND_PREFIX}${skill.name}`;
-    descriptions[legacyCommandName] = descriptions[commandName];
+    // Accepted aliases for typed history and compatibility. They are not added
+    // to the visible list unless they are the tier-appropriate display command.
+    descriptions[`${LEGACY_SKILL_COMMAND_PREFIX}${skill.name}`] = description;
+    descriptions[`${YEAFT_SKILL_COMMAND_PREFIX}${skill.name}`] = description;
   }
   commands.sort((a, b) => a.localeCompare(b));
   return { commands, descriptions };
 }
 
 export function buildMergedSkillSlashCommands(skillManagers = []) {
-  const commands = [];
-  const descriptions = {};
+  const byName = new Map();
   for (const manager of skillManagers) {
-    const built = buildSkillSlashCommands(manager);
-    for (const cmd of built.commands) commands.push(cmd);
-    Object.assign(descriptions, built.descriptions);
+    if (!manager || typeof manager.list !== 'function') continue;
+    for (const skill of manager.list()) {
+      if (!skill?.name || typeof skill.name !== 'string') continue;
+      byName.set(skill.name, skill);
+    }
   }
-  return { commands: [...new Set(commands)].sort((a, b) => a.localeCompare(b)), descriptions };
+  return buildSkillSlashCommands({ list: () => [...byName.values()] });
 }
 
 function sendSkillSlashCommandsUpdate({ conversationId, slashCommands, slashCommandDescriptions }) {
@@ -1909,7 +1938,7 @@ function replayCachedSkillSlashCommandsToYeaftConversation() {
   });
 }
 
-export function preloadYeaftSkillSlashCommands() {
+function loadAndBroadcastYeaftSkillSlashCommands() {
   const yeaftDir = ctx.CONFIG?.yeaftDir || DEFAULT_YEAFT_DIR;
   const roots = [process.cwd()];
   const configuredWorkDir = typeof ctx.CONFIG?.workDir === 'string' ? ctx.CONFIG.workDir.trim() : '';
@@ -1923,11 +1952,21 @@ export function preloadYeaftSkillSlashCommands() {
   };
 }
 
+export function preloadYeaftSkillSlashCommands() {
+  setTimeout(() => {
+    try { loadAndBroadcastYeaftSkillSlashCommands(); }
+    catch (err) { console.warn('[Yeaft] async skill slash preload failed:', err?.message || err); }
+  }, 0);
+  return { scheduled: true };
+}
+
 function broadcastSkillSlashCommands(sessionLike, extraSkillManagers = []) {
   const managers = [sessionLike?.skillManager, ...extraSkillManagers].filter(Boolean);
   const { commands, descriptions } = buildMergedSkillSlashCommands(managers);
   const isYeaftSkillCommand = (cmd) => typeof cmd === 'string'
-    && (cmd.startsWith(LEGACY_SKILL_COMMAND_PREFIX) || cmd.startsWith(YEAFT_SKILL_COMMAND_PREFIX));
+    && (lastYeaftGeneratedSlashCommands.has(cmd)
+      || cmd.startsWith(LEGACY_SKILL_COMMAND_PREFIX)
+      || cmd.startsWith(YEAFT_SKILL_COMMAND_PREFIX));
   const nonSkillCommands = (ctx.slashCommands || []).filter(cmd => !isYeaftSkillCommand(cmd));
   const slashCommands = [...new Set([...nonSkillCommands, ...commands])];
   const slashCommandDescriptions = Object.fromEntries(
@@ -1937,6 +1976,7 @@ function broadcastSkillSlashCommands(sessionLike, extraSkillManagers = []) {
   Object.assign(slashCommandDescriptions, descriptions);
   ctx.slashCommands = slashCommands;
   ctx.slashCommandDescriptions = slashCommandDescriptions;
+  lastYeaftGeneratedSlashCommands = new Set(commands);
   lastYeaftSlashCommandSnapshot = { slashCommands, slashCommandDescriptions };
   sendSkillSlashCommandsUpdate({
     conversationId: yeaftConversationId || '__preload__',
@@ -1945,6 +1985,63 @@ function broadcastSkillSlashCommands(sessionLike, extraSkillManagers = []) {
   });
 }
 
+async function loadBaseRuntime() {
+  if (!session) return null;
+  const yeaftDir = ctx.CONFIG?.yeaftDir || session.yeaftDir || DEFAULT_YEAFT_DIR;
+  const skillManager = createSkillManager(yeaftDir, process.cwd());
+  session.skillManager = skillManager;
+
+  const mcpConfig = loadMCPConfig(yeaftDir, undefined, process.cwd());
+  const mcpManager = new MCPManager();
+  session.mcpManager = mcpManager;
+  let mcpStatus = { connected: [], failed: [] };
+
+  if (session.status) {
+    session.status.skills = skillManager.size;
+    session.status.mcpServers = [];
+    session.status.mcpFailed = [];
+    session.status.mcpSkipped = mcpConfig.skipped || [];
+    session.status.tools = session.toolRegistry?.size || session.status.tools || 0;
+  }
+  if (activeRuntimeKey === BASE_RUNTIME_KEY) {
+    activateBaseRuntime();
+  } else {
+    broadcastSkillSlashCommands(session);
+  }
+  hydrateYeaftStatusFromSession(session, { reason: 'base_runtime_skills', emitEvent: true });
+
+  if (mcpConfig.servers.length > 0) {
+    mcpStatus = await mcpManager.connectAll(mcpConfig.servers);
+    session.mcpManager = mcpManager;
+    if (session.status) {
+      session.status.mcpServers = mcpStatus.connected;
+      session.status.mcpFailed = mcpStatus.failed;
+      session.status.mcpSkipped = mcpConfig.skipped || [];
+    }
+    if (activeRuntimeKey === BASE_RUNTIME_KEY) {
+      activateBaseRuntime();
+    }
+    hydrateYeaftStatusFromSession(session, { reason: 'base_runtime_mcp', emitEvent: true });
+    try { broadcastMcpUpdated({ reason: 'base-runtime-load' }); } catch { /* best-effort */ }
+  }
+
+  return { skillManager, mcpManager, mcpStatus, mcpConfig };
+}
+
+function scheduleBaseRuntimeLoad() {
+  if (!session) return null;
+  if (baseRuntimeLoadPromises.has(BASE_RUNTIME_KEY)) return baseRuntimeLoadPromises.get(BASE_RUNTIME_KEY);
+  const promise = new Promise(resolve => setTimeout(resolve, 0))
+    .then(() => loadBaseRuntime())
+    .catch((err) => {
+      console.warn('[Yeaft] async base runtime load failed:', err?.message || err);
+      return null;
+    })
+    .finally(() => { baseRuntimeLoadPromises.delete(BASE_RUNTIME_KEY); });
+  baseRuntimeLoadPromises.set(BASE_RUNTIME_KEY, promise);
+  return promise;
+}
+
 async function loadProjectRuntime(workDir) {
   if (!session) return null;
   const normalizedWorkDir = normalizeSessionWorkDir(workDir);
@@ -1967,9 +2064,6 @@ async function loadProjectRuntime(workDir) {
   const mcpConfig = loadMCPConfig(yeaftDir, undefined, normalizedWorkDir);
   const mcpManager = new MCPManager();
   let mcpStatus = { connected: [], failed: [] };
-  if (mcpConfig.servers.length > 0) {
-    mcpStatus = await mcpManager.connectAll(mcpConfig.servers);
-  }
   const runtime = {
     workDir: normalizedWorkDir,
     skillManager,
@@ -1985,10 +2079,41 @@ async function loadProjectRuntime(workDir) {
     },
   };
   projectRuntimes.set(key, runtime);
+  // Skill metadata is available after the filesystem scan; publish it before
+  // any MCP server startup so autocomplete does not wait on external processes.
   activateProjectRuntime(runtime);
+  if (mcpConfig.servers.length > 0) {
+    mcpStatus = await mcpManager.connectAll(mcpConfig.servers);
+    runtime.mcpStatus = mcpStatus;
+    runtime.status = {
+      ...runtime.status,
+      mcpServers: mcpStatus.connected,
+      mcpFailed: mcpStatus.failed,
+      mcpSkipped: mcpConfig.skipped || [],
+      tools: session.toolRegistry?.size || 0,
+    };
+    activateProjectRuntime(runtime);
+  }
   return runtime;
 }
 
+
+function scheduleProjectRuntimeLoad(workDir) {
+  const normalizedWorkDir = normalizeSessionWorkDir(workDir);
+  if (!normalizedWorkDir || !session) return null;
+  const key = projectRuntimeKey(normalizedWorkDir);
+  if (projectRuntimes.has(key)) return projectRuntimes.get(key);
+  if (projectRuntimeLoadPromises.has(key)) return projectRuntimeLoadPromises.get(key);
+  const promise = loadProjectRuntime(normalizedWorkDir)
+    .catch((err) => {
+      console.warn('[Yeaft] async project runtime load failed for %s: %s', normalizedWorkDir, err?.message || err);
+      return null;
+    })
+    .finally(() => { projectRuntimeLoadPromises.delete(key); });
+  projectRuntimeLoadPromises.set(key, promise);
+  return promise;
+}
+
 async function ensureProjectRuntimeForSessionMeta(sessionMeta) {
   const workDir = normalizeSessionWorkDir(sessionMeta?.workDir);
   if (!workDir) {
@@ -2004,6 +2129,24 @@ async function ensureProjectRuntimeForSessionMeta(sessionMeta) {
   }
 }
 
+function getProjectRuntimeForTurn(sessionMeta) {
+  const workDir = normalizeSessionWorkDir(sessionMeta?.workDir);
+  if (!workDir) {
+    activateBaseRuntime();
+    return null;
+  }
+  const cached = projectRuntimes.get(projectRuntimeKey(workDir)) || null;
+  if (cached) {
+    activateProjectRuntime(cached);
+    return cached;
+  }
+  scheduleProjectRuntimeLoad(workDir);
+  // Do not let a previous workDir's MCP tools leak into this turn while the
+  // requested project runtime is still loading in the background.
+  activateBaseRuntime();
+  return null;
+}
+
 function mergedStatusForProjectRuntime(runtime) {
   if (!session?.status || !runtime?.status) return session?.status || { skills: 0, mcpServers: [], tools: 0 };
   return {
@@ -3274,7 +3417,7 @@ function handleEngineEvent(event, hctx) {
  *   - No legacy "no-session" fallback paths — they were the source of the
  *     router_unavailable bug fixed in v0.1.671.
  */
-export async function handleYeaftSessionSend(msg) {
+async function runYeaftSessionSend(msg) {
   if (!msg || typeof msg !== 'object') return;
   const { text } = msg;
   // PR #721: image-only send is allowed — text may be empty when the
@@ -3343,10 +3486,10 @@ export async function handleYeaftSessionSend(msg) {
     return;
   }
 
-  // Open the session metadata first so a workDir-backed Session can load its
-  // project-tier skills and MCP before the first engine turn. The runtime boot
-  // below uses the same workDir; if metadata is missing we still boot the agent
-  // runtime for a useful error response, then fail on the session open check.
+  // Open the session metadata first so a workDir-backed Session can schedule
+  // project runtime loading without blocking the user-message hot path. If
+  // metadata is missing we still boot the agent runtime for a useful error
+  // response, then fail on the session open check.
   let sessionHandle = null;
   let sessionRoot = null;
   let sessionMetaForRuntime = null;
@@ -3374,7 +3517,7 @@ export async function handleYeaftSessionSend(msg) {
 
   const ensureSessionStart = perfNowMs();
   await ensureSessionLoaded({ sessionMeta: sessionMetaForRuntime, perfTraceId });
-  await ensureProjectRuntimeForSessionMeta(sessionMetaForRuntime);
+  scheduleProjectRuntimeLoad(sessionMetaForRuntime?.workDir);
   traceDuration('session_send.ensure_session_loaded', ensureSessionStart);
 
 
@@ -3740,8 +3883,8 @@ async function ensureSessionLoaded(opts = {}) {
     session = await loadSession({
       ...(yeaftDir && { dir: yeaftDir }),
       ...(normalizedWorkDir && { workDir: normalizedWorkDir }),
-      skipMCP: false,
-      skipSkills: false,
+      skipMCP: true,
+      skipSkills: true,
       serverMode: true,
     });
 
@@ -3772,7 +3915,11 @@ async function ensureSessionLoaded(opts = {}) {
     }
 
     ensureYeaftConversationId();
-    const bootProjectRuntime = normalizedWorkDir ? await ensureProjectRuntimeForSessionMeta({ workDir: normalizedWorkDir }) : null;
+    scheduleBaseRuntimeLoad();
+    const bootProjectRuntime = normalizedWorkDir ? projectRuntimes.get(projectRuntimeKey(normalizedWorkDir)) || null : null;
+    if (normalizedWorkDir && !bootProjectRuntime) {
+      scheduleProjectRuntimeLoad(normalizedWorkDir);
+    }
     const bootStatus = mergedStatusForProjectRuntime(bootProjectRuntime);
     hydrateYeaftStatusFromSession({ ...session, status: bootStatus }, { reason: 'session_ready', emitEvent: true });
     broadcastSkillSlashCommands(session, bootProjectRuntime ? [bootProjectRuntime.skillManager] : []);
@@ -4068,7 +4215,9 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         envelope: inboundEnvelope,
         threadId,
       });
-      const projectRuntime = await ensureProjectRuntimeForSessionMeta(sessionCoordinator?.group?.getMeta?.());
+      let turnSessionMeta = null;
+      try { turnSessionMeta = sessionCoordinator?.group?.getMeta?.() || null; } catch { turnSessionMeta = null; }
+      const projectRuntime = getProjectRuntimeForTurn(turnSessionMeta);
 
       vpEngine = getOrCreateVpEngine(sessionId, vpId, threadId);
       if (projectRuntime) {
@@ -5166,6 +5315,10 @@ export async function handleYeaftFetchDebugHistory(msg = {}) {
   });
 }
 
+export async function handleYeaftSessionSend(msg) {
+  return runYeaftSessionSend(msg);
+}
+
 export function handleYeaftSubAgentPrompt(msg) {
   const sessionId = typeof msg?.sessionId === 'string' ? msg.sessionId.trim() : '';
   const taskId = typeof msg?.taskId === 'string' ? msg.taskId.trim() : '';
@@ -5694,13 +5847,14 @@ export async function resetYeaftSession() {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     session = await loadSession({
       ...(yeaftDir && { dir: yeaftDir }),
-      skipMCP: false,
-      skipSkills: false,
+      skipMCP: true,
+      skipSkills: true,
       serverMode: true,
     });
     installYeaftRuntimeBridge(session);
 
     yeaftConversationId = `yeaft-${Date.now()}`;
+    scheduleBaseRuntimeLoad();
     hydrateYeaftStatusFromSession(session, { reason: 'reset', emitEvent: true });
     broadcastSkillSlashCommands(session);
 
@@ -5955,6 +6109,9 @@ export const __testHooks = {
   loadVisibleGroupHistoryPage,
   persistInboundMessageOnceByMsgId,
   buildPendingRescueEnvelope,
+  runYeaftSessionSendForTest(msg) {
+    return runYeaftSessionSend(msg);
+  },
   setSessionForTest(nextSession) {
     session = nextSession || null;
     sessionLoadPromise = null;
@@ -5965,6 +6122,9 @@ export const __testHooks = {
   preloadYeaftSkillSlashCommandsForTest() {
     return broadcastSkillSlashCommands(session);
   },
+  loadAndBroadcastYeaftSkillSlashCommandsForTest() {
+    return loadAndBroadcastYeaftSkillSlashCommands();
+  },
   resetAbortState() {
     turnAbortCtrls.clear();
     turnAbortMeta.clear();
@@ -5982,6 +6142,30 @@ export const __testHooks = {
   async loadProjectRuntime(workDir) {
     return loadProjectRuntime(workDir);
   },
+  seedSessionContext(sessionId, meta) {
+    const group = {
+      getMeta() { return structuredClone(meta); },
+      appendMessage(record) {
+        return {
+          ...record,
+          id: record?.id || `msg-${Date.now()}`,
+          ts: record?.ts || new Date().toISOString(),
+          role: record?.role || (record?.from === 'user' ? 'user' : 'assistant'),
+          meta: record?.meta || {},
+        };
+      },
+    };
+    const coord = createCoordinator(group, {
+      deliver: (vpId, envelope) => enqueueForVp(sessionId, vpId, envelope),
+    });
+    const entry = makeGroupContextStub();
+    entry.coord = coord;
+    entry.router = createRouter({ coordinator: coord });
+    entry.sessionHandle = group;
+    entry.historyHydrated = true;
+    sessionContexts.set(sessionId, entry);
+    return entry;
+  },
   seedProjectRuntime(workDir, runtime) {
     const normalizedWorkDir = normalizeSessionWorkDir(workDir);
     const seeded = {