@yeaft/webchat-agent 1.0.246 → 1.0.248

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

@@ -1,5 +1,9 @@
 import { createHash } from 'node:crypto';
-import { eventMatchesActionGeneration, runMatchesActionIdentity } from './action-identity.js';
+import {
+  currentActionInputEventIds,
+  eventMatchesActionGeneration,
+  runMatchesActionIdentity,
+} from './action-identity.js';
 import { normalizeSessionContextSnapshot } from './session-context.js';
 
 export const MAINLINE_CONTEXT_HARD_LIMIT_BYTES = 64 * 1024;
@@ -64,32 +68,93 @@ function clamp(value, minimum, maximum) {
   return Math.min(maximum, Math.max(minimum, value));
 }
 
-function workItemMessageView(messages) {
-  return (Array.isArray(messages) ? messages : [])
-    .filter(message => typeof message?.text === 'string' && message.text)
+function inputEventView(event) {
+  return {
+    eventId: event.id,
+    inputId: event.data?.inputId || null,
+    actionId: event.actionId || null,
+    text: event.data?.text || '',
+    attachments: Array.isArray(event.data?.attachments) ? event.data.attachments : [],
+  };
+}
+
+function canonicalActionUserContext(events, action) {
+  const actionEvents = (Array.isArray(events) ? events : [])
+    .filter(event => event?.actionId === action?.id
+      && ['action.guidance_added', 'action.input_added'].includes(event.type))
     .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),
-    }));
+    .sort((left, right) => count(left.id) - count(right.id));
+  const inputEvents = actionEvents.filter(event => event.type === 'action.input_added');
+  const validInputEventIds = currentActionInputEventIds(events, action);
+  const eventByInputId = new Map(inputEvents
+    .filter(event => event.data?.inputId)
+    .map(event => [event.data.inputId, event]));
+  const currentInputEvents = inputEvents.filter(event => validInputEventIds.has(String(event.id)));
+  const usedEventIds = new Set();
+  const contextEntries = (Array.isArray(action?.context) ? action.context : [])
+    .filter(entry => ['input', 'guidance', 'coordinator-guidance'].includes(entry?.type)
+      && typeof entry.summary === 'string');
+  const values = contextEntries.flatMap((entry, index) => {
+    if (entry.type !== 'input') {
+      const event = actionEvents.find(candidate => !usedEventIds.has(candidate.id)
+        && candidate.type === 'action.guidance_added'
+        && (candidate.data?.guidance || '') === entry.summary) || null;
+      if (event) usedEventIds.add(event.id);
+      return [{
+        eventId: event?.id ?? null,
+        inputId: null,
+        actionId: action.id,
+        text: entry.summary,
+        attachments: Array.isArray(entry.attachments)
+          ? entry.attachments
+          : Array.isArray(event?.data?.attachments) ? event.data.attachments : [],
+      }];
+    }
+    let event = entry.inputId ? eventByInputId.get(entry.inputId) : null;
+    if (!event && typeof entry.inputId === 'string' && entry.inputId.startsWith('legacy-event:')) {
+      const legacyEventId = Number(entry.inputId.slice('legacy-event:'.length));
+      event = inputEvents.find(candidate => candidate.id === legacyEventId) || null;
+    }
+    if (!event && !entry.inputId) {
+      event = currentInputEvents.find(candidate => !usedEventIds.has(candidate.id)
+        && (candidate.data?.text || '') === entry.summary) || null;
+    }
+    if (!entry.inputId && !event) return [];
+    if (event) usedEventIds.add(event.id);
+    return [{
+      eventId: event?.id ?? null,
+      inputId: entry.inputId || event?.data?.inputId || `legacy-context:${index}`,
+      actionId: action.id,
+      text: entry.summary,
+      attachments: Array.isArray(entry.attachments)
+        ? entry.attachments
+        : Array.isArray(event?.data?.attachments) ? event.data.attachments : [],
+    }];
+  });
+  return { values, usedEventIds, validInputEventIds };
 }
 
 function guidanceView(events, action) {
-  return (Array.isArray(events) ? events : [])
+  const allEvents = Array.isArray(events) ? events : [];
+  const canonicalEntries = canonicalActionUserContext(allEvents, action);
+  const currentEvents = allEvents
     .filter(event => event?.actionId === action?.id
-      && eventMatchesActionGeneration(event, action)
-      && ['action.guidance_added', 'action.input_added'].includes(event.type))
+      && ((event.type === 'action.input_added'
+        && canonicalEntries.validInputEventIds.has(String(event.id)))
+        || (event.type === 'action.guidance_added' && eventMatchesActionGeneration(event, action)))
+      && !canonicalEntries.usedEventIds.has(event.id))
     .slice()
     .sort((left, right) => count(left.id) - count(right.id))
-    .map(event => ({
-      eventId: event.id,
-      actionId: event.actionId || null,
-      text: event.data?.guidance || event.data?.text || '',
-      attachments: Array.isArray(event.data?.attachments) ? event.data.attachments : [],
-    }));
+    .map(event => event.type === 'action.input_added'
+      ? inputEventView(event)
+      : {
+          eventId: event.id,
+          inputId: null,
+          actionId: event.actionId || null,
+          text: event.data?.guidance || '',
+          attachments: Array.isArray(event.data?.attachments) ? event.data.attachments : [],
+        });
+  return [...canonicalEntries.values, ...currentEvents];
 }
 
 /**
@@ -259,21 +324,7 @@ export function buildMainlineContextSnapshot(detail, action, budgetInput = {}) {
     return false;
   };
   const sessionContext = normalizeSessionContextSnapshot(detail.sessionContext);
-  const workItemMessages = workItemMessageView(detail.messages);
   const guidance = guidanceView(detail.events, action);
-  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 })),
@@ -287,8 +338,7 @@ export function buildMainlineContextSnapshot(detail, action, budgetInput = {}) {
     };
     trySet('userContext', next);
   }
-  snapshot.userContext.omittedCount = workItemMessages.length + otherUserEntries.length
-    - snapshot.userContext.includedCount;
+  snapshot.userContext.omittedCount = 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/plan-mutation.js

@@ -4,6 +4,7 @@ import {
   canonicalActionId,
   canonicalExplicitActionId,
   canonicalExplicitActionIds,
+  validateGeneratedCompletionGate,
 } from './workflow.js';
 
 function cleanProposalId(value) {
@@ -174,9 +175,15 @@ export function applyAdditivePlanProposal({ workItem, actions, proposal, availab
     }),
     ...canonicalActions,
   ];
+  const orderedActions = stableTopologicalActions(mergedActions);
+  validateGeneratedCompletionGate(orderedActions.map(action => ({
+    id: action.id,
+    type: action.type,
+    dependsOnStageIds: action.dependsOnActionIds || [],
+  })));
   const rawPlan = {
     workItemType: workItem.workflowSnapshot.workItemType,
-    actions: stableTopologicalActions(mergedActions),
+    actions: orderedActions,
   };
   const workflowSnapshot = applyGeneratedPlan(synthetic, rawPlan, { availableVpIds });
   const addedStages = workflowSnapshot.stages.filter(stage => addedIds.has(stage.id));
@@ -189,6 +196,96 @@ export function applyAdditivePlanProposal({ workItem, actions, proposal, availab
   };
 }
 
+export function applyCoordinatorReplan({ workItem, actions, proposal, availableVpIds = null }) {
+  if (workItem.workflowSnapshot?.executionMode !== 'graph'
+      || workItem.workflowSnapshot?.planningMode !== 'ai') {
+    throw new Error('Work Center Coordinator replan requires an AI-planned Action graph');
+  }
+  if (!proposal || typeof proposal !== 'object' || Array.isArray(proposal)) {
+    throw new Error('Work Center Coordinator replan must be an object');
+  }
+  const proposalId = cleanProposalId(proposal.proposalId);
+  const basePlanRevision = Number(proposal.basePlanRevision);
+  if (!Number.isInteger(basePlanRevision) || basePlanRevision !== workItem.planRevision) {
+    throw new Error('Work Center Coordinator replan has a stale basePlanRevision');
+  }
+  if (!Array.isArray(proposal.actions) || proposal.actions.length < 1 || proposal.actions.length > 8) {
+    throw new Error('Work Center Coordinator replan requires between 1 and 8 unfinished Actions');
+  }
+
+  const active = actions.filter(candidate => !['superseded', 'cancelled'].includes(candidate.status));
+  const completed = active.filter(candidate => candidate.status === 'completed');
+  const completedStageIds = new Set(completed.map(candidate => candidate.stageId));
+  const unfinished = active.filter(candidate => candidate.status !== 'completed');
+  const unfinishedByStage = new Map(unfinished.map(candidate => [candidate.stageId, candidate]));
+  const historicalStageIds = new Set(actions.map(candidate => candidate.stageId));
+  const currentStages = new Map((workItem.workflowSnapshot.stages || []).map(stage => [stage.id, stage]));
+  const futureStageIds = new Set();
+
+  const normalizedFuture = proposal.actions.map(raw => {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+      throw new Error('Work Center Coordinator replan requires full Action specifications');
+    }
+    const id = canonicalActionId(raw.id);
+    if (!id || futureStageIds.has(id) || completedStageIds.has(id)) {
+      throw new Error(`Work Center Coordinator Action id is missing, duplicated, or completed: ${id || '(missing)'}`);
+    }
+    if (historicalStageIds.has(id) && !unfinishedByStage.has(id)) {
+      throw new Error(`Work Center Coordinator Action reuses historical stage identity: ${id}`);
+    }
+    futureStageIds.add(id);
+    const dependsOnActionIds = canonicalExplicitActionIds(
+      raw.dependsOnActionIds,
+      `Coordinator Action "${id}" dependencies`,
+    );
+    for (const dependencyId of dependsOnActionIds) {
+      if (!completedStageIds.has(dependencyId) && !futureStageIds.has(dependencyId)) {
+        throw new Error(`Work Center Coordinator Action "${id}" references a missing or future dependency "${dependencyId}"`);
+      }
+    }
+    return {
+      ...raw,
+      id,
+      dependsOnActionIds,
+      changesRequestedActionId: Object.hasOwn(raw, 'changesRequestedActionId')
+        ? canonicalExplicitActionId(raw.changesRequestedActionId, `Coordinator Action "${id}" review target`)
+        : undefined,
+    };
+  });
+
+  const completedInputs = completed.filter(candidate => candidate.type !== 'triage').map(candidate => {
+    const stage = currentStages.get(candidate.stageId);
+    if (!stage) throw new Error(`Work Center completed Action is missing from the frozen workflow: ${candidate.stageId}`);
+    return planActionFromStage(stage);
+  });
+  const synthetic = {
+    ...workItem,
+    workflowSnapshot: {
+      ...workItem.workflowSnapshot,
+      actionTemplates: [],
+      stages: [workItem.workflowSnapshot.stages[0]],
+    },
+  };
+  const workflowSnapshot = applyGeneratedPlan(synthetic, {
+    workItemType: workItem.workflowSnapshot.workItemType,
+    actions: [...completedInputs, ...normalizedFuture],
+  }, { availableVpIds });
+  const stageById = new Map(workflowSnapshot.stages.map(stage => [stage.id, stage]));
+
+  return {
+    proposalId,
+    reason: typeof proposal.reason === 'string' ? proposal.reason.trim().slice(0, 4_000) : '',
+    basePlanRevision,
+    workflowSnapshot,
+    unfinished,
+    nextActions: normalizedFuture.map(input => {
+      const prior = unfinishedByStage.get(input.id) || null;
+      const nextAction = actionForStage(stageById.get(input.id), { ...workItem, workflowSnapshot }, []);
+      return { prior, nextAction };
+    }),
+  };
+}
+
 export function applyReplanMutation({ workItem, action, actions, proposal, availableVpIds = null }) {
   if (workItem.workflowSnapshot?.executionMode !== 'graph'
       || action?.type !== 'triage'
@@ -283,7 +380,7 @@ export function applyReplanMutation({ workItem, action, actions, proposal, avail
   }, { availableVpIds });
   const stageById = new Map(workflowSnapshot.stages.map(stage => [stage.id, stage]));
   const context = (Array.isArray(action.context) ? action.context : [])
-    .filter(entry => entry?.type !== 'replan-barrier');
+    .filter(entry => entry?.type !== 'replan-barrier' && entry?.type !== 'input');
   return {
     proposalId,
     basePlanRevision,

package/yeaft/work-center/projection.js

@@ -732,6 +732,7 @@ function enforceWorkItemBrowserDtoBudget(value, options = {}) {
     omittedActionCount: originalCount,
     createdAt: count(workItem.createdAt),
     updatedAt: count(workItem.updatedAt),
+    coordinatorRevision: count(workItem.coordinatorRevision),
   };
   if (options.event === true) dto.workItem = minimalWorkItem;
   else return minimalWorkItem;
@@ -845,6 +846,9 @@ export function projectWorkItemDetail(detail) {
   const projected = {
     id: detail.id,
     revision: detail.revision,
+    planRevision: count(detail.planRevision),
+    ledgerRevision: count(detail.ledgerRevision),
+    coordinatorRevision: count(detail.coordinatorRevision),
     title: detail.title,
     goal: detail.goal,
     acceptanceCriteria: Array.isArray(detail.acceptanceCriteria) ? detail.acceptanceCriteria : [],
@@ -870,8 +874,21 @@ export function projectWorkItemDetail(detail) {
     linkedSessionIds: Array.isArray(detail.linkedSessionIds) ? detail.linkedSessionIds : [],
     messages: (Array.isArray(detail.messages) ? detail.messages : []).slice(-100).map(message => ({
       id: String(message.id || ''),
+      turnId: String(message.turnId || message.id || ''),
+      role: message.role === 'assistant' ? 'assistant' : message.role === 'legacy_instruction' ? 'legacy_instruction' : 'user',
       text: truncateUtf8(message.text || '', MAX_ACTION_MESSAGE_CHARS),
+      status: ['thinking', 'completed', 'failed'].includes(message.status) ? message.status : 'completed',
+      error: truncateUtf8(message.error || '', MAX_ACTION_DIAGNOSTIC_CHARS) || null,
+      decision: message.decision && typeof message.decision === 'object' ? {
+        kind: ['answer', 'guide_actions', 'replan'].includes(message.decision.kind)
+          ? message.decision.kind : null,
+        reason: truncateUtf8(message.decision.reason || '', MAX_ACTION_DIAGNOSTIC_CHARS),
+        changedContract: message.decision.changedContract === true,
+        affectedActionIds: Array.isArray(message.decision.affectedActionIds)
+          ? message.decision.affectedActionIds.map(id => String(id)).slice(0, 8) : [],
+      } : null,
       createdAt: count(message.createdAt),
+      updatedAt: count(message.updatedAt || message.createdAt),
     })),
     attachments: projectAttachments(detail.attachments),
     createdAt: detail.createdAt,
@@ -900,6 +917,9 @@ export function projectWorkItemSummary(detail) {
     return {
       id: detail.id,
       revision: detail.revision,
+      planRevision: count(detail.planRevision),
+      ledgerRevision: count(detail.ledgerRevision),
+      coordinatorRevision: count(detail.coordinatorRevision),
       title: detail.title,
       goal: detail.goal,
       workItemType: detail.workflowSnapshot?.workItemType || detail.workItemType || null,
@@ -931,6 +951,9 @@ export function projectWorkItemSummary(detail) {
   return {
     id: detail.id,
     revision: detail.revision,
+    planRevision: count(detail.planRevision),
+    ledgerRevision: count(detail.ledgerRevision),
+    coordinatorRevision: count(detail.coordinatorRevision),
     title: detail.title,
     goal: detail.goal,
     workItemType: detail.workflowSnapshot?.workItemType || detail.workItemType || null,

package/yeaft/work-center/runner.js

@@ -578,7 +578,7 @@ function completionContract(action, workItem) {
   "acceptanceChecks": ${JSON.stringify(acceptanceChecks)},
   "waitingReason": null,
   "error": null${reviewField}${triageField}${planField}
-}\nFor completed, provide at least one concrete evidence item and exactly one acceptanceChecks entry for every current acceptance criterion, in the same order, with status passed, deferred, or not_applicable and a non-empty evidence reference. Triage must use its proposed criteria when submitting a contractPatch. Test, approved review, and deliver require every criterion to be passed; if a criterion is not applicable, triage must remove or rewrite it through contractPatch before verification. This is a deterministic submission gate, not independent proof: later test, review, and deliver Actions must verify the claims. A model turn ending is not completion. Use waiting when user or external input is required. Use retryable only for a transient failure. Do not start background jobs or delegate this Action.`;
+}\nFor completed, provide at least one concrete evidence item and exactly one acceptanceChecks entry for every current acceptance criterion, in the same order, with status passed, deferred, or not_applicable and a non-empty evidence reference. Triage must use its proposed criteria when submitting a contractPatch. An intermediate Action may defer criteria outside its task-specific expected result; the final deliver Action, and an approved review with no downstream work, require every criterion to pass. If a criterion is no longer applicable, ask the WorkItem Coordinator to revise the contract instead of pretending it passed. This is a deterministic submission gate, not independent proof: later verification and delivery Actions must verify the claims. A model turn ending is not completion. Use waiting when user or external input is required. Use retryable only for a transient failure. Do not start background jobs or delegate this Action.`;
 }
 
 function safeCheckpointUrl(value) {

package/yeaft/work-center/service.js

@@ -105,6 +105,7 @@ export class WorkCenterService {
     this.controller = options.controller || new WorkflowController(this.store, {
       listAvailableVpIds: options.listAvailableVpIds,
     });
+    this.coordinator = options.coordinator || null;
     this.onEvent = typeof options.onEvent === 'function' ? options.onEvent : () => {};
     this.watcher = new WorkItemWatcher({
       store: this.store,
@@ -271,14 +272,22 @@ export class WorkCenterService {
         return { id, deleted: true, cleanupWarning };
       }
       case 'work_item_message': {
+        if (!this.coordinator) throw new Error('Work Center Coordinator is unavailable');
         const id = requiredString(payload.id, 'id');
-        const detail = this.controller.message(id, {
+        const turn = this.coordinator.message(id, {
           text: typeof payload.text === 'string' ? payload.text : '',
           revision: payload.revision,
+          planRevision: payload.planRevision,
+          ledgerRevision: payload.ledgerRevision,
+          coordinatorRevision: payload.coordinatorRevision,
+        }, {
+          onUpdate: (type, workItem) => {
+            this.watcher.abortInvalidWorkItemRuns(id);
+            this.#emit({ type, workItem });
+          },
         });
-        this.watcher.notifyWorkItemInput(id);
-        this.#emit({ type: 'work_item.message_added', workItem: detail });
-        return detail;
+        turn.task.catch(() => {});
+        return { accepted: true, turnId: turn.detail.messages?.at(-1)?.turnId || null };
       }
       case 'retry_action': {
         const id = requiredString(payload.id, 'id');
@@ -296,6 +305,10 @@ export class WorkCenterService {
       }
       case 'action_input': {
         const id = requiredString(payload.id, 'id');
+        const generation = Number(payload.generation);
+        if (!Number.isInteger(generation) || generation < 1) {
+          throw new Error('generation must be a positive integer');
+        }
         const workItem = this.#requiredItem(id);
         let addedAttachments = [];
         let detail;
@@ -308,7 +321,7 @@ export class WorkCenterService {
             text: typeof payload.text === 'string' ? payload.text : '',
             actionId: typeof payload.actionId === 'string' ? payload.actionId : '',
             revision: payload.revision,
-            generation: payload.generation,
+            generation,
             addedAttachmentCount: addedAttachments.length,
             addedAttachments,
             attachments: [...(workItem.attachments || []), ...addedAttachments],
@@ -429,6 +442,7 @@ export class WorkCenterService {
   }
 
   async shutdown() {
+    await this.coordinator?.shutdown?.();
     await this.watcher.stop();
     try { await this.watcher.runner?.shutdown?.(); } catch {}
     try { await this.watcher.runner?.trace?.close?.(); } catch {}