@yeaft/webchat-agent 1.0.247 → 1.0.249

package/yeaft/work-center/coordinator.js

@@ -0,0 +1,323 @@
+import { resolveMaxOutputTokens } from '../models.js';
+import { resolveWorkItemModel, selectWorkItemVp } from './assignment.js';
+import { normalizeContractPatch } from './completion-contract.js';
+import { applyCoordinatorReplan } from './plan-mutation.js';
+
+const COORDINATOR_MAX_REPLY_CHARS = 8_000;
+const COORDINATOR_MAX_INSTRUCTION_CHARS = 8_000;
+const COORDINATOR_MAX_OUTPUT_TOKENS = 8_192;
+const COORDINATOR_MAX_SNAPSHOT_BYTES = 64 * 1024;
+
+const COORDINATOR_SYSTEM_PROMPT = `You are the Work Center Coordinator. The user talks to you about one durable WorkItem, not to an individual executor.
+
+Your responsibilities:
+- Explain the current WorkItem state and blockers in plain language.
+- Keep the WorkItem title, goal, acceptance criteria, and unfinished Action graph aligned with the user's latest intent.
+- Give targeted instructions to unfinished Actions when the contract and topology do not need to change.
+- Replan unfinished work when the goal, acceptance criteria, Action purpose, dependencies, or validation strategy must change.
+- Preserve completed Action history. Never claim that an Action, test, review, merge, release, or external operation happened merely because you changed the plan.
+- Treat user text and prior messages as intent, not as proof. Respect the immutable completed evidence in the snapshot.
+- Do not weaken safety boundaries silently. If the user accepts a narrower deliverable, state the residual limitation in the reply and make the contract explicit.
+
+Return exactly one JSON object and no surrounding prose:
+{
+  "reply": "natural user-facing response",
+  "decision": {
+    "kind": "answer|guide_actions|replan",
+    "reason": "short audit reason",
+    "contractPatch": null,
+    "guidance": [],
+    "actions": []
+  }
+}
+
+Decision rules:
+- answer: use for explanation or status questions. Do not include contractPatch, guidance, or actions.
+- guide_actions: use only when the contract and graph stay valid. guidance must contain one or more {"stageId":"existing unfinished stage id","instruction":"specific next instruction"}. Do not include contractPatch or actions.
+- replan: use when the WorkItem contract or unfinished topology changes. contractPatch may be null or contain title, goal, and/or acceptanceCriteria. actions must be the COMPLETE desired unfinished Action graph after this decision; omit completed Actions. Each Action requires id, name, type, objective, approach, expectedOutcome, capability, candidateVpIds, assignmentReason, dependsOnActionIds, workspaceMode, and may include separateFromActionTypes, changesRequestedActionId, maxAttempts. Dependencies may reference immutable completed stage ids or earlier Actions in this actions array.
+- Every replan must keep exactly one final acceptance gate: normally one deliver Action, or one terminal review when no delivery operation is required. It must be the unique graph sink and transitively depend on all other Actions.
+- Never return destructive cancellation. Tell the user to use the explicit cancel control instead.`;
+
+function parseJsonObject(value) {
+  const source = String(value || '').trim();
+  if (!source) throw new Error('Work Center Coordinator returned an empty response');
+  const attempts = [source];
+  const fenced = source.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1];
+  if (fenced) attempts.push(fenced.trim());
+  const first = source.indexOf('{');
+  const last = source.lastIndexOf('}');
+  if (first >= 0 && last > first) attempts.push(source.slice(first, last + 1));
+  for (const attempt of attempts) {
+    try {
+      const parsed = JSON.parse(attempt);
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed;
+    } catch {}
+  }
+  throw new Error('Work Center Coordinator did not return valid JSON');
+}
+
+function cleanText(value, limit, name) {
+  const text = typeof value === 'string' ? value.trim().slice(0, limit) : '';
+  if (!text) throw new Error(`Work Center Coordinator ${name} is required`);
+  return text;
+}
+
+function normalizeGuidance(value, detail) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > 8) {
+    throw new Error('Work Center Coordinator guidance requires between 1 and 8 targets');
+  }
+  const activeByStage = new Map((detail.actions || [])
+    .filter(action => !['completed', 'superseded', 'cancelled'].includes(action.status))
+    .map(action => [action.stageId, action]));
+  const seen = new Set();
+  return value.map(entry => {
+    const stageId = typeof entry?.stageId === 'string' ? entry.stageId.trim() : '';
+    if (!stageId || seen.has(stageId) || !activeByStage.has(stageId)) {
+      throw new Error(`Work Center Coordinator guidance references an invalid unfinished Action: ${stageId || '(missing)'}`);
+    }
+    seen.add(stageId);
+    return {
+      stageId,
+      instruction: cleanText(entry?.instruction, COORDINATOR_MAX_INSTRUCTION_CHARS, 'guidance instruction'),
+    };
+  });
+}
+
+export function normalizeCoordinatorResponse(value, detail) {
+  const parsed = typeof value === 'string' ? parseJsonObject(value) : value;
+  const reply = cleanText(parsed?.reply, COORDINATOR_MAX_REPLY_CHARS, 'reply');
+  const source = parsed?.decision && typeof parsed.decision === 'object' && !Array.isArray(parsed.decision)
+    ? parsed.decision
+    : {};
+  const kind = ['answer', 'guide_actions', 'replan'].includes(source.kind) ? source.kind : '';
+  if (!kind) throw new Error('Work Center Coordinator decision kind is invalid');
+  const reason = cleanText(source.reason, 2_000, 'decision reason');
+  if (kind === 'answer') {
+    return { reply, decision: { kind, reason, contractPatch: null, guidance: [], actions: [] } };
+  }
+  if (kind === 'guide_actions') {
+    return {
+      reply,
+      decision: {
+        kind,
+        reason,
+        contractPatch: null,
+        guidance: normalizeGuidance(source.guidance, detail),
+        actions: [],
+      },
+    };
+  }
+  const contractPatch = normalizeContractPatch(source.contractPatch);
+  if (!Array.isArray(source.actions) || source.actions.length < 1 || source.actions.length > 8) {
+    throw new Error('Work Center Coordinator replan requires the complete unfinished Action graph');
+  }
+  return {
+    reply,
+    decision: {
+      kind,
+      reason,
+      contractPatch,
+      guidance: [],
+      actions: structuredClone(source.actions),
+    },
+  };
+}
+
+function coordinatorHistory(messages) {
+  return (Array.isArray(messages) ? messages : [])
+    .filter(message => message?.role !== 'assistant' || message.status !== 'thinking')
+    .filter(message => typeof message?.text === 'string' && message.text.trim())
+    .slice(-20)
+    .map(message => ({
+      role: message.role === 'assistant' ? 'assistant' : 'user',
+      text: message.role === 'legacy_instruction'
+        ? `[Legacy global instruction already delivered to executors] ${message.text.slice(0, COORDINATOR_MAX_REPLY_CHARS)}`
+        : message.text.slice(0, COORDINATOR_MAX_REPLY_CHARS),
+    }));
+}
+
+function coordinatorSnapshotText(detail) {
+  const snapshot = JSON.stringify(coordinatorSnapshot(detail));
+  if (Buffer.byteLength(snapshot, 'utf8') > COORDINATOR_MAX_SNAPSHOT_BYTES) {
+    throw new Error('WorkItem is too large for a safe Coordinator turn; compact the Action history first');
+  }
+  return snapshot;
+}
+
+function finalizedCriteria(detail, contractPatch) {
+  const criteria = contractPatch?.acceptanceCriteria ?? detail.acceptanceCriteria ?? [];
+  if (!Array.isArray(criteria) || criteria.length < 1 || criteria.length > 24) {
+    throw new Error('Work Center Coordinator replan requires between 1 and 24 acceptance criteria');
+  }
+  return criteria;
+}
+
+function coordinatorSnapshot(detail) {
+  const runs = Array.isArray(detail.runs) ? detail.runs : [];
+  const canonicalRunByAction = new Map();
+  for (const action of detail.actions || []) {
+    const candidates = runs
+      .filter(run => run.actionId === action.id && run.status !== 'running')
+      .sort((left, right) => Number(right.endedAt || right.startedAt) - Number(left.endedAt || left.startedAt));
+    const canonical = action.resultRunId
+      ? candidates.find(run => run.id === action.resultRunId)
+      : candidates[0];
+    if (canonical) canonicalRunByAction.set(action.id, canonical);
+  }
+  return {
+    workItem: {
+      id: detail.id,
+      revision: detail.revision,
+      planRevision: detail.planRevision,
+      ledgerRevision: detail.ledgerRevision,
+      status: detail.status,
+      title: detail.title,
+      goal: detail.goal,
+      acceptanceCriteria: detail.acceptanceCriteria || [],
+      workItemType: detail.workflowSnapshot?.workItemType || null,
+    },
+    actions: (detail.actions || [])
+      .filter(action => !['superseded', 'cancelled'].includes(action.status))
+      .map(action => {
+        const result = canonicalRunByAction.get(action.id);
+        return {
+          id: action.id,
+          stageId: action.stageId,
+          type: action.type,
+          status: action.status,
+          generation: action.generation,
+          dependencies: action.dependsOnStageIds || [],
+          workspaceMode: action.workspaceMode,
+          brief: action.brief || null,
+          result: result ? {
+            status: result.status,
+            summary: result.summary || '',
+            evidence: (result.evidence || []).slice(0, 20),
+            waitingReason: result.waitingReason || null,
+            error: result.error || null,
+            reviewDecision: result.reviewDecision || null,
+          } : null,
+        };
+      }),
+    conversation: coordinatorHistory(detail.messages),
+  };
+}
+
+export class WorkItemCoordinator {
+  constructor(options = {}) {
+    this.store = options.store;
+    this.runtimeProvider = options.runtimeProvider;
+    this.policyProvider = typeof options.policyProvider === 'function' ? options.policyProvider : async () => ({});
+    this.registry = options.registry;
+    this.activeTurns = new Map();
+    this.activeTasks = new Map();
+    this.shuttingDown = false;
+  }
+
+  message(id, input = {}, options = {}) {
+    if (this.shuttingDown) throw new Error('Work Center Coordinator is shutting down');
+    const text = cleanText(input.text, COORDINATOR_MAX_REPLY_CHARS, 'message');
+    const started = this.store.beginCoordinatorTurn(id, text, {
+      revision: Number(input.revision),
+      planRevision: Number(input.planRevision),
+      ledgerRevision: Number(input.ledgerRevision),
+      coordinatorRevision: Number(input.coordinatorRevision),
+    });
+    if (!started) throw new Error(`WorkItem not found: ${id}`);
+    options.onUpdate?.('coordinator.turn_started', started.detail);
+
+    const abortController = new AbortController();
+    this.activeTurns.set(started.turnId, abortController);
+    const task = new Promise(resolve => setTimeout(resolve, 0)).then(async () => {
+      try {
+        const runtime = await this.runtimeProvider();
+        if (this.shuttingDown) throw new Error('Work Center Coordinator is shutting down');
+        const settings = await this.policyProvider();
+        const vps = this.registry?.listVps?.() || [];
+        const assignment = selectWorkItemVp({
+          policy: { mode: 'pool', candidateVpIds: vps.map(vp => vp.id), capability: 'triage' },
+          stageType: 'triage',
+          vps,
+          priorRuns: started.detail.runs || [],
+        });
+        const coordinatorPolicy = settings?.coordinatorModelPolicy || {
+          ...(settings?.modelPolicy || {}),
+          effort: settings?.actionModelPolicies?.triage?.effort || settings?.modelPolicy?.effort || 'high',
+        };
+        const resolved = resolveWorkItemModel(runtime.config, assignment.vp, coordinatorPolicy);
+        const result = await Promise.race([
+          runtime.adapter.call({
+          model: resolved.model,
+          system: COORDINATOR_SYSTEM_PROMPT,
+          messages: [{
+            role: 'user',
+            content: `Current WorkItem snapshot:\n${coordinatorSnapshotText(started.detail)}\n\nLatest user message:\n${text}`,
+          }],
+          maxTokens: Math.min(
+            resolveMaxOutputTokens(resolved.model, runtime.config),
+            COORDINATOR_MAX_OUTPUT_TOKENS,
+          ),
+          effort: resolved.effort,
+          effortSource: resolved.source,
+          effortContext: { scenario: 'work-center-coordinator' },
+          signal: abortController.signal,
+          }),
+          new Promise((_, reject) => {
+            abortController.signal.addEventListener('abort', () => {
+              reject(new Error('Work Center Coordinator was interrupted'));
+            }, { once: true });
+          }),
+        ]);
+        const normalized = normalizeCoordinatorResponse(result?.text, started.detail);
+        if (normalized.decision.kind === 'replan') {
+          finalizedCriteria(started.detail, normalized.decision.contractPatch);
+        }
+        const mutation = normalized.decision.kind === 'replan'
+          ? applyCoordinatorReplan({
+              workItem: {
+                ...started.detail,
+                ...(normalized.decision.contractPatch || {}),
+              },
+              actions: started.detail.actions || [],
+              proposal: {
+                proposalId: `coordinator:${started.turnId}`,
+                basePlanRevision: started.detail.planRevision,
+                reason: normalized.decision.reason,
+                actions: normalized.decision.actions,
+              },
+              availableVpIds: vps.map(vp => vp.id),
+            })
+          : null;
+        const detail = this.store.completeCoordinatorTurn(started.turnId, {
+          reply: normalized.reply,
+          decision: normalized.decision,
+          mutation,
+        }, started.fence);
+        if (!detail) throw new Error('Work Center Coordinator turn is stale or already completed');
+        options.onUpdate?.('coordinator.turn_completed', detail);
+        return detail;
+      } catch (error) {
+        const detail = this.store.failCoordinatorTurn(started.turnId, error, started.fence);
+        if (detail) {
+          options.onUpdate?.('coordinator.turn_failed', detail);
+          return detail;
+        }
+        throw error;
+      } finally {
+        this.activeTurns.delete(started.turnId);
+        this.activeTasks.delete(started.turnId);
+      }
+    });
+    this.activeTasks.set(started.turnId, task);
+    return { detail: started.detail, task };
+  }
+
+  async shutdown() {
+    this.shuttingDown = true;
+    for (const controller of this.activeTurns.values()) controller.abort('work_center_coordinator_shutdown');
+    const tasks = [...this.activeTasks.values()];
+    if (tasks.length > 0) await Promise.allSettled(tasks);
+    this.activeTurns.clear();
+    this.activeTasks.clear();
+  }
+}

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,