@yeaft/webchat-agent 1.0.365 → 1.0.367

package/yeaft/work-center/coordinator.js

@@ -9,6 +9,8 @@ import {
 } from '../llm/adapter.js';
 import { resolveWorkItemModel, selectWorkItemVp } from './assignment.js';
 import { normalizeContractPatch } from './completion-contract.js';
+import { prepareDynamicActionMutation } from './dynamic-coordination.js';
+import { isDynamicWorkItem } from './execution-mode.js';
 import { applyCoordinatorReplan } from './plan-mutation.js';
 import { buildWorkItemAttachmentContext } from './attachments.js';
 import { sanitizeDiagnosticText } from './debug-projection.js';
@@ -124,17 +126,25 @@ function coordinatorStageReferences(detail) {
   };
 }
 
-function boundedAction(action, result, stageReferences, compact = false) {
+function boundedAction(action, result, stageReferences, compact = false, dynamic = false) {
   const brief = action?.brief && typeof action.brief === 'object' ? action.brief : null;
   return {
-    stageId: stageReferences.project(action?.stageId),
+    ...(dynamic
+      ? {
+          actionId: truncateUtf8(action?.id, 256),
+          sourceActionIds: (Array.isArray(action?.sourceActionIds) ? action.sourceActionIds : [])
+            .slice(0, 8).map(value => truncateUtf8(value, 256)).filter(Boolean),
+        }
+      : { stageId: stageReferences.project(action?.stageId) }),
     type: truncateUtf8(action?.type, 64),
     status: truncateUtf8(action?.status, 64),
     generation: Math.max(1, Number(action?.generation) || 1),
-    dependencies: (Array.isArray(action?.dependsOnStageIds) ? action.dependsOnStageIds : [])
-      .slice(0, 8)
-      .map(value => stageReferences.project(value))
-      .filter(Boolean),
+    ...(dynamic ? {} : {
+      dependencies: (Array.isArray(action?.dependsOnStageIds) ? action.dependsOnStageIds : [])
+        .slice(0, 8)
+        .map(value => stageReferences.project(value))
+        .filter(Boolean),
+    }),
     workspaceMode: truncateUtf8(action?.workspaceMode, 64),
     ...(!compact && brief ? {
       brief: {
@@ -146,7 +156,15 @@ function boundedAction(action, result, stageReferences, compact = false) {
     result: result ? {
       status: truncateUtf8(result.status, 64),
       summary: truncateUtf8(result.summary, compact ? 256 : 768),
-      ...(!compact ? { evidence: boundedEvidence(result.evidence) } : {}),
+      ...(!compact ? {
+        evidence: boundedEvidence(result.evidence),
+        acceptanceChecks: (Array.isArray(result.acceptanceChecks) ? result.acceptanceChecks : [])
+          .slice(0, 24).map(check => ({
+            criterion: truncateUtf8(check?.criterion, 512),
+            status: truncateUtf8(check?.status, 64),
+            evidence: truncateUtf8(check?.evidence, 1_000),
+          })),
+      } : {}),
       waitingReason: truncateUtf8(result.waitingReason, 384) || null,
       error: truncateUtf8(result.error, 384) || null,
       reviewDecision: truncateUtf8(result.reviewDecision, 64) || null,
@@ -188,11 +206,42 @@ Decision rules:
 - Stage ids in the snapshot may be bounded aliases. Echo them exactly; the runtime resolves them to durable identities.
 - Never return destructive cancellation. Tell the user to use the explicit cancel control instead.`;
 
-function coordinatorSystemPrompt(language) {
+const DYNAMIC_COORDINATOR_SYSTEM_PROMPT = `You are the persistent Work Center Coordinator. You own progress toward one durable WorkItem.
+
+Observe the current contract, Action journal, canonical Run evidence, and conversation. Decide only the next justified step; never predict or emit a complete workflow graph.
+
+Return exactly one JSON object and no surrounding prose:
+{
+  "reply": "natural user-facing response",
+  "decision": {
+    "kind": "answer|create_actions|guide_actions|request_human|complete",
+    "reason": "short audit reason",
+    "question": null,
+    "workItemType": null,
+    "contractPatch": null,
+    "supersedeActionIds": [],
+    "guidance": [],
+    "actions": [],
+    "completion": null
+  }
+}
+
+Rules:
+- answer: explain state only. Never use it for an automatic advance trigger.
+- create_actions: create 1..8 currently runnable Actions. Every Action needs type, objective, approach, expectedOutcome, capability, candidateVpIds, assignmentReason, sourceActionIds, workspaceMode, and optional maxAttempts/separateFromActionTypes. sourceActionIds are context/audit references, never scheduling dependencies. Do not include dependsOnActionIds, dependsOnStageIds, stages, or a graph.
+- guide_actions: target 1..8 unfinished non-running Actions by durable actionId.
+- request_human: only when external information or a user decision is genuinely required.
+- complete: only when every acceptance criterion has canonical completed Run evidence and there are no unfinished Actions. Include summary, ordered acceptanceResults with evidenceRunIds, evidenceRunIds, and residualRisks.
+- Preserve completed Action history. Never claim tests, review, merge, release, or external effects without canonical Run evidence.
+- Action templates are reusable capabilities, not a prescribed workflow. Create the smallest useful Action boundary, not tool-call-sized work.
+- Never return destructive cancellation. The user owns the explicit cancel control.`;
+
+function coordinatorSystemPrompt(language, detail) {
   const userLanguage = coordinatorLanguage(language) === 'zh'
     ? 'Simplified Chinese (zh-CN)'
     : 'English';
-  return `${COORDINATOR_SYSTEM_PROMPT}
+  const base = isDynamicWorkItem(detail) ? DYNAMIC_COORDINATOR_SYSTEM_PROMPT : COORDINATOR_SYSTEM_PROMPT;
+  return `${base}
 
 User-facing language: ${userLanguage}. Write reply and question in that language. Keep JSON property names and decision enum values in English. Never expose deterministic validator errors as the user-facing reply; explain the underlying issue plainly.`;
 }
@@ -327,19 +376,22 @@ 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 dynamic = isDynamicWorkItem(detail);
+  const active = (detail.actions || [])
+    .filter(action => !['completed', 'superseded', 'cancelled'].includes(action.status));
+  const activeByReference = new Map(active.map(action => [dynamic ? action.id : action.stageId, action]));
   const stageReferences = coordinatorStageReferences(detail);
   const seen = new Set();
   return value.map(entry => {
-    const stageId = stageReferences.resolve(entry?.stageId);
-    if (!stageId || seen.has(stageId) || !activeByStage.has(stageId)) {
-      throw new Error(`Work Center Coordinator guidance references an invalid unfinished Action: ${stageId || '(missing)'}`);
+    const reference = dynamic
+      ? (typeof entry?.actionId === 'string' ? entry.actionId.trim() : '')
+      : stageReferences.resolve(entry?.stageId);
+    if (!reference || seen.has(reference) || !activeByReference.has(reference)) {
+      throw new Error(`Work Center Coordinator guidance references an invalid unfinished Action: ${reference || '(missing)'}`);
     }
-    seen.add(stageId);
+    seen.add(reference);
     return {
-      stageId,
+      ...(dynamic ? { actionId: reference } : { stageId: reference }),
       instruction: cleanText(entry?.instruction, COORDINATOR_MAX_INSTRUCTION_CHARS, 'guidance instruction'),
     };
   });
@@ -368,9 +420,14 @@ export function normalizeCoordinatorResponse(value, detail, options = {}) {
   const source = parsed?.decision && typeof parsed.decision === 'object' && !Array.isArray(parsed.decision)
     ? parsed.decision
     : {};
-  const allowedKinds = options.recovery === true
-    ? ['guide_actions', 'replan', 'request_human']
-    : ['answer', 'guide_actions', 'replan'];
+  const dynamic = isDynamicWorkItem(detail);
+  const allowedKinds = dynamic
+    ? (options.automatic === true
+      ? ['create_actions', 'guide_actions', 'request_human', 'complete']
+      : ['answer', 'create_actions', 'guide_actions', 'request_human', 'complete'])
+    : (options.recovery === true
+      ? ['guide_actions', 'replan', 'request_human']
+      : ['answer', 'guide_actions', 'replan']);
   const kind = allowedKinds.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');
@@ -411,6 +468,41 @@ export function normalizeCoordinatorResponse(value, detail, options = {}) {
       },
     };
   }
+  if (dynamic && kind === 'complete') {
+    return {
+      reply,
+      decision: {
+        kind,
+        reason,
+        completion: source.completion,
+        contractPatch: null,
+        guidance: [],
+        actions: [],
+      },
+    };
+  }
+  if (dynamic && kind === 'create_actions') {
+    const contractPatch = normalizeContractPatch(source.contractPatch);
+    const decision = {
+      kind,
+      reason,
+      workItemType: source.workItemType,
+      contractPatch,
+      supersedeActionIds: source.supersedeActionIds,
+      guidance: [],
+      actions: source.actions,
+    };
+    return {
+      reply,
+      decision,
+      mutation: prepareDynamicActionMutation({
+        workItem: detail,
+        actions: detail.actions || [],
+        decision,
+        availableVpIds: options.availableVpIds,
+      }),
+    };
+  }
   const contractPatch = normalizeContractPatch(source.contractPatch);
   if (!Array.isArray(source.actions)) {
     throw new Error('Work Center Coordinator replan requires the complete unfinished Action graph');
@@ -496,6 +588,7 @@ function coordinatorSnapshot(detail) {
     throw new Error('WorkItem contract cannot be represented within the Coordinator snapshot budget');
   }
 
+  const dynamic = isDynamicWorkItem(detail);
   const currentActions = (Array.isArray(detail.actions) ? detail.actions : [])
     .filter(action => !['superseded', 'cancelled'].includes(action.status));
   const stageReferences = coordinatorStageReferences(detail);
@@ -510,20 +603,24 @@ function coordinatorSnapshot(detail) {
     canonicalRunByAction.get(action.id),
     stageReferences,
     action.status === 'completed',
+    dynamic,
   ));
   let actions = boundedJsonArray(projectedActions, COORDINATOR_MAX_ACTIONS_BYTES);
-  let includedActionIdentities = new Set(actions.map(action => `${action.stageId}:${action.generation}`));
-  if (unfinished.some(action => !includedActionIdentities.has(`${stageReferences.project(action.stageId)}:${action.generation}`))) {
+  const identity = action => `${dynamic ? action.actionId : action.stageId}:${action.generation}`;
+  const expectedIdentity = action => `${dynamic ? action.id : stageReferences.project(action.stageId)}:${action.generation}`;
+  let includedActionIdentities = new Set(actions.map(identity));
+  if (unfinished.some(action => !includedActionIdentities.has(expectedIdentity(action)))) {
     projectedActions = selected.map(action => boundedAction(
       action,
       canonicalRunByAction.get(action.id),
       stageReferences,
       true,
+      dynamic,
     ));
     actions = boundedJsonArray(projectedActions, COORDINATOR_MAX_ACTIONS_BYTES);
-    includedActionIdentities = new Set(actions.map(action => `${action.stageId}:${action.generation}`));
+    includedActionIdentities = new Set(actions.map(identity));
   }
-  if (unfinished.some(action => !includedActionIdentities.has(`${stageReferences.project(action.stageId)}:${action.generation}`))) {
+  if (unfinished.some(action => !includedActionIdentities.has(expectedIdentity(action)))) {
     throw new Error('Active Actions cannot be represented within the Coordinator snapshot budget');
   }
 
@@ -604,6 +701,34 @@ export class WorkItemCoordinator {
     });
   }
 
+  advance(mailboxId, options = {}) {
+    if (this.shuttingDown) throw new Error('Work Center Coordinator is shutting down');
+    const claim = this.store.claimCoordinatorMailbox(options.workItemId, this.ownerBootId, this.claimLeaseMs);
+    if (!claim) return null;
+    if (claim.id !== mailboxId) {
+      this.store.releaseCoordinatorMailboxClaim(
+        claim.id, this.ownerBootId, Number(claim.claim_epoch),
+      );
+      return null;
+    }
+    const started = this.store.beginDynamicCoordinatorTurn(mailboxId, {
+      ownerBootId: this.ownerBootId,
+      claimEpoch: Number(claim.claim_epoch),
+    });
+    if (!started) {
+      this.store.releaseCoordinatorMailboxClaim(
+        claim.id, this.ownerBootId, Number(claim.claim_epoch),
+      );
+      return null;
+    }
+    options.onUpdate?.('coordinator.advance_started', started.detail);
+    const trigger = started.detail.messages?.find(message => message.turnId === started.turnId)?.trigger;
+    const text = `Automatic WorkItem advance trigger: ${JSON.stringify(trigger || { kind: claim.kind })}. `
+      + 'Observe the current durable state and choose the next justified Actions, a genuine human request, '
+      + 'or evidence-backed completion. Do not stop merely because the previous Action ended.';
+    return this.#scheduleTurn(started, { text, recovery: false, options });
+  }
+
   recover(id, options = {}) {
     if (this.shuttingDown) throw new Error('Work Center Coordinator is shutting down');
     const detail = this.store.getWorkItemDetail(id);
@@ -746,7 +871,7 @@ export class WorkItemCoordinator {
                 : latestMessage;
               const requestBody = {
                 model: resolved.model,
-                system: coordinatorSystemPrompt(language),
+                system: coordinatorSystemPrompt(language, started.detail),
                 messages: [{ role: 'user', content }],
                 maxTokens: Math.min(
                   resolveMaxOutputTokens(resolved.model, runtime.config),
@@ -799,8 +924,11 @@ export class WorkItemCoordinator {
             }
             normalized = normalizeCoordinatorResponse(result?.text, started.detail, {
               recovery,
+              automatic: started.fence.automatic === true,
               recoveryActionId: started.fence.recovery?.actionId || null,
+              availableVpIds: vps.map(vp => vp.id),
             });
+            mutation = normalized.mutation || null;
             if (normalized.decision.kind === 'replan') {
               finalizedCriteria(started.detail, normalized.decision.contractPatch);
               mutation = applyCoordinatorReplan({
@@ -873,7 +1001,9 @@ export class WorkItemCoordinator {
         attemptCount,
       }, started.fence);
       if (!detail) return this.store.getWorkItemDetail(started.detail.id);
-      options.onUpdate?.(recovery ? 'coordinator.recovery_completed' : 'coordinator.turn_completed', detail);
+      options.onUpdate?.(started.fence.automatic === true
+        ? 'coordinator.advance_completed'
+        : recovery ? 'coordinator.recovery_completed' : 'coordinator.turn_completed', detail);
       return detail;
     } catch (error) {
       if (providerTurn?.status === 'responded') {

package/yeaft/work-center/durable-model.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 
-export const WORK_CENTER_SCHEMA_VERSION = 35;
+export const WORK_CENTER_SCHEMA_VERSION = 37;
 
 const MIGRATIONS = [
   ['23-conversation-stream', migrateConversationStream],
@@ -16,6 +16,8 @@ const MIGRATIONS = [
   ['33-coordinator-provider-turns', migrateCoordinatorProviderTurns],
   ['34-engine-turn-status-repair', repairEngineTurnStatusContract],
   ['35-coordinator-provider-claims', migrateCoordinatorProviderClaims],
+  ['36-dynamic-coordination', migrateDynamicCoordination],
+  ['37-run-acceptance-checks', migrateRunAcceptanceChecks],
 ];
 
 const MIGRATION_ALIASES = new Map([
@@ -478,6 +480,54 @@ function migrateCoordinatorProviderClaims(db) {
   `);
 }
 
+function migrateDynamicCoordination(db) {
+  if (!hasColumn(db, 'work_items', 'coordination_mode')) {
+    db.exec("ALTER TABLE work_items ADD COLUMN coordination_mode TEXT NOT NULL DEFAULT 'legacy'");
+  }
+  if (!hasColumn(db, 'work_items', 'final_result')) {
+    db.exec('ALTER TABLE work_items ADD COLUMN final_result TEXT');
+  }
+  if (!hasColumn(db, 'actions', 'source_action_ids')) {
+    db.exec("ALTER TABLE actions ADD COLUMN source_action_ids TEXT NOT NULL DEFAULT '[]'");
+  }
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_work_items_dynamic_status
+      ON work_items(coordination_mode, status, updated_at);
+    CREATE TRIGGER IF NOT EXISTS trg_work_item_final_result_immutable
+    BEFORE UPDATE OF final_result ON work_items
+    WHEN OLD.final_result IS NOT NULL AND NEW.final_result IS NOT OLD.final_result
+    BEGIN
+      SELECT RAISE(ABORT, 'WorkItem final result is immutable');
+    END;
+  `);
+}
+
+function migrateRunAcceptanceChecks(db) {
+  if (!hasColumn(db, 'runs', 'acceptance_checks')) {
+    db.exec("ALTER TABLE runs ADD COLUMN acceptance_checks TEXT NOT NULL DEFAULT '[]'");
+  }
+  db.exec(`
+    DROP TRIGGER IF EXISTS trg_runs_terminal_identity_immutable;
+    CREATE TRIGGER IF NOT EXISTS trg_runs_terminal_identity_immutable
+    BEFORE UPDATE ON runs
+    WHEN OLD.terminal_status IS NOT NULL AND (
+      NEW.action_id IS NOT OLD.action_id OR NEW.work_item_id IS NOT OLD.work_item_id OR
+      NEW.owner_boot_id IS NOT OLD.owner_boot_id OR NEW.lease_epoch IS NOT OLD.lease_epoch OR
+      NEW.ordinal IS NOT OLD.ordinal OR NEW.started_at IS NOT OLD.started_at OR
+      NEW.status IS NOT OLD.status OR NEW.ended_at IS NOT OLD.ended_at OR
+      NEW.terminal_status IS NOT OLD.terminal_status OR NEW.terminal_at IS NOT OLD.terminal_at OR
+      NEW.response IS NOT OLD.response OR NEW.summary IS NOT OLD.summary OR
+      NEW.evidence IS NOT OLD.evidence OR NEW.acceptance_checks IS NOT OLD.acceptance_checks OR
+      NEW.waiting_reason IS NOT OLD.waiting_reason OR NEW.error IS NOT OLD.error OR
+      NEW.failure_kind IS NOT OLD.failure_kind OR NEW.failure_code IS NOT OLD.failure_code OR
+      NEW.review_decision IS NOT OLD.review_decision OR NEW.contract_patch IS NOT OLD.contract_patch OR
+      NEW.checkpoint IS NOT OLD.checkpoint)
+    BEGIN
+      SELECT RAISE(ABORT, 'terminal Run result is immutable');
+    END;
+  `);
+}
+
 function migrateReliabilityGuards(db) {
   for (const [column, definition] of [
     ['dispatch_capability', "TEXT NOT NULL DEFAULT 'unknown'"],

package/yeaft/work-center/dynamic-coordination.js

@@ -0,0 +1,243 @@
+import { randomUUID } from 'node:crypto';
+import {
+  BUILT_IN_ACTION_TYPES,
+  MAX_WORK_ITEM_ACTIONS,
+  canonicalActionId,
+  canonicalActionInstruction,
+  normalizeActionBrief,
+  normalizeWorkCenterSettings,
+  taskSpecificActionBrief,
+} from './workflow.js';
+import {
+  DYNAMIC_COORDINATION_MODE,
+  DYNAMIC_EXECUTION_SCHEMA_VERSION,
+  isDynamicWorkItem,
+} from './execution-mode.js';
+
+export {
+  DYNAMIC_COORDINATION_MODE,
+  DYNAMIC_EXECUTION_SCHEMA_VERSION,
+  isDynamicWorkItem,
+};
+const DYNAMIC_ACTION_LIMIT = 8;
+const DYNAMIC_WORKSPACE_MODES = new Set(['read', 'shared', 'isolated-write', 'integrate']);
+
+function uniqueStrings(value) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value.map(item => String(item || '').trim()).filter(Boolean))];
+}
+
+function requiredText(value, name, limit = 2_000) {
+  const text = typeof value === 'string' ? value.trim().slice(0, limit) : '';
+  if (!text) throw new Error(`Work Center dynamic Action ${name} is required`);
+  return text;
+}
+
+/**
+ * Build the frozen policy catalog for a Coordinator-driven WorkItem. The legacy
+ * workflow_snapshot column remains the on-disk compatibility envelope, but new
+ * entries contain no stages, dependencies, or precomputed successors.
+ */
+export function resolveDynamicActionPolicySnapshot(settings, requestedWorkItemType = null) {
+  const normalized = normalizeWorkCenterSettings(settings);
+  const requested = typeof requestedWorkItemType === 'string'
+    && requestedWorkItemType.trim()
+    && requestedWorkItemType.trim().toLowerCase() !== 'auto'
+    ? canonicalActionId(requestedWorkItemType, '').slice(0, 64)
+    : '';
+  return {
+    version: 2,
+    id: 'coordinator-driven',
+    name: 'Coordinator driven',
+    planningMode: 'coordinator',
+    executionMode: 'dynamic',
+    workItemType: requested || null,
+    globalInstructions: normalized.globalInstructions,
+    modelPolicy: normalized.modelPolicy,
+    coordinatorModelPolicy: normalized.coordinatorModelPolicy,
+    actionModelPolicies: normalized.actionModelPolicies,
+    actionInstructions: normalized.actionInstructions,
+    actionTemplates: BUILT_IN_ACTION_TYPES.filter(type => type !== 'triage').map(type => ({ type })),
+  };
+}
+
+function normalizeSourceActionIds(value, actions) {
+  const ids = uniqueStrings(value);
+  const available = new Set(actions.map(action => action.id));
+  for (const id of ids) {
+    if (!available.has(id)) throw new Error(`Work Center dynamic Action references an unknown source Action: ${id}`);
+  }
+  return ids;
+}
+
+function normalizeSupersededActionIds(value, actions) {
+  const ids = uniqueStrings(value);
+  const byId = new Map(actions.map(action => [action.id, action]));
+  for (const id of ids) {
+    const action = byId.get(id);
+    if (!action || !['ready', 'waiting', 'failed'].includes(action.status)) {
+      throw new Error(`Work Center can supersede only a non-running unfinished Action: ${id}`);
+    }
+  }
+  return ids;
+}
+
+/**
+ * Normalize one just-in-time Coordinator decision into concrete durable Action
+ * records. sourceActionIds are audit/context links only and never gate dispatch.
+ */
+export function prepareDynamicActionMutation({
+  workItem,
+  actions,
+  decision,
+  availableVpIds = null,
+}) {
+  if (!isDynamicWorkItem(workItem)) {
+    throw new Error('Work Center dynamic Action creation requires a Coordinator-driven WorkItem');
+  }
+  const requested = Array.isArray(decision?.actions) ? decision.actions : [];
+  if (requested.length < 1 || requested.length > DYNAMIC_ACTION_LIMIT) {
+    throw new Error('Work Center Coordinator must create between 1 and 8 currently justified Actions');
+  }
+  const historicalCount = Array.isArray(actions) ? actions.length : 0;
+  if (historicalCount + requested.length > MAX_WORK_ITEM_ACTIONS) {
+    throw new Error(`Work Center cannot exceed ${MAX_WORK_ITEM_ACTIONS} Actions`);
+  }
+  const knownVpIds = Array.isArray(availableVpIds)
+    ? new Set(availableVpIds.map(value => String(value || '').trim()).filter(Boolean))
+    : null;
+  const supersedeActionIds = normalizeSupersededActionIds(decision.supersedeActionIds, actions);
+  const effectiveWorkItem = {
+    ...workItem,
+    ...(decision.contractPatch || {}),
+  };
+  const createdActions = requested.map((raw, index) => {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+      throw new Error('Work Center Coordinator Action specification must be an object');
+    }
+    if (Object.hasOwn(raw, 'dependsOnActionIds') || Object.hasOwn(raw, 'dependsOnStageIds')) {
+      throw new Error('Coordinator-driven Actions cannot contain dependency fields');
+    }
+    const type = canonicalActionId(raw.type, 'custom').slice(0, 64);
+    if (type === 'triage') throw new Error('Coordinator-driven WorkItems do not create triage Actions');
+    const brief = normalizeActionBrief({
+      objective: requiredText(raw.objective, 'objective'),
+      approach: requiredText(raw.approach, 'approach'),
+      expectedOutcome: requiredText(raw.expectedOutcome, 'expectedOutcome'),
+    }, type);
+    if (!taskSpecificActionBrief(brief, type)) {
+      throw new Error(`Work Center dynamic Action ${index + 1} must use a task-specific brief`);
+    }
+    const candidateVpIds = uniqueStrings(raw.candidateVpIds);
+    if (knownVpIds) {
+      const unavailable = candidateVpIds.find(vpId => !knownVpIds.has(vpId));
+      if (unavailable) throw new Error(`Work Center dynamic Action references unavailable VP "${unavailable}"`);
+    }
+    const assignmentReason = candidateVpIds.length > 0
+      ? requiredText(raw.assignmentReason, 'assignmentReason', 1_000)
+      : '';
+    const id = randomUUID();
+    const workspaceMode = DYNAMIC_WORKSPACE_MODES.has(raw.workspaceMode)
+      ? raw.workspaceMode
+      : 'shared';
+    const sourceActionIds = normalizeSourceActionIds(raw.sourceActionIds, actions);
+    if (workspaceMode === 'integrate' && sourceActionIds.length === 0) {
+      throw new Error('Work Center integrate Action requires sourceActionIds');
+    }
+    if (workspaceMode === 'integrate') {
+      const byId = new Map(actions.map(candidate => [candidate.id, candidate]));
+      const invalid = sourceActionIds.find(sourceId => (
+        byId.get(sourceId)?.workspaceMode !== 'isolated-write'
+        || byId.get(sourceId)?.status !== 'completed'
+      ));
+      if (invalid) {
+        throw new Error(`Work Center integrate Action source is not a completed isolated write: ${invalid}`);
+      }
+    }
+    const action = {
+      id,
+      type,
+      // stage_id is retained only as a legacy storage alias. Dynamic dispatch
+      // and Coordinator references use the durable Action id above.
+      stageId: id,
+      assignmentPolicy: candidateVpIds.length > 0 ? {
+        mode: 'planned',
+        capability: canonicalActionId(raw.capability, type),
+        candidateVpIds,
+        fixedVpId: null,
+        assignmentReason,
+        separateFromStageTypes: uniqueStrings(raw.separateFromActionTypes),
+      } : {
+        mode: 'auto',
+        capability: canonicalActionId(raw.capability, type),
+        candidateVpIds: [],
+        fixedVpId: null,
+        assignmentReason: '',
+        separateFromStageTypes: uniqueStrings(raw.separateFromActionTypes),
+      },
+      modelPolicy: workItem.workflowSnapshot?.actionModelPolicies?.[type]
+        || workItem.workflowSnapshot?.actionModelPolicies?.custom
+        || workItem.workflowSnapshot?.modelPolicy
+        || null,
+      dependsOnStageIds: [],
+      sourceActionIds,
+      workspaceMode,
+      changesRequestedStageId: null,
+      requiredRole: '',
+      brief,
+      context: [],
+      maxAttempts: Math.min(Math.max(Number(raw.maxAttempts) || 2, 1), 5),
+    };
+    action.instruction = canonicalActionInstruction(effectiveWorkItem, action, []);
+    return action;
+  });
+  const workItemType = canonicalActionId(
+    decision.workItemType || workItem.workflowSnapshot?.workItemType,
+    '',
+  ).slice(0, 64);
+  if (!workItemType) throw new Error('Work Center Coordinator must choose a specific WorkItem type');
+  return {
+    createdActions,
+    supersedeActionIds,
+    contractPatch: decision.contractPatch || null,
+    workItemType,
+  };
+}
+
+function normalizeEvidenceRunIds(value) {
+  return uniqueStrings(value);
+}
+
+export function normalizeDynamicCompletion(value, acceptanceCriteria) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('Work Center Coordinator completion is required');
+  }
+  const criteria = Array.isArray(acceptanceCriteria) ? acceptanceCriteria : [];
+  if (criteria.length === 0) throw new Error('Work Center completion requires acceptance criteria');
+  if (!Array.isArray(value.acceptanceResults) || value.acceptanceResults.length !== criteria.length) {
+    throw new Error('Work Center completion requires one ordered result for every acceptance criterion');
+  }
+  const acceptanceResults = value.acceptanceResults.map((raw, index) => {
+    const criterion = typeof raw?.criterion === 'string' ? raw.criterion.trim() : '';
+    const status = raw?.status === 'passed' ? 'passed' : '';
+    const evidenceRunIds = normalizeEvidenceRunIds(raw?.evidenceRunIds);
+    if (criterion !== criteria[index] || !status || evidenceRunIds.length === 0) {
+      throw new Error('Work Center completion requires every criterion to pass with owned Run evidence');
+    }
+    return { criterion, status, evidenceRunIds };
+  });
+  const evidenceRunIds = normalizeEvidenceRunIds(value.evidenceRunIds);
+  if (evidenceRunIds.length === 0) {
+    throw new Error('Work Center completion requires at least one evidence Run');
+  }
+  const acceptanceEvidence = new Set(acceptanceResults.flatMap(result => result.evidenceRunIds));
+  if ([...acceptanceEvidence].some(runId => !evidenceRunIds.includes(runId))) {
+    throw new Error('Work Center completion evidence must include every acceptance evidence Run');
+  }
+  return {
+    summary: requiredText(value.summary, 'completion summary', 8_000),
+    acceptanceResults,
+    evidenceRunIds,
+    residualRisks: uniqueStrings(value.residualRisks).slice(0, 24),
+  };
+}

package/yeaft/work-center/execution-mode.js

@@ -0,0 +1,16 @@
+export const LEGACY_COORDINATION_MODE = 'legacy';
+export const DYNAMIC_COORDINATION_MODE = 'dynamic';
+export const DYNAMIC_EXECUTION_SCHEMA_VERSION = 3;
+
+export function isDynamicWorkItem(workItem) {
+  return workItem?.coordinationMode === DYNAMIC_COORDINATION_MODE;
+}
+
+export function usesMainlineContext(workItem) {
+  return Number(workItem?.executionSchemaVersion) >= 2;
+}
+
+export function usesLegacyGraph(workItem) {
+  return !isDynamicWorkItem(workItem)
+    && workItem?.workflowSnapshot?.executionMode === 'graph';
+}