@yeaft/webchat-agent 1.0.205 → 1.0.206

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.205",
+  "version": "1.0.206",
   "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/work-center/bridge.js

@@ -18,7 +18,9 @@ let shuttingDown = false;
 let shutdownPromise = null;
 let serviceFactory = null;
 
-const BROWSER_DETAIL_OPS = new Set(['get', 'create', 'update', 'start', 'cancel', 'action_input', 'guide', 'retry']);
+const BROWSER_DETAIL_OPS = new Set([
+  'get', 'create', 'update', 'start', 'cancel', 'work_item_message', 'action_input', 'retry_action', 'guide', 'retry',
+]);
 const BROWSER_ACTION_DEBUG_OPS = new Set(['get_action_messages', 'get_action_requests', 'get_action_request']);
 // `files` is an internal server-to-Agent field. The browser relay rejects any
 // client-supplied value and only emits files resolved from owned upload ids.
@@ -26,7 +28,9 @@ const BROWSER_FILE_FIELDS = Object.freeze({
   create: [
     'title', 'goal', 'acceptanceCriteria', 'workItemType', 'workDir', 'reuseMemory', 'files', 'start',
   ],
+  work_item_message: ['id', 'text', 'revision'],
   action_input: ['id', 'text', 'actionId', 'revision', 'generation', 'files'],
+  retry_action: ['id', 'actionId', 'revision', 'generation'],
   guide: ['id', 'guidance', 'actionId', 'revision', 'generation', 'files'],
   get_action_messages: ['id', 'actionId', 'cursor', 'limit'],
   get_action_requests: ['id', 'actionId'],

package/yeaft/work-center/controller.js

@@ -189,15 +189,34 @@ export class WorkflowController {
     return detail;
   }
 
+  message(id, input = {}) {
+    const text = typeof input.text === 'string' ? input.text.trim().slice(0, 8_000) : '';
+    if (!text) throw new Error('WorkItem message is required');
+    const revision = Number(input.revision);
+    if (!Number.isInteger(revision)) throw new Error('revision is required for WorkItem messages');
+    const detail = this.store.addWorkItemMessage(id, text, revision, (workItem, action) => (
+      actionInstruction(action, workItem, action.context || [], renderSessionContextSnapshot(workItem.sessionContext))
+    ));
+    if (!detail) throw new Error(`WorkItem not found: ${id}`);
+    return detail;
+  }
+
   input(id, input = {}) {
     const text = typeof input.text === 'string' ? input.text.trim().slice(0, 8_000) : '';
     const addedAttachmentCount = Math.max(0, Number(input.addedAttachmentCount) || 0);
     if (!text && addedAttachmentCount === 0) throw new Error('Action input or attachments are required');
     const workItem = this.store.getWorkItem(id);
     if (!workItem) throw new Error(`WorkItem not found: ${id}`);
-    if (['ready', 'running'].includes(workItem.status)) {
-      const activeAction = this.store.getAction(input.actionId);
-      if (activeAction?.status === 'running' && addedAttachmentCount > 0) {
+    const targetAction = this.store.getAction(input.actionId);
+    const graphMode = workItem.workflowSnapshot?.executionMode === 'graph';
+    const targetMatches = graphMode
+      ? targetAction?.workItemId === id && targetAction.generation === input.generation
+      : workItem.currentActionId === input.actionId;
+    if (!targetMatches || workItem.revision !== input.revision) {
+      throw new Error('Action changed before input was applied; refresh and try again');
+    }
+    if (['ready', 'running'].includes(targetAction.status)) {
+      if (targetAction.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');
       }
       const inputSummary = text || `The user added ${addedAttachmentCount} attachment(s) as additional context for this Action.`;
@@ -205,20 +224,20 @@ export class WorkflowController {
         actionId: input.actionId,
         generation: input.generation,
         revision: input.revision,
-      }, (current, action) => {
-        const context = [...(action.context || []), {
+      }, (current, currentAction) => {
+        const context = [...(currentAction.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,
+          type: currentAction.type,
+          stageId: currentAction.stageId || currentAction.type,
+          assignmentPolicy: currentAction.assignmentPolicy,
+          modelPolicy: currentAction.modelPolicy,
+          requiredRole: currentAction.requiredRole,
+          dependsOnStageIds: currentAction.dependsOnStageIds,
+          workspaceMode: currentAction.workspaceMode,
+          changesRequestedStageId: currentAction.changesRequestedStageId,
+          brief: currentAction.brief,
         };
         return {
           context,
@@ -226,17 +245,8 @@ export class WorkflowController {
         };
       }, input.attachments, input.addedAttachments);
     }
-    if (!['waiting', 'needs_attention'].includes(workItem.status)) {
-      throw new Error(`WorkItem in ${workItem.status} cannot accept Action input`);
-    }
-    const targetAction = this.store.getAction(input.actionId);
-    const graphMode = workItem.workflowSnapshot?.executionMode === 'graph';
-    const targetMatches = graphMode
-      ? targetAction?.workItemId === id && targetAction.generation === input.generation
-        && ['waiting', 'failed'].includes(targetAction.status)
-      : workItem.currentActionId === input.actionId;
-    if (!targetMatches || workItem.revision !== input.revision) {
-      throw new Error('Action changed before input was applied; refresh and try again');
+    if (!['waiting', 'failed'].includes(targetAction.status)) {
+      throw new Error(`Action in ${targetAction.status} cannot accept input`);
     }
     return this.retry(id, {
       answer: text,
@@ -254,8 +264,8 @@ export class WorkflowController {
     const answer = typeof input.answer === 'string' ? input.answer.trim().slice(0, 8_000) : '';
     const addedAttachmentCount = Math.max(0, Number(input.addedAttachmentCount) || 0);
     const detail = this.store.retryWorkItemAtomic(id, (workItem, previous, previousRun) => {
-      if (workItem.status === 'waiting' && !answer && addedAttachmentCount === 0) {
-        throw new Error('answer or attachments are required to resume a waiting WorkItem');
+      if (previous?.status === 'waiting' && !answer && addedAttachmentCount === 0) {
+        throw new Error('answer or attachments are required to resume a waiting Action');
       }
       const step = previous
         ? {

package/yeaft/work-center/mainline-projection.js

@@ -70,9 +70,23 @@ function clamp(value, minimum, maximum) {
   return Math.min(maximum, Math.max(minimum, value));
 }
 
-function guidanceView(events) {
+function workItemMessageView(messages) {
+  return (Array.isArray(messages) ? messages : [])
+    .filter(message => typeof message?.text === 'string' && message.text)
+    .slice()
+    .sort((left, right) => count(left.createdAt) - count(right.createdAt)
+      || String(left.id).localeCompare(String(right.id)))
+    .map(message => ({
+      messageId: message.id,
+      text: message.text,
+      createdAt: count(message.createdAt),
+    }));
+}
+
+function guidanceView(events, actionId) {
   return (Array.isArray(events) ? events : [])
-    .filter(event => ['action.guidance_added', 'action.input_added'].includes(event?.type))
+    .filter(event => event?.actionId === actionId
+      && ['action.guidance_added', 'action.input_added'].includes(event.type))
     .slice()
     .sort((left, right) => count(left.id) - count(right.id))
     .map(event => ({
@@ -223,6 +237,7 @@ export function buildMainlineContextSnapshot(detail, action, budgetInput = {}) {
     directDependencies: dependencies,
     userContext: {
       sessionContext: [],
+      workItemMessages: [],
       guidance: [],
       includedCount: 0,
       omittedCount: 0,
@@ -249,12 +264,26 @@ export function buildMainlineContextSnapshot(detail, action, budgetInput = {}) {
     return false;
   };
   const sessionContext = normalizeSessionContextSnapshot(detail.sessionContext);
-  const guidance = guidanceView(detail.events);
-  const userEntries = [
-    ...sessionContext.map(value => ({ kind: 'sessionContext', value })),
+  const workItemMessages = workItemMessageView(detail.messages);
+  const guidance = guidanceView(detail.events, action.id);
+  const newestFirstMessages = workItemMessages.slice().reverse();
+  for (const [index, message] of newestFirstMessages.entries()) {
+    const next = {
+      ...snapshot.userContext,
+      workItemMessages: [message, ...snapshot.userContext.workItemMessages],
+      includedCount: snapshot.userContext.includedCount + 1,
+      omittedCount: 0,
+    };
+    const included = trySet('userContext', next);
+    if (index === 0 && !included) {
+      throw mainlineContextBlocked('Latest WorkItem message exceeds the Mainline prompt budget');
+    }
+  }
+  const otherUserEntries = [
     ...guidance.map(value => ({ kind: 'guidance', value })),
+    ...sessionContext.map(value => ({ kind: 'sessionContext', value })),
   ];
-  for (const entry of userEntries) {
+  for (const entry of otherUserEntries) {
     const next = {
       ...snapshot.userContext,
       [entry.kind]: [...snapshot.userContext[entry.kind], entry.value],
@@ -263,7 +292,8 @@ export function buildMainlineContextSnapshot(detail, action, budgetInput = {}) {
     };
     trySet('userContext', next);
   }
-  snapshot.userContext.omittedCount = userEntries.length - snapshot.userContext.includedCount;
+  snapshot.userContext.omittedCount = workItemMessages.length + otherUserEntries.length
+    - snapshot.userContext.includedCount;
 
   const siblingEntries = Object.entries(projection.canonicalActionResults)
     .filter(([actionId]) => actionId !== action.id && !dependencies.some(item => item.actionId === actionId))

package/yeaft/work-center/projection.js

@@ -610,6 +610,11 @@ export function projectWorkItemDetail(detail) {
 
     origin: detail.origin?.sessionId ? { sessionId: detail.origin.sessionId } : null,
     linkedSessionIds: Array.isArray(detail.linkedSessionIds) ? detail.linkedSessionIds : [],
+    messages: (Array.isArray(detail.messages) ? detail.messages : []).slice(-100).map(message => ({
+      id: String(message.id || ''),
+      text: truncateUtf8(message.text || '', MAX_ACTION_MESSAGE_CHARS),
+      createdAt: count(message.createdAt),
+    })),
     attachments: projectAttachments(detail.attachments),
     createdAt: detail.createdAt,
     updatedAt: detail.updatedAt,

package/yeaft/work-center/service.js

@@ -207,6 +207,30 @@ export class WorkCenterService {
         this.#emit({ type: 'work_item.cancelled', workItem: detail });
         return detail;
       }
+      case 'work_item_message': {
+        const id = requiredString(payload.id, 'id');
+        const detail = this.controller.message(id, {
+          text: typeof payload.text === 'string' ? payload.text : '',
+          revision: payload.revision,
+        });
+        this.watcher.notifyWorkItemInput(id);
+        this.#emit({ type: 'work_item.message_added', workItem: detail });
+        return detail;
+      }
+      case 'retry_action': {
+        const id = requiredString(payload.id, 'id');
+        const detail = this.controller.retry(id, {
+          expected: {
+            actionId: typeof payload.actionId === 'string' ? payload.actionId : '',
+            revision: payload.revision,
+            generation: payload.generation,
+            statuses: ['failed'],
+          },
+        });
+        this.watcher.abortInvalidWorkItemRuns(id);
+        this.#emit({ type: 'action.retried', workItem: detail });
+        return detail;
+      }
       case 'action_input': {
         const id = requiredString(payload.id, 'id');
         const workItem = this.#requiredItem(id);

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 = 15;
+const SCHEMA_VERSION = 16;
 const OPEN_ACTION_STATUSES = "'ready','running','waiting'";
 const MAX_REUSABLE_CONTEXT_ITEMS = 12;
 const MAX_RUN_RESPONSE_CHARS = 65_536;
@@ -77,6 +77,7 @@ function mapWorkItem(row) {
     origin: parseJson(row.origin, null),
     linkedSessionIds: parseJson(row.linked_session_ids, []),
     sessionContext: parseJson(row.session_context, []),
+    messages: parseJson(row.messages, []),
     attachments: parseJson(row.attachments, []),
     executionStats: {
       llmRequestCount: Math.max(0, Number(row.usage_llm_request_count) || 0),
@@ -284,6 +285,7 @@ export class WorkItemStore {
         origin TEXT,
         linked_session_ids TEXT NOT NULL DEFAULT '[]',
         session_context TEXT NOT NULL DEFAULT '[]',
+        messages TEXT NOT NULL DEFAULT '[]',
         attachments TEXT NOT NULL DEFAULT '[]',
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL
@@ -421,6 +423,9 @@ export class WorkItemStore {
     if (!hasColumn(this.db, 'work_items', 'reuse_memory')) {
       this.db.exec('ALTER TABLE work_items ADD COLUMN reuse_memory INTEGER NOT NULL DEFAULT 1');
     }
+    if (!hasColumn(this.db, 'work_items', 'messages')) {
+      this.db.exec("ALTER TABLE work_items ADD COLUMN messages TEXT NOT NULL DEFAULT '[]'");
+    }
     if (!hasColumn(this.db, 'actions', 'brief')) {
       this.db.exec('ALTER TABLE actions ADD COLUMN brief TEXT');
     }
@@ -555,13 +560,17 @@ export class WorkItemStore {
     return withTransaction(this.db, () => {
       const workItem = this.getWorkItem(id);
       if (!workItem) return null;
-      if (!['ready', 'running'].includes(workItem.status)) {
+      const graphMode = workItem.workflowSnapshot?.executionMode === 'graph';
+      const inputStatuses = graphMode
+        ? ['ready', 'running', 'waiting', 'needs_attention']
+        : ['ready', 'running'];
+      if (!inputStatuses.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?.workItemId === id && action.generation === expected.generation
+          && ['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) {
@@ -1217,6 +1226,63 @@ export class WorkItemStore {
     return this.db.prepare(`SELECT * FROM events WHERE action_id = ? ORDER BY id`).all(actionId).map(mapEvent);
   }
 
+  addWorkItemMessage(id, text, expectedRevision, updateActionInstruction) {
+    return withTransaction(this.db, () => {
+      const workItem = this.getWorkItem(id);
+      if (!workItem) return null;
+      if (['done', 'cancelled'].includes(workItem.status)) {
+        throw new Error(`WorkItem in ${workItem.status} cannot accept messages`);
+      }
+      if (workItem.revision !== expectedRevision) {
+        throw new Error('WorkItem changed before the message was applied; refresh and try again');
+      }
+      const openActions = this.db.prepare(`SELECT * FROM actions WHERE work_item_id = ?
+        AND status IN ('ready', 'running') ORDER BY sequence`).all(id).map(mapAction);
+      for (const action of openActions.filter(candidate => candidate.status === 'running')) {
+        const run = action.currentRunId ? this.getRun(action.currentRunId) : null;
+        if (!run || run.status !== 'running' || run.acceptingInput === false) {
+          throw new Error('A running Action closed its input window before the WorkItem message was applied; refresh and try again');
+        }
+      }
+      const now = this.now();
+      const revision = workItem.revision + 1;
+      const message = { id: randomUUID(), text, createdAt: now };
+      const messages = [...(workItem.messages || []), message].slice(-100);
+      this.db.prepare(`UPDATE work_items SET messages = ?, revision = ?, updated_at = ? WHERE id = ?`)
+        .run(stringify(messages), revision, now, id);
+      const updatedWorkItem = { ...workItem, messages, revision };
+      for (const action of openActions) {
+        if (action.status === 'ready') {
+          const instruction = updateActionInstruction(updatedWorkItem, action);
+          this.db.prepare(`UPDATE actions SET instruction = ?, spec_hash = ?, updated_at = ?
+            WHERE id = ? AND status = 'ready'`).run(
+            instruction,
+            actionSpecHash({ ...action, instruction }),
+            now,
+            action.id,
+          );
+          continue;
+        }
+        const run = this.getRun(action.currentRunId);
+        const eventId = this.appendEvent(id, 'work_item.message_applied', { message }, {
+          actionId: action.id,
+          runId: action.currentRunId,
+        });
+        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,
+          `WorkItem-level message: ${text}`,
+        );
+      }
+      this.appendEvent(id, 'work_item.message_added', { message });
+      return this.getWorkItemDetail(id);
+    });
+  }
+
   getReusableContext(workDir, excludeWorkItemId = null) {
     const workspaceKey = canonicalWorkspaceKey(workDir);
     if (!workspaceKey) return [];
@@ -1432,17 +1498,24 @@ export class WorkItemStore {
     return withTransaction(this.db, () => {
       const workItem = this.getWorkItem(id);
       if (!workItem) return null;
-      if (!['waiting', 'needs_attention'].includes(workItem.status)) {
+      const graphMode = isGraphWorkItem(workItem);
+      const retryableWorkItemStatuses = graphMode
+        ? ['ready', 'running', 'waiting', 'needs_attention']
+        : ['waiting', 'needs_attention'];
+      if (!retryableWorkItemStatuses.includes(workItem.status)) {
         throw new Error(`WorkItem in ${workItem.status} does not need retry`);
       }
-      const graphMode = isGraphWorkItem(workItem);
       let previous = workItem.currentActionId ? this.getAction(workItem.currentActionId) : null;
       if (options.expected) {
         const expectedAction = this.getAction(options.expected.actionId);
+        const allowedExpectedStatuses = Array.isArray(options.expected.statuses)
+          ? options.expected.statuses
+          : ['waiting', 'failed'];
         const expectedMatches = graphMode
           ? expectedAction?.workItemId === id && expectedAction.generation === options.expected.generation
-            && ['waiting', 'failed'].includes(expectedAction.status)
-          : workItem.currentActionId === options.expected.actionId;
+            && allowedExpectedStatuses.includes(expectedAction.status)
+          : workItem.currentActionId === options.expected.actionId
+            && allowedExpectedStatuses.includes(expectedAction?.status);
         if (!expectedMatches || workItem.revision !== options.expected.revision) {
           throw new Error('Action changed before input was applied; refresh and try again');
         }

package/yeaft/work-center/watcher.js

@@ -95,6 +95,13 @@ export class WorkItemWatcher {
     }
   }
 
+  notifyWorkItemInput(workItemId) {
+    for (const entry of this.activeRuns.values()) {
+      if (entry.workItemId !== workItemId) continue;
+      try { entry.wakeForPendingUserMessage?.(); } catch {}
+    }
+  }
+
   #recoverExpiredRuns() {
     const recovered = this.store.recoverInterruptedRuns?.(this.ownerBootId) || 0;
     if (recovered > 0) {

package/yeaft/work-center/workflow.js

@@ -675,7 +675,10 @@ function renderContext(context = []) {
 
 export function actionInstruction(stage, workItem, context = [], sessionContextBlock = renderSessionContextSnapshot(workItem?.sessionContext)) {
   const criteria = (workItem.acceptanceCriteria || []).map(item => `- ${item}`).join('\n') || '- No explicit criteria';
-  const common = `WorkItem: ${workItem.title}\nGoal: ${workItem.goal}\nAcceptance criteria:\n${criteria}${sessionContextBlock}${renderContext(context)}`;
+  const workItemMessages = Array.isArray(workItem.messages) && workItem.messages.length > 0
+    ? `\n\nWorkItem-level user messages (apply to every unfinished Action):\n${workItem.messages.map(message => `- ${message.text}`).join('\n')}`
+    : '';
+  const common = `WorkItem: ${workItem.title}\nGoal: ${workItem.goal}\nAcceptance criteria:\n${criteria}${sessionContextBlock}${workItemMessages}${renderContext(context)}`;
   const policy = stage.instruction || defaultWorkCenterStageInstruction(stage.type);
   const brief = normalizeActionBrief(stage.brief || stage, stage.type);
   const contract = `Action type: ${stage.type}\nWhat to do:\n${brief.objective}\n\nHow to do it:\n${brief.approach}\n\nExpected result:\n${brief.expectedOutcome}`;