@yeaft/webchat-agent 1.0.37 → 1.0.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.37",
+  "version": "1.0.39",
   "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

@@ -95,6 +95,36 @@ const RETRY_DEFAULTS = Object.freeze({
   jitterRatio: 0.25,
 });
 
+const EXPLICIT_SKILL_COMMAND_RE = /^\/skill:([^\s]+)(\s+|$)/;
+
+function parseExplicitSkillCommand(prompt) {
+  if (typeof prompt !== 'string') {
+    return { skillName: null, cleanedPrompt: prompt };
+  }
+  const match = prompt.match(EXPLICIT_SKILL_COMMAND_RE);
+  if (!match) {
+    return { skillName: null, cleanedPrompt: prompt };
+  }
+  return {
+    skillName: match[1],
+    cleanedPrompt: prompt.slice(match[0].length),
+  };
+}
+
+function stripLeadingSkillCommandFromPromptParts(promptParts) {
+  if (!Array.isArray(promptParts) || promptParts.length === 0) return promptParts;
+  let stripped = false;
+  return promptParts.map(part => {
+    if (stripped || !part || part.type !== 'text' || typeof part.text !== 'string') {
+      return part;
+    }
+    const parsed = parseExplicitSkillCommand(part.text);
+    if (!parsed.skillName) return part;
+    stripped = true;
+    return { ...part, text: parsed.cleanedPrompt };
+  });
+}
+
 function resolveRetryPolicy(config) {
   const raw = config?.llmRetry || {};
   const num = (v, d) => (Number.isFinite(v) && v >= 0 ? v : d);
@@ -932,13 +962,21 @@ export class Engine {
    * @param {string} [args.sessionAnnouncement]
    * @param {string} [args.projectDoc] — resolved CLAUDE.md / AGENTS.md text (already truncated)
    * @param {object} [args.taskCtx] — legacy task-context sub-block (optional)
+   * @param {string} [args.explicitSkillName] — leading /skill:<name> command, if present
    * @returns {string}
    */
-  #buildSystemPrompt({ prompt, memoryInjection, vpPersona, activeScope, sessionAnnouncement, projectDoc, taskCtx, activeTasks } = {}) {
-    // Get relevant skill content if SkillManager is wired
+  #buildSystemPrompt({ prompt, memoryInjection, vpPersona, activeScope, sessionAnnouncement, projectDoc, taskCtx, activeTasks, explicitSkillName } = {}) {
+    // Get relevant skill content if SkillManager is wired. A leading
+    // /skill:<name> is explicit, not relevance matching: load that skill by
+    // name or inject a visible prompt warning when the command is unknown.
     let skillContent = '';
-    if (this.#skillManager && prompt) {
-      skillContent = this.#skillManager.getRelevantPromptContent(prompt);
+    if (this.#skillManager) {
+      if (explicitSkillName) {
+        skillContent = this.#skillManager.getPromptContent(explicitSkillName)
+          || `## Skill command error\n\nRequested skill "${explicitSkillName}" was not found. Continue without that skill and tell the user it is unavailable.`;
+      } else if (prompt) {
+        skillContent = this.#skillManager.getRelevantPromptContent(prompt);
+      }
     }
 
     // Get tool names from the appropriate source
@@ -1583,7 +1621,11 @@ 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 effectivePrompt = parsed.cleanedPrompt;
+    const parsedSkill = parseExplicitSkillCommand(parsed.cleanedPrompt);
+    const effectivePrompt = parsedSkill.cleanedPrompt;
+    const effectivePromptParts = parsedSkill.skillName
+      ? stripLeadingSkillCommandFromPromptParts(promptParts)
+      : promptParts;
     const configuredEffort = normalizeEffort(this.#config?.modelEffort);
     const effectiveUserEffort = normalizeEffort(userEffort) || parsed.effort || configuredEffort || null;
     const effectiveCollabToolPolicy = collabToolPolicy === COLLAB_TOOL_POLICY.SINGLE_VP || collabToolPolicy === COLLAB_TOOL_POLICY.MULTI_VP
@@ -1623,7 +1665,7 @@ export class Engine {
 
     try {
       this.#currentThreadId = threadId || MAIN_THREAD_ID;
-      yield* this.#runQuery({ prompt: effectivePrompt, promptParts, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, sessionTopics, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted, getCurrentTodos, setCurrentTodos, threadId: this.#currentThreadId, drainPendingUserMessages, collabToolPolicy: effectiveCollabToolPolicy });
+      yield* this.#runQuery({ prompt: effectivePrompt, promptParts: effectivePromptParts, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, sessionTopics, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted, getCurrentTodos, setCurrentTodos, threadId: this.#currentThreadId, drainPendingUserMessages, collabToolPolicy: effectiveCollabToolPolicy, explicitSkillName: parsedSkill.skillName });
     } finally {
       if (signal) {
         try { signal.removeEventListener('abort', onExternalAbort); } catch { /* ignore */ }
@@ -1667,7 +1709,7 @@ export class Engine {
    * in a try/finally without indenting the whole loop.
    * @private
    */
-  async *#runQuery({ prompt, promptParts = null, messages, signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, sessionTopics = null, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, threadId = MAIN_THREAD_ID, drainPendingUserMessages = null, collabToolPolicy = null }) {
+  async *#runQuery({ prompt, promptParts = null, messages, signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, sessionTopics = null, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, threadId = MAIN_THREAD_ID, drainPendingUserMessages = null, collabToolPolicy = null, explicitSkillName = null }) {
 
     const effectiveCollabToolPolicy = collabToolPolicy === COLLAB_TOOL_POLICY.SINGLE_VP || collabToolPolicy === COLLAB_TOOL_POLICY.MULTI_VP
       ? collabToolPolicy
@@ -1783,6 +1825,7 @@ export class Engine {
       sessionAnnouncement,
       projectDoc,
       activeTasks,
+      explicitSkillName,
     });
 
     // ─── HARD INVARIANT: Compact ≠ Dream (read DESIGN-COMPACT-VS-DREAM.md) ─

package/yeaft/router/continuity.js

@@ -85,10 +85,10 @@ export function extractPriorPlan(messages, vpId) {
 }
 
 /**
- * Return a copy of the messages array with `_meta` stripped from every
- * message. The serialisers (anthropic/openai-responses) read this; it is
- * NEVER part of the wire payload. Cheap because we only shallow-clone the
- * messages that actually have `_meta`.
+ * Return a copy of the messages array with engine-private metadata stripped
+ * from every message. The serialisers (anthropic/openai-responses) read this;
+ * these fields are NEVER part of the wire payload. Cheap because we only
+ * shallow-clone the messages that actually have private fields.
  *
  * @param {object[]} messages
  * @returns {object[]}
@@ -97,9 +97,10 @@ export function stripMetaForWire(messages) {
   if (!Array.isArray(messages)) return messages;
   let mutated = false;
   const out = messages.map(m => {
-    if (m && typeof m === 'object' && '_meta' in m) {
+    if (m && typeof m === 'object'
+        && ('_meta' in m || '_runtimeTurnId' in m || '_partialTurn' in m)) {
       mutated = true;
-      const { _meta, ...rest } = m;
+      const { _meta, _runtimeTurnId, _partialTurn, ...rest } = m;
       return rest;
     }
     return m;

package/yeaft/web-bridge.js

@@ -73,6 +73,8 @@ import { buildMcpFlattenedTools } from './tools/mcp-tools.js';
 import { getAgentRegistry, agentBelongsToScope } from './tools/agent.js';
 import { isPromptableAgentStatus } from './sub-agent/status.js';
 
+const SKILL_COMMAND_PREFIX = 'skill:';
+
 /** @type {import('./session.js').Session | null} */
 let session = null;
 
@@ -1690,6 +1692,37 @@ function sendSessionOutputFrame(data, { sessionId, chatId, vpId, turnId, threadI
   });
 }
 
+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 = `${SKILL_COMMAND_PREFIX}${skill.name}`;
+    commands.push(commandName);
+    descriptions[commandName] = skill.description || skill.trigger || 'Load Yeaft skill';
+  }
+  commands.sort((a, b) => a.localeCompare(b));
+  return { commands, descriptions };
+}
+
+function broadcastSkillSlashCommands(sessionLike) {
+  const { commands, descriptions } = buildSkillSlashCommands(sessionLike?.skillManager);
+  const slashCommands = [...new Set([...(ctx.slashCommands || []), ...commands])];
+  const slashCommandDescriptions = {
+    ...(ctx.slashCommandDescriptions || {}),
+    ...descriptions,
+  };
+  ctx.slashCommands = slashCommands;
+  ctx.slashCommandDescriptions = slashCommandDescriptions;
+  sendToServer({
+    type: 'slash_commands_update',
+    conversationId: '__preload__',
+    slashCommands,
+    slashCommandDescriptions,
+  });
+}
+
 /** Send a Yeaft Session metadata event over the legacy-compatible envelope. */
 function sendSessionEvent(event, { sessionId, chatId, vpId, turnId, threadId } = {}) {
   sendToServer({
@@ -2577,6 +2610,23 @@ function handleEngineEvent(event, hctx) {
           isError: !!event.isError,
         });
       }
+      if (hctx.sessionId && hctx.turnId && !hctx.skipPartialHistory) {
+        const appendedPrompts = Array.isArray(hctx.appendedUserPrompts) ? hctx.appendedUserPrompts : [];
+        const prompts = hctx.includeInitialPrompt && typeof hctx.prompt === 'string'
+          ? [hctx.prompt, ...appendedPrompts]
+          : appendedPrompts;
+        appendTurnToSessionHistory(
+          hctx.sessionId,
+          hctx.threadId || event.threadId || 'main',
+          hctx.vpId,
+          prompts,
+          hctx.assistantTextParts || [],
+          hctx.toolCallsAccum || [],
+          hctx.toolResultsAccum || [],
+          hctx.thinkingBlocksAccum || [],
+          { turnId: hctx.turnId, partial: true },
+        );
+      }
       sendSessionOutputFrame({
         type: 'user',
         tool_use_result: [{
@@ -3358,6 +3408,7 @@ async function ensureSessionLoaded() {
 
   yeaftConversationId = `yeaft-${Date.now()}`;
   hydrateYeaftStatusFromSession(session, { reason: 'session_ready', emitEvent: true });
+  broadcastSkillSlashCommands(session);
 
   // Per-group history is hydrated lazily on first `getOrCreateSessionHistory`
   // — there's no global "all conversations" tape any more.
@@ -3598,6 +3649,9 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
       vpEngine = getOrCreateVpEngine(sessionId, vpId, threadId);
       if (thread) thread.engine = vpEngine;
 
+      const inboundInjectedBy = inboundEnvelope?.msg?.meta?.injectedBy;
+      const inboundIsInternal = inboundInjectedBy === 'route_forward' || inboundInjectedBy === 'task_result';
+
       handlerCtx = {
         assistantTextParts,
         toolCallsAccum,
@@ -3610,6 +3664,9 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         threadId,
         thread,
         appendedUserPrompts,
+        prompt,
+        includeInitialPrompt: !inboundIsInternal,
+        skipPartialHistory: false,
         markTurnEnd,
       };
       // Always trim the snapshot before passing to engine.query. This is
@@ -3651,10 +3708,8 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
       // the source VP's tool action. Do not append it as a visible prompt for
       // the target VP turn; otherwise UI replay can show a trailing handoff
       // block after the target response.
-      const inboundInjectedBy = inboundEnvelope?.msg?.meta?.injectedBy;
-      const inboundIsInternal = inboundInjectedBy === 'route_forward' || inboundInjectedBy === 'task_result';
       const visiblePrompts = inboundIsInternal ? appendedUserPrompts : [prompt, ...appendedUserPrompts];
-      appendTurnToSessionHistory(sessionId, threadId, vpId, visiblePrompts, assistantTextParts, toolCallsAccum, toolResultsAccum, thinkingBlocksAccum);
+      appendTurnToSessionHistory(sessionId, threadId, vpId, visiblePrompts, assistantTextParts, toolCallsAccum, toolResultsAccum, thinkingBlocksAccum, { turnId });
 
       sendSessionOutputFrame({
         type: 'assistant',
@@ -3766,8 +3821,9 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
 }
 
 /**
- * Atomically append a completed VP-turn's messages to the GROUP'S
- * conversation history. Called once at turn end (not during streaming).
+ * Atomically append a completed or partial VP-turn's messages to the GROUP'S
+ * conversation history. Partial writes are replaced by the final write when
+ * the same runtime turn completes.
  *
  * Note: this does NOT see the engine's collapsed form — it appends the
  * raw user prompt(s) + the per-VP assistant text + tool results. Related
@@ -3779,15 +3835,20 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
  * a session, this in-memory tape carries the un-collapsed form — which
  * is fine because each VP turn's `engine.query` re-collapses on the fly.
  */
-function appendTurnToSessionHistory(sessionId, threadId, vpId, prompts, assistantTextParts, toolCallsAccum, toolResultsAccum, thinkingBlocksAccum) {
-  if (!sessionId) return;
-  const history = getOrCreateSessionHistory(sessionId);
+function buildTurnHistoryEntries(threadId, vpId, prompts, assistantTextParts, toolCallsAccum, toolResultsAccum, thinkingBlocksAccum, opts = {}) {
+  const entries = [];
+  const runtimeTurnId = typeof opts.turnId === 'string' && opts.turnId ? opts.turnId : null;
+  const markEntry = (entry) => {
+    if (runtimeTurnId) entry._runtimeTurnId = runtimeTurnId;
+    if (opts.partial) entry._partialTurn = true;
+    return entry;
+  };
   const promptList = Array.isArray(prompts) ? prompts : [prompts];
   for (const prompt of promptList) {
     if (typeof prompt === 'string' && prompt.trim()) {
       // user rows intentionally carry NO speakerVpId — every VP in the
       // session should see the prompt in their history.
-      history.push({ role: 'user', content: prompt, threadId: threadId || 'main' });
+      entries.push(markEntry({ role: 'user', content: prompt, threadId: threadId || 'main' }));
     }
   }
 
@@ -3821,7 +3882,7 @@ function appendTurnToSessionHistory(sessionId, threadId, vpId, prompts, assistan
           : { thinking: tb.thinking, signature: tb.signature }
       ));
     }
-    history.push(assistantMsg);
+    entries.push(markEntry(assistantMsg));
 
     for (const tr of toolResultsAccum) {
       const toolMsg = {
@@ -3832,8 +3893,30 @@ function appendTurnToSessionHistory(sessionId, threadId, vpId, prompts, assistan
         threadId: threadId || 'main',
       };
       if (vpId) toolMsg.speakerVpId = vpId;
-      history.push(toolMsg);
+      entries.push(markEntry(toolMsg));
+    }
+  }
+  return entries;
+}
+
+function appendTurnToSessionHistory(sessionId, threadId, vpId, prompts, assistantTextParts, toolCallsAccum, toolResultsAccum, thinkingBlocksAccum, opts = {}) {
+  if (!sessionId) return;
+  const history = getOrCreateSessionHistory(sessionId);
+  const nextEntries = buildTurnHistoryEntries(threadId, vpId, prompts, assistantTextParts, toolCallsAccum, toolResultsAccum, thinkingBlocksAccum, opts);
+  if (nextEntries.length === 0) return;
+  const runtimeTurnId = typeof opts.turnId === 'string' && opts.turnId ? opts.turnId : null;
+  if (runtimeTurnId) {
+    let insertAt = history.length;
+    for (let i = history.length - 1; i >= 0; i--) {
+      if (history[i]?._runtimeTurnId === runtimeTurnId) {
+        insertAt = i;
+        history.splice(i, 1);
+      }
     }
+    if (insertAt > history.length) insertAt = history.length;
+    history.splice(insertAt, 0, ...nextEntries);
+  } else {
+    history.push(...nextEntries);
   }
 }