@yeaft/webchat-agent 1.0.366 → 1.0.368

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';
+}

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

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { isDynamicWorkItem } from './execution-mode.js';
 import {
   currentActionInputEventIds,
   eventMatchesActionGeneration,
@@ -281,6 +282,7 @@ export function buildMainlineProjection(detail) {
   const actions = (Array.isArray(detail.actions) ? detail.actions : []).slice().sort(stableActionOrder);
   const runs = Array.isArray(detail.runs) ? detail.runs : [];
   const activeActions = actions.filter(action => action.status !== 'superseded');
+  const dynamic = isDynamicWorkItem(detail);
   const completedStageIds = new Set(activeActions
     .filter(action => action.status === 'completed')
     .map(action => action.stageId));
@@ -292,10 +294,11 @@ export function buildMainlineProjection(detail) {
     generation: Math.max(1, count(action.generation) || 1),
     specHash: action.specHash || '',
     status: action.status,
-    dependsOnStageIds: [...new Set(action.dependsOnStageIds || [])].sort(),
+    dependsOnStageIds: dynamic ? [] : [...new Set(action.dependsOnStageIds || [])].sort(),
+    sourceActionIds: dynamic ? [...new Set(action.sourceActionIds || [])].sort() : [],
   }));
   const frontier = nodes.filter(node => !CLOSED_ACTION_STATUSES.has(node.status)
-      && node.dependsOnStageIds.every(stageId => completedStageIds.has(stageId)))
+      && (dynamic || node.dependsOnStageIds.every(stageId => completedStageIds.has(stageId))))
     .map(node => node.id);
   const canonicalActionResults = {};
   for (const action of activeActions) {
@@ -321,7 +324,9 @@ export function buildMainlineProjection(detail) {
       goal: detail.goal || '',
       acceptanceCriteria: Array.isArray(detail.acceptanceCriteria) ? detail.acceptanceCriteria : [],
     },
-    graph: { planRevision: count(detail.planRevision), nodes, frontier },
+    ...(dynamic
+      ? { actionJournal: { revision: count(detail.planRevision), entries: nodes, runnableActionIds: frontier } }
+      : { graph: { planRevision: count(detail.planRevision), nodes, frontier } }),
     canonicalActionResults,
     planConflicts: (Array.isArray(detail.planConflicts) ? detail.planConflicts : [])
       .slice()
@@ -343,14 +348,17 @@ export function buildMainlineContextSnapshot(detail, action, budgetInput = {}) {
     throw mainlineContextBlocked(`Mainline fixed prompt content exceeds 64 KiB (${reservedBytes} rendered UTF-8 bytes)`);
   }
   const projection = buildMainlineProjection(detail);
-  const dependencyIds = new Set(action.dependsOnStageIds || []);
-  const actionByStage = new Map((detail.actions || []).filter(candidate => candidate.status !== 'superseded')
-    .map(candidate => [candidate.stageId, candidate]));
-  const dependencies = [...dependencyIds].sort().map(stageId => {
-    const dependency = actionByStage.get(stageId);
-    if (!dependency) return { stageId, actionId: null, result: null };
+  const dynamic = isDynamicWorkItem(detail);
+  const dependencyIds = new Set(dynamic ? action.sourceActionIds || [] : action.dependsOnStageIds || []);
+  const actionByReference = new Map((detail.actions || []).filter(candidate => candidate.status !== 'superseded')
+    .map(candidate => [dynamic ? candidate.id : candidate.stageId, candidate]));
+  const dependencies = [...dependencyIds].sort().map(reference => {
+    const dependency = actionByReference.get(reference);
+    if (!dependency) return dynamic
+      ? { sourceActionId: reference, actionId: null, result: null }
+      : { stageId: reference, actionId: null, result: null };
     return {
-      stageId,
+      ...(dynamic ? { sourceActionId: reference } : { stageId: reference }),
       actionId: dependency.id,
       generation: dependency.generation || 1,
       specHash: dependency.specHash || '',
@@ -377,14 +385,18 @@ export function buildMainlineContextSnapshot(detail, action, budgetInput = {}) {
         policyInstruction: detail.workflowSnapshot?.actionInstructions?.[action.type]
           || detail.workflowSnapshot?.actionInstructions?.custom
           || '',
-        dependsOnStageIds: [...dependencyIds].sort(),
+        ...(dynamic
+          ? { sourceActionIds: [...dependencyIds].sort() }
+          : { dependsOnStageIds: [...dependencyIds].sort() }),
         workspaceMode: action.workspaceMode || 'shared',
         changesRequestedStageId: action.changesRequestedStageId || null,
       },
     },
-    graph: projection.graph,
+    ...(dynamic
+      ? { actionJournal: projection.actionJournal }
+      : { graph: projection.graph }),
     canonicalCompletedResultsIndex: resultIndex,
-    directDependencies: dependencies,
+    ...(dynamic ? { sourceResults: dependencies } : { directDependencies: dependencies }),
     userContext: {
       sessionContext: [],
       workItemMessages: [],

package/yeaft/work-center/projection.js

@@ -605,6 +605,7 @@ function projectAction(action, runs, events, includeBody = true) {
       ? (action.assignmentPolicy || null)
       : projectAssignmentPolicy(action.assignmentPolicy),
     dependsOnStageIds: Array.isArray(action.dependsOnStageIds) ? action.dependsOnStageIds : [],
+    sourceActionIds: Array.isArray(action.sourceActionIds) ? action.sourceActionIds : [],
     workspaceMode: action.workspaceMode || 'shared',
     requiredRole: action.requiredRole || '',
     generation: Math.max(1, count(action.generation) || 1),
@@ -797,17 +798,20 @@ function projectCanonicalEvidence(value) {
 }
 
 function projectMainlineBrowser(detail) {
-  if (!detail?.id || detail.executionSchemaVersion !== 2) return null;
+  if (!detail?.id || Number(detail.executionSchemaVersion) < 2) return null;
   const mainline = buildMainlineProjection(detail);
+  const actionSet = mainline.actionJournal || mainline.graph;
+  const nodes = actionSet.entries || actionSet.nodes || [];
+  const frontier = actionSet.runnableActionIds || actionSet.frontier || [];
   const actionById = new Map((detail.actions || []).map(action => [action.id, action]));
   const activeActionIds = Array.isArray(detail.activeActionIds)
     ? detail.activeActionIds
-    : mainline.graph.nodes.filter(node => ['ready', 'running'].includes(node.status)).map(node => node.id);
+    : nodes.filter(node => ['ready', 'running'].includes(node.status)).map(node => node.id);
   const attentionActionIds = Array.isArray(detail.attentionActionIds)
     ? detail.attentionActionIds
-    : mainline.graph.nodes.filter(node => ['waiting', 'failed'].includes(node.status)).map(node => node.id);
+    : nodes.filter(node => ['waiting', 'failed'].includes(node.status)).map(node => node.id);
   const counts = Object.fromEntries(['completed', 'running', 'ready', 'waiting', 'failed']
-    .map(status => [status, mainline.graph.nodes.filter(node => node.status === status).length]));
+    .map(status => [status, nodes.filter(node => node.status === status).length]));
   return {
     contract: {
       title: truncateUtf8(mainline.contract.title, 8_000),
@@ -816,15 +820,15 @@ function projectMainlineBrowser(detail) {
         .map(criterion => truncateUtf8(criterion, 4_000)),
     },
     progress: {
-      lifecycle: detail.lifecycle || (counts.completed === mainline.graph.nodes.length ? 'done' : 'active'),
+      lifecycle: detail.lifecycle || (counts.completed === nodes.length ? 'done' : 'active'),
       attentionState: detail.attentionState || (counts.waiting && counts.failed ? 'mixed'
         : counts.waiting ? 'waiting' : counts.failed ? 'failed' : 'none'),
       activeActionIds: [...activeActionIds],
       attentionActionIds: [...attentionActionIds],
-      frontierActionIds: [...mainline.graph.frontier],
+      frontierActionIds: [...frontier],
       counts,
     },
-    actions: mainline.graph.nodes.map(node => {
+    actions: nodes.map(node => {
       const action = actionById.get(node.id) || {};
       const result = mainline.canonicalActionResults[node.id];
       return {
@@ -839,7 +843,7 @@ function projectMainlineBrowser(detail) {
               truncateUtf8(value, MAX_CURRENT_BRIEF_BYTES),
             ]))
           : null,
-        dependencies: [...node.dependsOnStageIds],
+        dependencies: [...(node.sourceActionIds?.length ? node.sourceActionIds : node.dependsOnStageIds || [])],
         canonicalResult: result ? {
           status: result.status,
           summary: sanitizeMainlineDiagnostic(result.summary, MAX_ACTION_DIAGNOSTIC_CHARS),
@@ -895,6 +899,22 @@ export function projectWorkItemDetail(detail, options = {}) {
     planRevision: count(detail.planRevision),
     ledgerRevision: count(detail.ledgerRevision),
     coordinatorRevision: count(detail.coordinatorRevision),
+    coordinationMode: detail.coordinationMode || 'legacy',
+    finalResult: detail.finalResult && typeof detail.finalResult === 'object' ? {
+      summary: truncateUtf8(detail.finalResult.summary || '', MAX_ACTION_MESSAGE_CHARS),
+      acceptanceResults: Array.isArray(detail.finalResult.acceptanceResults)
+        ? detail.finalResult.acceptanceResults.slice(0, 24).map(result => ({
+            criterion: truncateUtf8(result?.criterion || '', MAX_ACTION_MESSAGE_CHARS),
+            status: result?.status === 'passed' ? 'passed' : null,
+            evidenceRunIds: Array.isArray(result?.evidenceRunIds)
+              ? result.evidenceRunIds.map(String).slice(0, 24) : [],
+          })) : [],
+      evidenceRunIds: Array.isArray(detail.finalResult.evidenceRunIds)
+        ? detail.finalResult.evidenceRunIds.map(String).slice(0, 64) : [],
+      residualRisks: Array.isArray(detail.finalResult.residualRisks)
+        ? detail.finalResult.residualRisks
+          .map(risk => truncateUtf8(risk, MAX_ACTION_MESSAGE_CHARS)).slice(0, 24) : [],
+    } : null,
     title: detail.title,
     goal: detail.goal,
     acceptanceCriteria: Array.isArray(detail.acceptanceCriteria) ? detail.acceptanceCriteria : [],
@@ -931,7 +951,8 @@ export function projectWorkItemDetail(detail, options = {}) {
       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', 'request_human'].includes(message.decision.kind)
+        kind: ['answer', 'create_actions', 'guide_actions', 'replan', 'request_human', 'complete']
+          .includes(message.decision.kind)
           ? message.decision.kind : null,
         reason: truncateUtf8(message.decision.reason || '', MAX_ACTION_DIAGNOSTIC_CHARS),
         changedContract: message.decision.changedContract === true,
@@ -981,6 +1002,7 @@ export function projectWorkItemSummary(detail) {
       planRevision: count(detail.planRevision),
       ledgerRevision: count(detail.ledgerRevision),
       coordinatorRevision: count(detail.coordinatorRevision),
+      coordinationMode: detail.coordinationMode || 'legacy',
       title: detail.title,
       goal: detail.goal,
       workItemType: detail.workflowSnapshot?.workItemType || detail.workItemType || null,
@@ -1017,6 +1039,7 @@ export function projectWorkItemSummary(detail) {
     planRevision: count(detail.planRevision),
     ledgerRevision: count(detail.ledgerRevision),
     coordinatorRevision: count(detail.coordinatorRevision),
+    coordinationMode: detail.coordinationMode || 'legacy',
     title: detail.title,
     goal: detail.goal,
     workItemType: detail.workflowSnapshot?.workItemType || detail.workItemType || null,

package/yeaft/work-center/runner.js

@@ -34,6 +34,7 @@ import { MCPManager } from '../mcp.js';
 import { buildMcpFlattenedTools } from '../tools/mcp-tools.js';
 import { recallWorkspaceSessionContext } from './workspace-context.js';
 import { applyGeneratedPlan, BUILT_IN_ACTION_TYPES } from './workflow.js';
+import { isDynamicWorkItem, usesMainlineContext } from './execution-mode.js';
 import {
   applyAdditivePlanProposal,
   applyReplanMutation,
@@ -946,7 +947,9 @@ export class WorkItemRunner {
           action: finalizeOwnedIntegration(this.store, action, run, ownerBootId),
         };
       }
-      const dependencies = this.store.listActionDependencies(workItem.id, action.dependsOnStageIds || []);
+      const dependencies = isDynamicWorkItem(workItem)
+        ? this.store.listActionSources(workItem.id, action.sourceActionIds || [])
+        : this.store.listActionDependencies(workItem.id, action.dependsOnStageIds || []);
       if (dependencies.length > 0 && dependencies.every(dependency => (
         dependency.workspaceMode === 'shared' && !dependency.workspace?.isolated
       ))) {
@@ -1021,9 +1024,8 @@ export class WorkItemRunner {
 
   async run({ workItem, action, run, signal, ownerBootId, onProgress, registerProgressReader, registerInputWake }) {
     const runtime = await this.runtimeProvider();
-    const currentSettings = workItem?.workflowSnapshot?.planningMode === 'ai' && this.policyProvider
-      ? await this.policyProvider()
-      : null;
+    const currentSettings = ['ai', 'coordinator'].includes(workItem?.workflowSnapshot?.planningMode)
+      && this.policyProvider ? await this.policyProvider() : null;
     const currentModelPolicy = currentSettings?.actionModelPolicies?.[action.type]
       || currentSettings?.actionModelPolicies?.custom
       || currentSettings?.modelPolicy
@@ -1036,15 +1038,16 @@ export class WorkItemRunner {
       ? resolveWorkItemWorkDir({ workspaceKey: action.workspace.path }, runtime.defaultWorkDir)
       : workspaceDir;
     const priorRuns = this.store.listCompletedRuns(workItem.id);
-    const v2Execution = Number(workItem.executionSchemaVersion) === 2;
-    const dependencyContext = v2Execution
-      ? []
-      : this.store.listActionDependencies?.(workItem.id, action.dependsOnStageIds || []) || [];
+    const mainlineExecution = usesMainlineContext(workItem);
+    const dependencyContext = isDynamicWorkItem(workItem)
+      ? this.store.listActionSources?.(workItem.id, action.sourceActionIds || []) || []
+      : mainlineExecution ? []
+        : this.store.listActionDependencies?.(workItem.id, action.dependsOnStageIds || []) || [];
     const dependencyBlock = dependencyContext.length === 0 ? '' : `\n\nCompleted dependency results:\n${dependencyContext.map(dependency => {
       const evidence = dependency.evidence?.length
         ? `\nEvidence: ${dependency.evidence.map(item => item.label).join('; ')}`
         : '';
-      return `### ${dependency.stageId} (${dependency.vpId || 'unknown VP'})\n${dependency.summary || '(no summary)'}${evidence}`;
+      return `### ${isDynamicWorkItem(workItem) ? dependency.id : dependency.stageId} (${dependency.vpId || 'unknown VP'})\n${dependency.summary || '(no summary)'}${evidence}`;
     }).join('\n\n')}`;
     const resumeBlock = renderActionResumeBlock(this.store.getActionResumeContext?.(action.id, run.id));
     const assignment = executionAction.assignmentPolicy
@@ -1084,7 +1087,7 @@ export class WorkItemRunner {
     const attachmentFileById = new Map(attachmentContext.files.map(file => [file.id, file]));
     const fixedPromptSuffix = `${resumeBlock}${attachmentContext.promptBlock}${completionContract(executionAction, workItem)}`;
     const reservedPromptBytes = Buffer.byteLength(fixedPromptSuffix, 'utf8');
-    const mainline = v2Execution
+    const mainline = mainlineExecution
       ? buildMainlineContextSnapshot(
           this.store.getWorkItemDetail(workItem.id),
           executionAction,
@@ -1212,7 +1215,9 @@ export class WorkItemRunner {
         executionManifest: mainline ? {
           schemaVersion: 2,
           ledgerRevision: mainline.contextSnapshot.ledgerRevision,
-          planRevision: mainline.contextSnapshot.graph.planRevision,
+          planRevision: isDynamicWorkItem(workItem)
+            ? mainline.contextSnapshot.actionJournal.revision
+            : mainline.contextSnapshot.graph.planRevision,
           contractRevision: mainline.contextSnapshot.contract.revision,
           actionGeneration: mainline.contextSnapshot.action.generation,
           actionSpecHash: mainline.contextSnapshot.action.specHash,
@@ -1336,11 +1341,11 @@ export class WorkItemRunner {
       }
     };
     try {
-      const prompt = v2Execution
+      const prompt = mainlineExecution
         ? `${renderMainlineContextSnapshot(mainline.contextSnapshot)}${fixedPromptSuffix}`
         : `${executionAction.instruction}${dependencyBlock}${resumeBlock}${attachmentContext.promptBlock}${workspaceSessionBlock}${memoryBlock}${completionContract(executionAction, workItem)}`;
       const promptBytes = Buffer.byteLength(prompt, 'utf8');
-      if (v2Execution && promptBytes > MAINLINE_CONTEXT_HARD_LIMIT_BYTES) {
+      if (mainlineExecution && promptBytes > MAINLINE_CONTEXT_HARD_LIMIT_BYTES) {
         throw new Error(`Work Center Mainline prompt exceeds 64 KiB (${promptBytes} rendered UTF-8 bytes)`);
       }
       const promptParts = attachmentContext.promptParts.length > 0