@yeaft/webchat-agent 1.0.247 → 1.0.249

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.247",
+  "version": "1.0.249",
   "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/action-identity.js

@@ -7,6 +7,29 @@ export function eventMatchesActionGeneration(event, action) {
   return generation(event.actionGeneration) === generation(action.generation);
 }
 
+export function currentActionInputEventIds(events, action) {
+  const inputEvents = new Map((Array.isArray(events) ? events : [])
+    .filter(event => event?.type === 'action.input_added' && event.actionId === action?.id)
+    .map(event => [String(event.id), event]));
+  const valid = new Set();
+  for (const event of inputEvents.values()) {
+    if (eventMatchesActionGeneration(event, action)) valid.add(String(event.id));
+  }
+  for (const event of Array.isArray(events) ? events : []) {
+    if (event?.type !== 'action.input_rebound' || event.actionId !== action?.id
+        || !eventMatchesActionGeneration(event, action)) continue;
+    const sourceEventIds = [
+      event.data?.sourceEventId,
+      ...(Array.isArray(event.data?.sourceEventIds) ? event.data.sourceEventIds : []),
+    ].filter(value => value != null);
+    for (const eventId of sourceEventIds) {
+      const key = String(eventId);
+      if (inputEvents.has(key)) valid.add(key);
+    }
+  }
+  return valid;
+}
+
 export function runMatchesActionIdentity(run, action) {
   if (!run || !action) return false;
   const actionGeneration = generation(action.generation);

package/yeaft/work-center/bridge.js

@@ -5,7 +5,8 @@ import { defaultRegistry } from '../vp/registry.js';
 import { scanVpLibrary } from '../vp/vp-store.js';
 import { WorkCenterService } from './service.js';
 import { WorkItemRunner } from './runner.js';
-import { projectWorkCenterEvent, projectWorkItemDetail } from './projection.js';
+import { WorkItemCoordinator } from './coordinator.js';
+import { projectWorkCenterEvent } from './projection.js';
 import { previewWorkCenterPlan } from './planner.js';
 import { readWorkCenterSettings, writeWorkCenterSettings } from './settings.js';
 import { defaultWorkCenterStageInstructions } from './workflow.js';
@@ -19,7 +20,7 @@ let shutdownPromise = null;
 let serviceFactory = null;
 
 const BROWSER_DETAIL_OPS = new Set([
-  'get', 'create', 'update', 'start', 'cancel', 'work_item_message', 'action_input', 'retry_action', 'guide', 'retry',
+  'get', 'create', 'update', 'start', 'cancel', '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
@@ -28,7 +29,7 @@ const BROWSER_FILE_FIELDS = Object.freeze({
   create: [
     'title', 'goal', 'acceptanceCriteria', 'workItemType', 'workDir', 'reuseMemory', 'files', 'start',
   ],
-  work_item_message: ['id', 'text', 'revision'],
+  work_item_message: ['id', 'text', 'revision', 'planRevision', 'ledgerRevision', 'coordinatorRevision'],
   action_input: ['id', 'text', 'actionId', 'revision', 'generation', 'files'],
   retry_action: ['id', 'actionId', 'revision', 'generation'],
   delete: ['id', 'revision'],
@@ -117,9 +118,22 @@ async function createDefaultService() {
     registry: defaultRegistry,
     store: null,
   });
+  const coordinator = new WorkItemCoordinator({
+    store: null,
+    runtimeProvider: async () => {
+      const runtime = await runner.runtimeProvider();
+      if (defaultRegistry.vpCount() === 0) {
+        for (const vp of scanVpLibrary({ dir: join(yeaftDir, 'virtual-persons') })) defaultRegistry.setVp(vp);
+      }
+      return runtime;
+    },
+    policyProvider: async () => readWorkCenterSettings(yeaftDir),
+    registry: defaultRegistry,
+  });
   const created = new WorkCenterService({
     yeaftDir,
     runner,
+    coordinator,
     runtimeInfoProvider: getSettingsRuntime,
     listAvailableVpIds: () => defaultRegistry.listVps().map(vp => vp.id),
     watcherOptions: {
@@ -130,6 +144,7 @@ async function createDefaultService() {
     },
   });
   runner.store = created.store;
+  coordinator.store = created.store;
   return created;
 }
 
@@ -173,6 +188,7 @@ export async function handleWorkCenterRequest(msg) {
   const op = typeof msg.op === 'string' ? msg.op : '';
   try {
     let data;
+    let workCenter = null;
     if (op === 'get_settings') {
       data = await readSettingsResponse();
     } else if (op === 'update_settings') {
@@ -195,13 +211,13 @@ export async function handleWorkCenterRequest(msg) {
       await resetYeaftSession();
       data = await readSettingsResponse();
     } else {
-      const workCenter = await ensureWorkCenter();
+      workCenter = await ensureWorkCenter();
       const payload = Object.hasOwn(BROWSER_FILE_FIELDS, op)
         ? browserFilePayload(op, msg.payload)
         : (BROWSER_ACTION_DEBUG_OPS.has(op) ? browserFilePayload(op, msg.payload) : (msg.payload || {}));
       data = await workCenter.handle(op, payload);
     }
-    if (BROWSER_DETAIL_OPS.has(op)) data = projectWorkItemDetail(data);
+    if (BROWSER_DETAIL_OPS.has(op)) data = workCenter.projectBrowserDetail(data);
     send({
       type: 'work_center_response',
       requestId,

package/yeaft/work-center/completion-contract.js

@@ -44,9 +44,31 @@ export function validateCompletedResult(result, action, workItem) {
     result.error = 'Completed Action requires one ordered acceptance check with evidence for every acceptance criterion';
     return;
   }
-  const mustVerify = action.type === 'test'
-    || action.type === 'deliver'
-    || (action.type === 'review' && result.reviewDecision === 'approved');
+  // Intermediate test Actions validate their own task-specific expected result.
+  // Requiring them to prove the entire WorkItem contract makes any DAG with
+  // later tests or reviews impossible to complete. Global proof belongs at the
+  // delivery boundary or an approved review with no unfinished downstream work.
+  const remainingStages = Array.isArray(workItem?.workflowSnapshot?.stages)
+    ? workItem.workflowSnapshot.stages.filter(stage => stage?.id !== action.stageId)
+    : [];
+  const downstream = new Set([action.stageId]);
+  let expanded = true;
+  while (expanded) {
+    expanded = false;
+    for (const stage of remainingStages) {
+      if (downstream.has(stage?.id)) continue;
+      if (Array.isArray(stage?.dependsOnStageIds)
+          && stage.dependsOnStageIds.some(stageId => downstream.has(stageId))) {
+        downstream.add(stage.id);
+        expanded = true;
+      }
+    }
+  }
+  const hasDownstreamStage = remainingStages.some(stage => downstream.has(stage?.id));
+  const hasDeliverStage = remainingStages.some(stage => stage?.type === 'deliver');
+  const mustVerify = action.type === 'deliver'
+    || (action.type === 'review' && result.reviewDecision === 'approved'
+      && !hasDownstreamStage && !hasDeliverStage);
   if (mustVerify && checks.some(check => check.status !== 'passed')) {
     result.outcome = 'failed';
     result.error = `${action.type} Action requires every acceptance check to pass`;

package/yeaft/work-center/controller.js

@@ -1,6 +1,9 @@
+import { randomUUID } from 'node:crypto';
 import {
   actionForStage,
   actionInstruction,
+  canonicalActionInstruction,
+  withoutActionInputContext,
   applyGeneratedPlan,
   getNextStep,
   initialActionFor,
@@ -76,6 +79,28 @@ function normalizeTerminalResult(result, action) {
   return normalized;
 }
 
+function canonicalReplacementAction(workItem, action, context) {
+  const replacement = {
+    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,
+    context,
+    maxAttempts: action.maxAttempts || 2,
+  };
+  replacement.instruction = canonicalActionInstruction(
+    workItem,
+    { ...action, ...replacement },
+    context,
+  );
+  return replacement;
+}
+
 function contextEntry(action, result, run) {
   return {
     type: action.type,
@@ -161,50 +186,22 @@ export class WorkflowController {
     const current = this.store.getWorkItem(id);
     const graphMode = current?.workflowSnapshot?.executionMode === 'graph';
     if (!expected.actionId || !Number.isInteger(expected.revision)
-        || (graphMode && !Number.isInteger(expected.generation))) {
+        || (graphMode && (!Number.isInteger(expected.generation) || expected.generation < 1))) {
       throw new Error(`actionId, revision${graphMode ? ', and generation' : ''} are required for guidance`);
     }
     const detail = this.store.addActionGuidance(id, guidanceSummary, expected, (workItem, previous) => {
-      const context = [...(previous.context || []), {
+      const context = [...withoutActionInputContext(previous.context), {
         type: 'guidance',
         role: 'user',
         summary: guidanceSummary,
         evidence: [],
       }];
-      const step = {
-        type: previous.type,
-        stageId: previous.stageId || previous.type,
-        assignmentPolicy: previous.assignmentPolicy,
-        modelPolicy: previous.modelPolicy,
-        requiredRole: previous.requiredRole,
-        dependsOnStageIds: previous.dependsOnStageIds,
-        workspaceMode: previous.workspaceMode,
-        changesRequestedStageId: previous.changesRequestedStageId,
-        brief: previous.brief,
-      };
-      return {
-        ...step,
-        context,
-        instruction: actionInstruction(step, workItem, context, renderSessionContextSnapshot(workItem.sessionContext)),
-        maxAttempts: previous.maxAttempts || 2,
-      };
+      return canonicalReplacementAction(workItem, previous, context);
     }, input.attachments, input.addedAttachments);
     if (!detail) throw new Error(`WorkItem not found: ${id}`);
     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);
@@ -212,10 +209,14 @@ export class WorkflowController {
     const workItem = this.store.getWorkItem(id);
     if (!workItem) throw new Error(`WorkItem not found: ${id}`);
     const targetAction = this.store.getAction(input.actionId);
+    const expectedGeneration = Number(input.generation);
+    if (!Number.isInteger(expectedGeneration) || expectedGeneration < 1) {
+      throw new Error('actionId, revision, and generation are required for Action input');
+    }
     const graphMode = workItem.workflowSnapshot?.executionMode === 'graph';
-    const targetMatches = graphMode
-      ? targetAction?.workItemId === id && targetAction.generation === input.generation
-      : workItem.currentActionId === input.actionId;
+    const targetMatches = targetAction?.workItemId === id
+      && targetAction.generation === expectedGeneration
+      && (graphMode || workItem.currentActionId === input.actionId);
     if (!targetMatches || workItem.revision !== input.revision) {
       throw new Error('Action changed before input was applied; refresh and try again');
     }
@@ -226,27 +227,8 @@ export class WorkflowController {
       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,
+        generation: expectedGeneration,
         revision: input.revision,
-      }, (current, currentAction) => {
-        const context = [...(currentAction.context || []), {
-          type: 'input', role: 'user', summary: inputSummary, evidence: [],
-        }];
-        const step = {
-          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,
-          instruction: actionInstruction(step, current, context, renderSessionContextSnapshot(current.sessionContext)),
-        };
       }, input.attachments, input.addedAttachments);
     }
     if (!['waiting', 'failed'].includes(targetAction.status)) {
@@ -258,6 +240,7 @@ export class WorkflowController {
       expected: { actionId: input.actionId, generation: input.generation, revision: input.revision },
       attachments: input.attachments,
       inputEvent: {
+        inputId: randomUUID(),
         text: text || `The user added ${addedAttachmentCount} attachment(s) as additional context for this Action.`,
         attachments: input.addedAttachments,
       },
@@ -271,20 +254,7 @@ export class WorkflowController {
       if (previous?.status === 'waiting' && !answer && addedAttachmentCount === 0) {
         throw new Error('answer or attachments are required to resume a waiting Action');
       }
-      const step = previous
-        ? {
-            type: previous.type,
-            stageId: previous.stageId || previous.type,
-            assignmentPolicy: previous.assignmentPolicy,
-            modelPolicy: previous.modelPolicy,
-            requiredRole: previous.requiredRole,
-            dependsOnStageIds: previous.dependsOnStageIds,
-            workspaceMode: previous.workspaceMode,
-            changesRequestedStageId: previous.changesRequestedStageId,
-            brief: previous.brief,
-          }
-        : initialActionFor(workItem);
-      const context = Array.isArray(previous?.context) ? [...previous.context] : [];
+      const context = withoutActionInputContext(previous?.context);
       if (previousRun) {
         context.push({
           type: previous.type,
@@ -299,12 +269,19 @@ export class WorkflowController {
             : null),
         });
       }
-      return {
-        ...step,
-        context,
-        instruction: actionInstruction(step, workItem, context, renderSessionContextSnapshot(workItem.sessionContext)),
-        maxAttempts: previous?.maxAttempts || 2,
-      };
+      if (Number(workItem.executionSchemaVersion) === 2 && input.inputEvent?.inputId) {
+        context.push({
+          type: 'input',
+          role: 'user',
+          inputId: input.inputEvent.inputId,
+          summary: input.inputEvent.text || '',
+          attachments: Array.isArray(input.inputEvent.attachments) ? input.inputEvent.attachments : [],
+          evidence: [],
+        });
+      }
+      return previous
+        ? canonicalReplacementAction(workItem, previous, context)
+        : { ...initialActionFor(workItem), context };
     }, {
       expected: input.expected || null,
       attachments: input.attachments,
@@ -483,7 +460,7 @@ export class WorkflowController {
           : planProposal
             ? { ...effectiveWorkItem, workflowSnapshot: planProposal.workflowSnapshot }
             : effectiveWorkItem;
-        const context = [...(action.context || []), contextEntry(action, result, activeRun)];
+        const context = [...withoutActionInputContext(action.context), contextEntry(action, result, activeRun)];
         if (plannedWorkItem.workflowSnapshot?.executionMode === 'graph') {
           if (staleReplanMutation) {
             return {