@yeaft/webchat-agent 1.0.194 → 1.0.196

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.194",
+  "version": "1.0.196",
   "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/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;
       }

package/yeaft/work-center/store.js

@@ -5,7 +5,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { normalizeEvidence } from './evidence.js';
 import { normalizeActionCheckpoint } from './action-checkpoint.js';
 
-const SCHEMA_VERSION = 14;
+const SCHEMA_VERSION = 15;
 const OPEN_ACTION_STATUSES = "'ready','running','waiting'";
 const MAX_REUSABLE_CONTEXT_ITEMS = 12;
 const MAX_RUN_RESPONSE_CHARS = 65_536;
@@ -195,6 +195,7 @@ function mapRun(row) {
     totalTokens: Math.max(0, Number(row.total_tokens) || 0),
     progressRevision: Math.max(0, Number(row.progress_revision) || 0),
     checkpoint: normalizeActionCheckpoint(parseJson(row.checkpoint, null)),
+    acceptingInput: row.accepting_input !== 0,
   };
 }
 
@@ -350,7 +351,8 @@ export class WorkItemStore {
         cache_write_tokens INTEGER NOT NULL DEFAULT 0,
         total_tokens INTEGER NOT NULL DEFAULT 0,
         progress_revision INTEGER NOT NULL DEFAULT 0,
-        checkpoint TEXT
+        checkpoint TEXT,
+        accepting_input INTEGER NOT NULL DEFAULT 1
       );
       CREATE TABLE IF NOT EXISTS events (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -361,6 +363,15 @@ export class WorkItemStore {
         data TEXT NOT NULL,
         created_at INTEGER NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS pending_action_inputs (
+        event_id INTEGER PRIMARY KEY REFERENCES events(id) ON DELETE CASCADE,
+        work_item_id TEXT NOT NULL REFERENCES work_items(id) ON DELETE CASCADE,
+        action_id TEXT NOT NULL REFERENCES actions(id) ON DELETE CASCADE,
+        run_id TEXT,
+        text TEXT NOT NULL,
+        attachments TEXT NOT NULL DEFAULT '[]',
+        consumed_at INTEGER
+      );
       CREATE TABLE IF NOT EXISTS plan_audits (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         work_item_id TEXT NOT NULL REFERENCES work_items(id) ON DELETE CASCADE,
@@ -391,6 +402,8 @@ export class WorkItemStore {
       CREATE INDEX IF NOT EXISTS idx_actions_ready ON actions(status, updated_at, sequence);
       CREATE INDEX IF NOT EXISTS idx_runs_active ON runs(status, expires_at);
       CREATE INDEX IF NOT EXISTS idx_events_work_item ON events(work_item_id, id);
+      CREATE INDEX IF NOT EXISTS idx_pending_action_inputs_action
+        ON pending_action_inputs(action_id, consumed_at, event_id);
     `);
 
     // The feature shipped first as an unmerged PR, but keep the store tolerant
@@ -459,6 +472,9 @@ export class WorkItemStore {
     if (!hasColumn(this.db, 'runs', 'checkpoint')) {
       this.db.exec('ALTER TABLE runs ADD COLUMN checkpoint TEXT');
     }
+    if (!hasColumn(this.db, 'runs', 'accepting_input')) {
+      this.db.exec('ALTER TABLE runs ADD COLUMN accepting_input INTEGER NOT NULL DEFAULT 1');
+    }
     if (!hasColumn(this.db, 'work_items', 'workflow_snapshot')) {
       this.db.exec('ALTER TABLE work_items ADD COLUMN workflow_snapshot TEXT');
     }
@@ -535,6 +551,110 @@ export class WorkItemStore {
     return Number(result.lastInsertRowid);
   }
 
+  addActionInput(id, input, expected, updateReadyAction, attachments = null, addedAttachments = []) {
+    return withTransaction(this.db, () => {
+      const workItem = this.getWorkItem(id);
+      if (!workItem) return null;
+      if (!['ready', 'running'].includes(workItem.status)) {
+        throw new Error(`WorkItem in ${workItem.status} cannot accept Action input`);
+      }
+      const action = this.getAction(expected.actionId);
+      const graphMode = workItem.workflowSnapshot?.executionMode === 'graph';
+      const actionMatches = graphMode
+        ? action?.workItemId === id && ['ready', 'running'].includes(action.status)
+        : action?.id === workItem.currentActionId && ['ready', 'running'].includes(action?.status);
+      const activeRun = action?.currentRunId ? this.getRun(action.currentRunId) : null;
+      if (!actionMatches || activeRun?.acceptingInput === false || workItem.revision !== expected.revision) {
+        throw new Error('Action changed before input was applied; refresh and try again');
+      }
+      const now = this.now();
+      const revision = workItem.revision + 1;
+      const updated = updateReadyAction(workItem, action);
+      const changedAction = this.db.prepare(`UPDATE actions SET context = ?, instruction = ?, updated_at = ?
+        WHERE id = ? AND status = ? AND current_run_id IS ?`).run(
+        stringify(updated.context || []),
+        updated.instruction || action.instruction,
+        now,
+        action.id,
+        action.status,
+        action.currentRunId,
+      );
+      if (Number(changedAction.changes) !== 1) {
+        throw new Error('Action changed before input was applied; refresh and try again');
+      }
+      this.db.prepare(`UPDATE work_items SET attachments = ?, revision = ?, updated_at = ?
+        WHERE id = ?`).run(
+        stringify(Array.isArray(attachments) ? attachments : workItem.attachments),
+        revision,
+        now,
+        id,
+      );
+      const projectedAttachments = (Array.isArray(addedAttachments) ? addedAttachments : []).map(attachment => ({
+        id: attachment.id,
+        name: attachment.name,
+        mimeType: attachment.mimeType,
+        size: Math.max(0, Number(attachment.size) || 0),
+        isImage: attachment.isImage === true,
+      }));
+      const eventId = this.appendEvent(id, 'action.input_added', {
+        text: input,
+        attachments: projectedAttachments,
+      }, { actionId: action.id, runId: action.currentRunId });
+      if (action.status === 'running') {
+        this.db.prepare(`INSERT INTO pending_action_inputs
+          (event_id, work_item_id, action_id, run_id, text, attachments, consumed_at)
+          VALUES (?, ?, ?, ?, ?, ?, NULL)`).run(
+          eventId,
+          id,
+          action.id,
+          action.currentRunId,
+          input,
+          stringify(projectedAttachments),
+        );
+      }
+      return this.getWorkItemDetail(id);
+    });
+  }
+
+  listPendingActionInputs(actionId, runId, ownerBootId, leaseEpoch) {
+    const active = this.#activeRunRow(runId, ownerBootId, leaseEpoch, true);
+    if (!active || active.action_id !== actionId) return [];
+    return this.db.prepare(`SELECT * FROM pending_action_inputs
+      WHERE action_id = ? AND consumed_at IS NULL ORDER BY event_id`).all(actionId).map(row => ({
+      id: String(row.event_id),
+      text: row.text || '',
+      attachments: parseJson(row.attachments, []),
+    }));
+  }
+
+  acknowledgeActionInput(eventId, actionId, runId, ownerBootId, leaseEpoch) {
+    return withTransaction(this.db, () => {
+      const active = this.#activeRunRow(runId, ownerBootId, leaseEpoch, true);
+      if (!active || active.action_id !== actionId) return false;
+      const result = this.db.prepare(`UPDATE pending_action_inputs SET consumed_at = ?
+        WHERE event_id = ? AND action_id = ? AND consumed_at IS NULL`).run(
+        this.now(), Number(eventId), actionId,
+      );
+      return Number(result.changes) === 1;
+    });
+  }
+
+  appendRunLoop(runId, ownerBootId, leaseEpoch, loop = {}) {
+    return withTransaction(this.db, () => {
+      const active = this.#activeRunRow(runId, ownerBootId, leaseEpoch, true);
+      if (!active) return null;
+      const response = normalizeRunResponse(loop.response).trim();
+      if (response) {
+        this.appendEvent(active.work_item_id, 'run.loop_output', {
+          loopNumber: Math.max(0, Number(loop.loopNumber) || 0),
+          response,
+          stopReason: loop.stopReason || null,
+        }, { actionId: active.action_id, runId });
+      }
+      return this.getWorkItemDetail(active.work_item_id);
+    });
+  }
+
   createPlanConflict(workItemId, input = {}) {
     const id = input.id || randomUUID();
     const now = this.now();
@@ -1001,6 +1121,10 @@ export class WorkItemStore {
     return graphExecutionState(detail, detail.actions);
   }
 
+  listActionEvents(actionId) {
+    return this.db.prepare(`SELECT * FROM events WHERE action_id = ? ORDER BY id`).all(actionId).map(mapEvent);
+  }
+
   getReusableContext(workDir, excludeWorkItemId = null) {
     const workspaceKey = canonicalWorkspaceKey(workDir);
     if (!workspaceKey) return [];
@@ -1544,12 +1668,29 @@ export class WorkItemStore {
     };
   }
 
+  closeRunInput(runId, ownerBootId, leaseEpoch) {
+    return withTransaction(this.db, () => {
+      const active = this.#activeRunRow(runId, ownerBootId, leaseEpoch, true);
+      if (!active) return false;
+      const pendingInput = this.db.prepare(`SELECT event_id FROM pending_action_inputs
+        WHERE action_id = ? AND consumed_at IS NULL LIMIT 1`).get(active.action_id);
+      if (pendingInput) return false;
+      const changed = this.db.prepare(`UPDATE runs SET accepting_input = 0
+        WHERE id = ? AND owner_boot_id = ? AND lease_epoch = ? AND status = 'running'
+        AND accepting_input = 1`).run(runId, ownerBootId, leaseEpoch);
+      return Number(changed.changes) === 1;
+    });
+  }
+
   finalizeRun(runId, ownerBootId, leaseEpoch, result, makeTransition) {
     return withTransaction(this.db, () => {
       const active = this.#activeRunRow(runId, ownerBootId, leaseEpoch, true);
-      if (!active) return null;
+      if (!active || Number(active.accepting_input) !== 0) return null;
       const action = this.getAction(active.action_id);
       const workItem = this.getWorkItem(active.work_item_id);
+      const pendingInput = this.db.prepare(`SELECT event_id FROM pending_action_inputs
+        WHERE action_id = ? AND consumed_at IS NULL LIMIT 1`).get(action.id);
+      if (pendingInput) throw new Error('Run has unconsumed Action input and cannot finish yet');
       const priorRuns = this.db.prepare(`SELECT * FROM runs
         WHERE work_item_id = ? AND id != ? AND status != 'running'
         ORDER BY started_at ASC`).all(workItem.id, runId).map(mapRun);
@@ -1727,14 +1868,15 @@ export class WorkItemStore {
         currentActionId = blocked?.id || runnable?.id || null;
         changedWorkItem = this.db.prepare(`UPDATE work_items SET status = ?, current_action_id = ?,
           current_run_id = NULL, ledger_revision = ledger_revision + ?, updated_at = ?
-          WHERE id = ? AND status IN ('ready', 'running', 'waiting', 'needs_attention')`).run(
-          workItemStatus, currentActionId, ledgerIncrement, now, workItem.id,
+          WHERE id = ? AND status IN ('ready', 'running', 'waiting', 'needs_attention')
+          AND revision = ?`).run(
+          workItemStatus, currentActionId, ledgerIncrement, now, workItem.id, nextWorkItem.revision,
         );
       } else {
         changedWorkItem = this.db.prepare(`UPDATE work_items SET status = ?, current_action_id = ?,
           current_run_id = NULL, ledger_revision = ledger_revision + ?, updated_at = ? WHERE id = ? AND current_run_id = ?
-          AND current_action_id = ? AND status = 'running'`).run(
-          workItemStatus, currentActionId, ledgerIncrement, now, workItem.id, runId, action.id,
+          AND current_action_id = ? AND status = 'running' AND revision = ?`).run(
+          workItemStatus, currentActionId, ledgerIncrement, now, workItem.id, runId, action.id, nextWorkItem.revision,
         );
       }
       if (Number(changedWorkItem.changes) !== 1) {

package/yeaft/work-center/watcher.js

@@ -88,6 +88,13 @@ export class WorkItemWatcher {
     }
   }
 
+  notifyActionInput(workItemId, actionId) {
+    for (const entry of this.activeRuns.values()) {
+      if (entry.workItemId !== workItemId || entry.actionId !== actionId) continue;
+      try { entry.wakeForPendingUserMessage?.(); } catch {}
+    }
+  }
+
   #recoverExpiredRuns() {
     const recovered = this.store.recoverInterruptedRuns?.(this.ownerBootId) || 0;
     if (recovered > 0) {
@@ -172,11 +179,15 @@ export class WorkItemWatcher {
       readFinalProgress: null,
       interrupted: false,
       workItemId: claim.workItem.id,
+      actionId: claim.action.id,
       runId: claim.run.id,
       leaseEpoch: claim.run.leaseEpoch,
+      wakeForPendingUserMessage: null,
     };
     entry.promise = this.#execute(claim, abortController.signal, readProgress => {
       entry.readFinalProgress = readProgress;
+    }, wake => {
+      entry.wakeForPendingUserMessage = wake;
     }).finally(() => {
       clearInterval(renewal);
       this.activeRuns.delete(key);
@@ -186,7 +197,7 @@ export class WorkItemWatcher {
     this.onEvent({ type: 'run.started', workItem: this.store.getWorkItemDetail(claim.workItem.id) });
   }
 
-  async #execute(claim, signal, registerProgressReader) {
+  async #execute(claim, signal, registerProgressReader, registerInputWake) {
     try {
       let result;
       try {
@@ -195,6 +206,7 @@ export class WorkItemWatcher {
           signal,
           ownerBootId: this.ownerBootId,
           registerProgressReader,
+          registerInputWake,
           onProgress: progress => {
             const detail = this.store.updateRunProgress(
               claim.run.id,