@yeaft/webchat-agent 1.0.247 → 1.0.248

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.247",
+  "version": "1.0.248",
   "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,6 +5,7 @@ import { defaultRegistry } from '../vp/registry.js';
 import { scanVpLibrary } from '../vp/vp-store.js';
 import { WorkCenterService } from './service.js';
 import { WorkItemRunner } from './runner.js';
+import { WorkItemCoordinator } from './coordinator.js';
 import { projectWorkCenterEvent, projectWorkItemDetail } from './projection.js';
 import { previewWorkCenterPlan } from './planner.js';
 import { readWorkCenterSettings, writeWorkCenterSettings } from './settings.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;
 }
 

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 {

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();
+  }
+}