@yeaft/webchat-agent 1.0.195 → 1.0.197

package/package.json

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

@@ -1743,7 +1743,7 @@ export class Engine {
    *   string-prompt shape (no regression for existing callers).
    * @yields {EngineEvent}
    */
-  async *query({ prompt, promptParts = null, messages = [], signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, sessionTopics = null, vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, askUser = null, threadId = MAIN_THREAD_ID, vpTurnId = null, drainPendingUserMessages = null, collabToolPolicy = null } = {}) {
+  async *query({ prompt, promptParts = null, messages = [], signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, sessionTopics = null, vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, askUser = null, threadId = MAIN_THREAD_ID, vpTurnId = null, drainPendingUserMessages = null, closePendingUserInput = null, collabToolPolicy = null } = {}) {
     if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
       yield {
         type: 'error',
@@ -1816,7 +1816,7 @@ export class Engine {
 
     try {
       this.#currentThreadId = threadId || MAIN_THREAD_ID;
-      yield* this.#runQuery({ prompt: effectivePrompt, promptParts: effectivePromptParts, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, sessionTopics, vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted, getCurrentTodos, setCurrentTodos, askUser, threadId: this.#currentThreadId, vpTurnId, drainPendingUserMessages, collabToolPolicy: effectiveCollabToolPolicy, explicitSkillName: parsedSkill.skillName });
+      yield* this.#runQuery({ prompt: effectivePrompt, promptParts: effectivePromptParts, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, sessionTopics, vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted, getCurrentTodos, setCurrentTodos, askUser, threadId: this.#currentThreadId, vpTurnId, drainPendingUserMessages, closePendingUserInput, collabToolPolicy: effectiveCollabToolPolicy, explicitSkillName: parsedSkill.skillName });
     } finally {
       if (signal) {
         try { signal.removeEventListener('abort', onExternalAbort); } catch { /* ignore */ }
@@ -1850,7 +1850,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, workCenterInstructions, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, askUser = null, threadId = MAIN_THREAD_ID, vpTurnId = null, drainPendingUserMessages = null, collabToolPolicy = null, explicitSkillName = null }) {
+  async *#runQuery({ prompt, promptParts = null, messages, signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, sessionTopics = null, vpPlan, sessionAnnouncement, workCenterInstructions, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, askUser = null, threadId = MAIN_THREAD_ID, vpTurnId = null, drainPendingUserMessages = null, closePendingUserInput = null, collabToolPolicy = null, explicitSkillName = null }) {
 
     const effectiveCollabToolPolicy = collabToolPolicy === COLLAB_TOOL_POLICY.SINGLE_VP || collabToolPolicy === COLLAB_TOOL_POLICY.MULTI_VP
       ? collabToolPolicy
@@ -3035,8 +3035,29 @@ export class Engine {
         // into the regular end_turn path.
       }
 
-      // If no tool calls, we're done
+      // If no tool calls, we're done. Callers with a durable append queue may
+      // atomically close it here. A failed close means input won the race with
+      // terminal completion, so drain it and keep this same Engine query alive.
       if (stopReason !== 'tool_use' || toolCalls.length === 0) {
+        if (typeof closePendingUserInput === 'function' && !closePendingUserInput()) {
+          const appendedBeforeClose = this.#drainPendingUserMessages(drainPendingUserMessages);
+          if (appendedBeforeClose.length === 0) {
+            throw new Error('Could not close pending user input for terminal completion');
+          }
+          for (const item of appendedBeforeClose) {
+            conversationMessages.push({ role: 'user', content: item.content });
+            yield {
+              type: 'user_append',
+              turnId: queryTurnId,
+              loopNumber: turnNumber,
+              threadId,
+              preview: String(item.preview || '').slice(0, 200),
+              internal: Boolean(item.internal),
+            };
+          }
+          yield { type: 'turn_end', turnNumber, stopReason: 'user_append_continue', threadId };
+          continue;
+        }
         if (pendingSubAgentNotifs.length > 0) {
           acknowledgePendingNotifications(notifScope, pendingSubAgentNotifs.map(n => n.id));
         }

package/yeaft/skills.js

@@ -458,6 +458,9 @@ export class SkillManager {
   /** @type {Map<string, { workspaceRoot: string, relativeRoot: string }>} */
   #secureWorkspaceByDir;
 
+  /** Hash of the effective loaded skill set, including prompt content. */
+  #snapshotHash = '';
+
   /**
    * @param {string | string[]} dirs — single directory (back-compat) or array of
    *   directories in priority order (lowest → highest). Falsy entries are
@@ -526,14 +529,16 @@ export class SkillManager {
    * tagged with `_tier` (from the constructor's `tierByDir` map, or the dir
    * basename as fallback) so consumers can show provenance.
    *
-   * @returns {{ loaded: number, errors: string[] }}
+   * @returns {{ loaded: number, errors: string[], changed: boolean }}
    */
   load() {
+    const previousHash = this.#snapshotHash;
     this.#skills.clear();
     const allErrors = [];
 
     if (this.#skillsDirs.length === 0) {
-      return { loaded: 0, errors: [] };
+      this.#snapshotHash = this.#computeSnapshotHash();
+      return { loaded: 0, errors: [], changed: this.#snapshotHash !== previousHash };
     }
 
     for (const dir of this.#skillsDirs) {
@@ -554,7 +559,33 @@ export class SkillManager {
       allErrors.push(...errors);
     }
 
-    return { loaded: this.#skills.size, errors: allErrors };
+    this.#snapshotHash = this.#computeSnapshotHash();
+    return {
+      loaded: this.#skills.size,
+      errors: allErrors,
+      changed: this.#snapshotHash !== previousHash,
+    };
+  }
+
+  #computeSnapshotHash() {
+    const records = [...this.#skills.values()]
+      .sort((a, b) => String(a.name).localeCompare(String(b.name)))
+      .map(skill => ({
+        name: skill.name || '',
+        description: skill.description || '',
+        trigger: skill.trigger || '',
+        mode: skill.mode || 'both',
+        category: skill.category || '',
+        platforms: skill.platforms || [],
+        keywords: skill.keywords || [],
+        content: skill.content || '',
+        source: skill._source || '',
+        path: skill._path || '',
+        tier: skill._tier || '',
+        references: skill._references || [],
+        templates: skill._templates || [],
+      }));
+    return JSON.stringify(records);
   }
 
   /**
@@ -746,6 +777,7 @@ export class SkillManager {
       _path: filePath,
       _tier: userTier,
     });
+    this.#snapshotHash = this.#computeSnapshotHash();
 
     return filename;
   }
@@ -783,6 +815,7 @@ export class SkillManager {
     }
 
     this.#skills.delete(name);
+    this.#snapshotHash = this.#computeSnapshotHash();
     return true;
   }
 

package/yeaft/web-bridge.js

@@ -80,6 +80,7 @@ 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__';
+const SKILL_RELOAD_INTERVAL_MS = 2_000;
 
 /**
  * Live AskUser requests. They are Session-scoped runtime state rather than a
@@ -591,6 +592,8 @@ const projectRuntimes = new Map();
 /** @type {Map<string, Promise<any>>} */
 const baseRuntimeLoadPromises = new Map();
 let activeRuntimeKey = BASE_RUNTIME_KEY;
+let skillReloadTimer = null;
+let skillReloadRunning = false;
 
 function replaceSessionMcpTools(mcpManager) {
   if (!session?.toolRegistry || typeof session.toolRegistry.replaceMcpTools !== 'function') {
@@ -651,6 +654,7 @@ function activateProjectRuntime(runtime) {
 }
 
 async function shutdownProjectRuntimes() {
+  stopSkillHotReload();
   const runtimes = Array.from(projectRuntimes.values());
   projectRuntimes.clear();
   projectRuntimeLoadPromises.clear();
@@ -936,7 +940,6 @@ 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();
 
@@ -2181,6 +2184,7 @@ export function buildMergedSkillSlashCommands(skillManagers = []) {
 function sendSkillSlashCommandsUpdate({ conversationId, slashCommands, slashCommandDescriptions }) {
   sendToServer({
     type: 'slash_commands_update',
+    commandSet: 'yeaft',
     agentId: ctx.AGENT_ID || ctx.agentId || null,
     conversationId,
     slashCommands,
@@ -2221,21 +2225,10 @@ export function preloadYeaftSkillSlashCommands() {
 
 function broadcastSkillSlashCommands(sessionLike, extraSkillManagers = []) {
   const managers = [sessionLike?.skillManager, ...extraSkillManagers].filter(Boolean);
-  const { commands, descriptions } = buildMergedSkillSlashCommands(managers);
-  const isYeaftSkillCommand = (cmd) => typeof cmd === 'string'
-    && (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(
-    Object.entries(ctx.slashCommandDescriptions || {})
-      .filter(([cmd]) => !isYeaftSkillCommand(cmd))
-  );
-  Object.assign(slashCommandDescriptions, descriptions);
-  ctx.slashCommands = slashCommands;
-  ctx.slashCommandDescriptions = slashCommandDescriptions;
-  lastYeaftGeneratedSlashCommands = new Set(commands);
+  const { commands: slashCommands, descriptions: slashCommandDescriptions } = buildMergedSkillSlashCommands(managers);
+  // Yeaft owns an isolated command catalogue. Reusing ctx's Claude Chat
+  // commands made unsupported entries such as /compact and /mcp appear in a
+  // Session even though the Yeaft engine only parses effort and Skill prefixes.
   lastYeaftSlashCommandSnapshot = { slashCommands, slashCommandDescriptions };
   sendSkillSlashCommandsUpdate({
     conversationId: yeaftConversationId || '__preload__',
@@ -2244,6 +2237,81 @@ function broadcastSkillSlashCommands(sessionLike, extraSkillManagers = []) {
   });
 }
 
+function skillManagersForHotReload() {
+  const managers = new Set();
+  if (session?.skillManager) managers.add(session.skillManager);
+  for (const runtime of projectRuntimes.values()) {
+    if (runtime?.skillManager) managers.add(runtime.skillManager);
+  }
+  return [...managers];
+}
+
+function reloadActiveSkills() {
+  if (skillReloadRunning) return { changed: false, loaded: 0, errors: [] };
+  skillReloadRunning = true;
+  try {
+    let changed = false;
+    let loaded = 0;
+    const errors = [];
+    const changedManagers = new Set();
+    const managers = skillManagersForHotReload();
+    for (const manager of managers) {
+      if (typeof manager?.load !== 'function') continue;
+      const result = manager.load();
+      if (result?.changed) {
+        changed = true;
+        changedManagers.add(manager);
+      }
+      loaded += Number(result?.loaded) || 0;
+      errors.push(...(result?.errors || []));
+    }
+    if (changed) {
+      if (session?.status && changedManagers.has(session.skillManager)) {
+        session.status.skills = session.skillManager?.size || 0;
+      }
+      for (const runtime of projectRuntimes.values()) {
+        if (runtime?.status && changedManagers.has(runtime.skillManager)) {
+          runtime.status.skills = runtime.skillManager?.size || 0;
+        }
+      }
+      if (activeRuntimeKey === BASE_RUNTIME_KEY) {
+        broadcastSkillSlashCommands(session);
+      } else {
+        const runtime = projectRuntimes.get(activeRuntimeKey);
+        broadcastSkillSlashCommands(session, runtime?.skillManager ? [runtime.skillManager] : []);
+      }
+      const activeRuntime = activeRuntimeKey === BASE_RUNTIME_KEY ? null : projectRuntimes.get(activeRuntimeKey);
+      const activeStatus = activeRuntime ? mergedStatusForProjectRuntime(activeRuntime) : session?.status;
+      hydrateYeaftStatusFromSession(
+        activeStatus && session ? { ...session, status: activeStatus } : session,
+        { reason: 'skills_hot_reload', emitEvent: true },
+      );
+    }
+    if (errors.length > 0) {
+      console.warn(`[Yeaft] skill hot reload completed with ${errors.length} error(s):`, errors.join('; '));
+    }
+    return { changed, loaded, errors };
+  } finally {
+    skillReloadRunning = false;
+  }
+}
+
+function startSkillHotReload() {
+  if (skillReloadTimer) return;
+  skillReloadTimer = setInterval(() => {
+    try { reloadActiveSkills(); }
+    catch (err) { console.warn('[Yeaft] skill hot reload failed:', err?.message || err); }
+  }, SKILL_RELOAD_INTERVAL_MS);
+  skillReloadTimer.unref?.();
+}
+
+function stopSkillHotReload() {
+  if (!skillReloadTimer) return;
+  clearInterval(skillReloadTimer);
+  skillReloadTimer = null;
+  skillReloadRunning = false;
+}
+
 async function loadBaseRuntime() {
   if (!session) return null;
   const yeaftDir = ctx.CONFIG?.yeaftDir || session.yeaftDir || DEFAULT_YEAFT_DIR;
@@ -2267,6 +2335,7 @@ async function loadBaseRuntime() {
   } else {
     broadcastSkillSlashCommands(session);
   }
+  startSkillHotReload();
   hydrateYeaftStatusFromSession(session, { reason: 'base_runtime_skills', emitEvent: true });
 
   if (mcpConfig.servers.length > 0) {
@@ -2341,6 +2410,7 @@ async function loadProjectRuntime(workDir) {
   // 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);
+  startSkillHotReload();
   if (mcpConfig.servers.length > 0) {
     mcpStatus = await mcpManager.connectAll(mcpConfig.servers);
     runtime.mcpStatus = mcpStatus;
@@ -6716,6 +6786,9 @@ export const __testHooks = {
   preloadYeaftSkillSlashCommandsForTest() {
     return broadcastSkillSlashCommands(session);
   },
+  reloadActiveSkillsForTest() {
+    return reloadActiveSkills();
+  },
   loadAndBroadcastYeaftSkillSlashCommandsForTest() {
     return loadAndBroadcastYeaftSkillSlashCommands();
   },

package/yeaft/work-center/controller.js

@@ -249,18 +249,35 @@ export class WorkflowController {
     const workItem = this.store.getWorkItem(id);
     if (!workItem) throw new Error(`WorkItem not found: ${id}`);
     if (['ready', 'running'].includes(workItem.status)) {
-      if (workItem.currentActionId !== input.actionId || workItem.revision !== input.revision) {
-        throw new Error('Action changed before input was applied; refresh and try again');
+      const activeAction = this.store.getAction(input.actionId);
+      if (activeAction?.status === 'running' && addedAttachmentCount > 0) {
+        throw new Error('Files cannot be added while an Action is running; send text now or wait for the next Action boundary');
       }
-      return this.guide(id, {
-        guidance: text,
+      const inputSummary = text || `The user added ${addedAttachmentCount} attachment(s) as additional context for this Action.`;
+      return this.store.addActionInput(id, inputSummary, {
         actionId: input.actionId,
         generation: input.generation,
         revision: input.revision,
-        addedAttachmentCount,
-        addedAttachments: input.addedAttachments,
-        attachments: input.attachments,
-      });
+      }, (current, action) => {
+        const context = [...(action.context || []), {
+          type: 'input', role: 'user', summary: inputSummary, evidence: [],
+        }];
+        const step = {
+          type: action.type,
+          stageId: action.stageId || action.type,
+          assignmentPolicy: action.assignmentPolicy,
+          modelPolicy: action.modelPolicy,
+          requiredRole: action.requiredRole,
+          dependsOnStageIds: action.dependsOnStageIds,
+          workspaceMode: action.workspaceMode,
+          changesRequestedStageId: action.changesRequestedStageId,
+          brief: action.brief,
+        };
+        return {
+          context,
+          instruction: actionInstruction(step, current, context, renderSessionContextSnapshot(current.sessionContext)),
+        };
+      }, input.attachments, input.addedAttachments);
     }
     if (!['waiting', 'needs_attention'].includes(workItem.status)) {
       throw new Error(`WorkItem in ${workItem.status} cannot accept Action input`);
@@ -341,6 +358,13 @@ export class WorkflowController {
     const activeAction = activeRun ? this.store.getAction(activeRun.actionId) : null;
     if (!activeRun || !activeAction) throw new Error('Run is stale, cancelled, or already finished');
     const activeWorkItem = this.store.getWorkItem(activeRun.workItemId);
+    if (activeRun.acceptingInput !== false
+        && !this.store.closeRunInput(runId, ownerBootId, leaseEpoch)) {
+      if (!this.store.isActiveRun(runId, ownerBootId, leaseEpoch)) {
+        throw new Error('Run is stale, cancelled, expired, or already finished');
+      }
+      throw new Error('Run has unconsumed Action input and cannot finish yet');
+    }
     const result = normalizeTerminalResult(rawResult, activeAction);
     validateCompletedResult(result, activeAction, activeWorkItem);
     let validatedGeneratedWorkflow = null;

package/yeaft/work-center/projection.js

@@ -113,12 +113,30 @@ function runResponseMessage(run) {
   });
 }
 
+function loopOutputMessages(action, events) {
+  return (Array.isArray(events) ? events : [])
+    .filter(event => event?.actionId === action?.id && event.type === 'run.loop_output')
+    .map(event => normalizeProjectedMessage({
+      id: `event:${event.id}`,
+      role: 'assistant',
+      kind: 'response',
+      status: 'completed',
+      text: event.data?.response || '',
+      createdAt: event.createdAt,
+    }))
+    .filter(Boolean);
+}
+
 function actionMessages(action, runs, events) {
   const matchingRuns = Array.isArray(runs)
     ? runs.filter(run => run?.actionId === action?.id)
     : [];
-  return [...actionInputMessages(action, events), ...matchingRuns
+  const runsWithLoopOutput = new Set((Array.isArray(events) ? events : [])
+    .filter(event => event?.actionId === action?.id && event.type === 'run.loop_output' && event.runId)
+    .map(event => event.runId));
+  return [...actionInputMessages(action, events), ...loopOutputMessages(action, events), ...matchingRuns
     .sort((left, right) => count(left.startedAt) - count(right.startedAt))
+    .filter(run => !runsWithLoopOutput.has(run.id))
     .map(run => runResponseMessage(run))
     .filter(Boolean)]
     .sort((left, right) => left.createdAt - right.createdAt
@@ -294,6 +312,18 @@ function projectAction(action, runs, events, includeBody = true) {
         key,
         truncateUtf8(value, includeBody ? MAX_CURRENT_BRIEF_BYTES : MAX_HISTORICAL_BRIEF_CHARS),
       ]));
+  const matchingRuns = Array.isArray(runs) ? runs.filter(run => run?.actionId === action.id) : [];
+  const latestRun = [...matchingRuns].sort((left, right) => (
+    count(right.startedAt) - count(left.startedAt) || count(right.progressRevision) - count(left.progressRevision)
+  ))[0];
+  const assignedVp = latestRun?.vpSnapshot ? {
+    id: latestRun.vpSnapshot.id || null,
+    name: latestRun.vpSnapshot.name || latestRun.vpSnapshot.id || null,
+  } : null;
+  const contentSummary = truncateUtf8(
+    execution.response || latestRun?.summary || brief?.objective || brief?.expectedOutcome || '',
+    MAX_HISTORICAL_BRIEF_CHARS,
+  );
   return {
     id: action.id,
     sequence: action.sequence,
@@ -307,6 +337,8 @@ function projectAction(action, runs, events, includeBody = true) {
     requiredRole: action.requiredRole || '',
     brief: projectedBrief,
     status: action.status,
+    assignedVp,
+    contentSummary,
     executionStats: executionStats(execution),
     loopCount: execution.loopCount,
     toolCount: execution.toolCount,
@@ -366,6 +398,8 @@ function projectActionStats(detail) {
     const stats = {
       id: projected.id,
       status: projected.status,
+      assignedVp: projected.assignedVp,
+      contentSummary: projected.contentSummary,
       executionStats: projected.executionStats,
       loopCount: projected.loopCount,
       toolCount: projected.toolCount,

package/yeaft/work-center/runner.js

@@ -783,7 +783,7 @@ export class WorkItemRunner {
     }
   }
 
-  async run({ workItem, action, run, signal, ownerBootId, onProgress, registerProgressReader }) {
+  async run({ workItem, action, run, signal, ownerBootId, onProgress, registerProgressReader, registerInputWake }) {
     const runtime = await this.runtimeProvider();
     const currentSettings = workItem?.workflowSnapshot?.planningMode === 'ai' && this.policyProvider
       ? await this.policyProvider()
@@ -840,6 +840,7 @@ export class WorkItemRunner {
       reuseMemory: workItem.reuseMemory,
     });
     const attachmentContext = buildWorkItemAttachmentContext(workItem, { root: this.attachmentRoot });
+    const attachmentFileById = new Map(attachmentContext.files.map(file => [file.id, file]));
     const fixedPromptSuffix = `${resumeBlock}${attachmentContext.promptBlock}${completionContract(executionAction, workItem)}`;
     const reservedPromptBytes = Buffer.byteLength(fixedPromptSuffix, 'utf8');
     const mainline = v2Execution
@@ -992,6 +993,29 @@ export class WorkItemRunner {
       taskManager: null,
       vpId: vp.id,
     });
+    if (typeof registerInputWake === 'function') {
+      registerInputWake(() => engine.wakeForPendingUserMessage?.());
+    }
+    const drainPendingUserMessages = () => {
+      const pending = this.store.listPendingActionInputs?.(
+        action.id, run.id, ownerBootId, run.leaseEpoch,
+      ) || [];
+      const accepted = [];
+      for (const item of pending) {
+        const attachmentLines = item.attachments.map(attachment => {
+          const file = attachmentFileById.get(attachment.id);
+          return file ? `- ${attachment.name}: ${file.ref}` : `- ${attachment.name}`;
+        });
+        const content = [item.text, attachmentLines.length > 0
+          ? `Additional WorkItem attachments:\n${attachmentLines.join('\n')}` : '']
+          .filter(Boolean).join('\n\n');
+        if (!content || !this.store.acknowledgeActionInput?.(
+          item.id, action.id, run.id, ownerBootId, run.leaseEpoch,
+        )) continue;
+        accepted.push({ content, preview: item.text || '[attachments]' });
+      }
+      return accepted;
+    };
     try {
       const prompt = v2Execution
         ? `${renderMainlineContextSnapshot(mainline.contextSnapshot)}${fixedPromptSuffix}`
@@ -1015,9 +1039,19 @@ export class WorkItemRunner {
         workCenterInstructions: workItem?.workflowSnapshot?.globalInstructions || '',
         workDir,
         userAlreadyPersisted: true,
+        drainPendingUserMessages,
+        closePendingUserInput: () => this.store.closeRunInput(
+          run.id, ownerBootId, run.leaseEpoch,
+        ),
         collabToolPolicy: 'single-vp',
       })) {
-        if (event?.type === 'loop') loopCount += 1;
+        if (event?.type === 'loop') {
+          loopCount += 1;
+          this.store.appendRunLoop?.(run.id, ownerBootId, run.leaseEpoch, {
+            ...event,
+            response: publicWorkItemResponse(event.response),
+          });
+        }
         else if (event?.type === 'tool_start') toolInputs.set(event.id, event.input);
         else if (event?.type === 'tool_end') {
           toolCount += 1;

package/yeaft/work-center/service.js

@@ -93,7 +93,7 @@ export class WorkCenterService {
       case 'get_action_messages': {
         const detail = this.#requiredItem(payload.id);
         const action = this.#requiredAction(detail, payload.actionId);
-        return projectActionMessagePage(action, detail.runs, detail.events, {
+        return projectActionMessagePage(action, detail.runs, this.store.listActionEvents(action.id), {
           cursor: payload.cursor,
           limit: payload.limit,
         });
@@ -237,6 +237,7 @@ export class WorkCenterService {
           throw error;
         }
         this.watcher.abortInvalidWorkItemRuns(id);
+        this.watcher.notifyActionInput(id, payload.actionId);
         this.#emit({ type: 'action.input_added', workItem: detail });
         return detail;
       }