@yeaft/webchat-agent 1.0.365 → 1.0.367

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

package/yeaft/work-center/service.js

@@ -23,9 +23,12 @@ import { readWorkCenterSettings, writeWorkCenterSettings } from './settings.js';
 import {
   defaultWorkCenterStageInstructions,
   listWorkItemTypeTemplates,
-  resolvePlanningWorkflowSnapshot,
-  resolveWorkflowSnapshot,
 } from './workflow.js';
+import {
+  DYNAMIC_COORDINATION_MODE,
+  DYNAMIC_EXECUTION_SCHEMA_VERSION,
+  resolveDynamicActionPolicySnapshot,
+} from './dynamic-coordination.js';
 
 function requiredString(value, name) {
   if (typeof value !== 'string' || !value.trim()) throw new Error(`${name} is required`);
@@ -122,6 +125,7 @@ export class WorkCenterService {
       ? Number(options.pollIntervalMs)
       : 2_000;
     this.recoveryTimer = null;
+    this.dynamicCoordinatorTasks = new Map();
     this.shuttingDown = false;
     this.watcher = new WorkItemWatcher({
       store: this.store,
@@ -227,14 +231,8 @@ export class WorkCenterService {
       }
       case 'create': {
         const settings = this.settingsReader(this.yeaftDir);
-        const explicitWorkflow = requestContext.trustedProducer === true
-          && typeof payload.workflowTemplate === 'string' && payload.workflowTemplate.trim()
-          ? payload.workflowTemplate.trim()
-          : null;
-        const workflowTemplate = explicitWorkflow || 'ai-planned';
-        const workflowSnapshot = explicitWorkflow
-          ? resolveWorkflowSnapshot(settings, explicitWorkflow, payload.stageOverrides)
-          : resolvePlanningWorkflowSnapshot(settings, payload.workItemType);
+        const workflowTemplate = 'coordinator-driven';
+        const workflowSnapshot = resolveDynamicActionPolicySnapshot(settings, payload.workItemType);
         const runtime = !Object.hasOwn(payload, 'workDir') && !settings.defaultWorkDir
           ? await this.runtimeInfo()
           : null;
@@ -248,6 +246,7 @@ export class WorkCenterService {
             root: this.attachmentRoot,
             workItemId,
           });
+          const shouldStart = payload.start === undefined ? settings.startImmediately : payload.start !== false;
           this.controller.create({
             id: workItemId,
             title: requiredString(payload.title, 'title'),
@@ -257,6 +256,8 @@ export class WorkCenterService {
               : [],
             workflowTemplate,
             workflowSnapshot,
+            coordinationMode: DYNAMIC_COORDINATION_MODE,
+            executionSchemaVersion: DYNAMIC_EXECUTION_SCHEMA_VERSION,
             workDir,
             reuseMemory: payload.reuseMemory !== false,
             origin: payload.origin && typeof payload.origin === 'object'
@@ -274,9 +275,13 @@ export class WorkCenterService {
               ? normalizeSessionContextSnapshot(payload.sessionContext)
               : [],
             attachments,
-            start: payload.start === undefined ? settings.startImmediately : payload.start !== false,
+            start: false,
           });
-          const detail = this.#requiredItem(workItemId);
+          let detail = this.#requiredItem(workItemId);
+          if (shouldStart) {
+            detail = this.controller.start(workItemId);
+            this.#queueDynamicCoordinatorWake(workItemId);
+          }
           this.#emit({ type: 'work_item.created', workItem: detail });
           return detail;
         } catch (error) {
@@ -288,11 +293,17 @@ export class WorkCenterService {
         const id = requiredString(payload.id, 'id');
         const detail = this.controller.update(id, payload.patch || {});
         this.watcher.abortInvalidWorkItemRuns(id);
+        if (detail.coordinationMode === DYNAMIC_COORDINATION_MODE) {
+          this.#queueDynamicCoordinatorWake(id);
+        }
         this.#emit({ type: 'work_item.updated', workItem: detail });
         return detail;
       }
       case 'start': {
         const detail = this.controller.start(requiredString(payload.id, 'id'));
+        if (detail.coordinationMode === DYNAMIC_COORDINATION_MODE) {
+          this.#queueDynamicCoordinatorWake(detail.id);
+        }
         this.#emit({ type: 'work_item.started', workItem: detail });
         return detail;
       }
@@ -307,6 +318,9 @@ export class WorkCenterService {
         const id = requiredString(payload.id, 'id');
         const detail = this.controller.resume(id, { revision: payload.revision });
         this.watcher.abortInvalidWorkItemRuns(id);
+        if (detail.coordinationMode === DYNAMIC_COORDINATION_MODE) {
+          this.#queueDynamicCoordinatorWake(id);
+        }
         this.#emit({ type: 'work_item.resumed', workItem: detail });
         return detail;
       }
@@ -571,6 +585,10 @@ export class WorkCenterService {
 
   #emit(event) {
     try { this.onEvent(event); } catch {}
+    if (event?.workItem?.coordinationMode === DYNAMIC_COORDINATION_MODE) {
+      this.#queueDynamicCoordinatorWake(event.workItem.id);
+      return;
+    }
     if (['run.finished', 'coordinator.turn_completed'].includes(event?.type)) {
       for (const action of event.workItem?.actions || []) {
         if (action.status !== 'failed') continue;
@@ -583,6 +601,56 @@ export class WorkCenterService {
     }
   }
 
+  #queueDynamicCoordinatorWake(workItemId) {
+    if (this.shuttingDown || !this.coordinator || !workItemId
+        || this.dynamicCoordinatorTasks.has(workItemId)) return;
+    this.dynamicCoordinatorTasks.set(workItemId, null);
+    queueMicrotask(() => {
+      if (this.dynamicCoordinatorTasks.get(workItemId) === null) {
+        this.dynamicCoordinatorTasks.delete(workItemId);
+        this.#drainDynamicCoordinatorWakes(workItemId);
+      }
+    });
+  }
+
+  #scanDynamicCoordinatorWakes() {
+    if (this.shuttingDown || !this.coordinator) return;
+    for (const entry of this.store.listPendingDynamicCoordinatorWakes()) {
+      this.#queueDynamicCoordinatorWake(entry.workItemId);
+    }
+  }
+
+  #drainDynamicCoordinatorWakes(workItemId) {
+    if (this.shuttingDown || !this.coordinator || this.dynamicCoordinatorTasks.has(workItemId)) return null;
+    const entries = this.store.listPendingDynamicCoordinatorWakes()
+      .filter(candidate => candidate.workItemId === workItemId);
+    const entry = entries.find(candidate => candidate.payload?.turnId) || entries[0];
+    if (!entry) return null;
+    const detail = this.store.getWorkItemDetail(workItemId);
+    if (detail?.actions?.some(action => action.status === 'running')) return null;
+    let turn;
+    try {
+      turn = this.coordinator.advance(entry.id, {
+        workItemId,
+        onUpdate: (type, workItem) => this.#emit({ type, workItem }),
+      });
+    } catch (error) {
+      this.#emit({
+        type: 'coordinator.advance_schedule_failed',
+        workItem: this.store.getWorkItemDetail(workItemId),
+        error: error?.message || String(error),
+      });
+      return null;
+    }
+    if (!turn) return null;
+    const task = turn.task.finally(() => {
+      this.dynamicCoordinatorTasks.delete(workItemId);
+    });
+    this.dynamicCoordinatorTasks.set(workItemId, task);
+    task.catch(() => {});
+    return task;
+  }
+
   #recoveryKey(entry) {
     return `${entry.workItemId}:${entry.actionId}:${entry.actionGeneration}`;
   }
@@ -621,6 +689,7 @@ export class WorkCenterService {
 
   #scanRecoveries() {
     this.#scanCoordinatorProviderRecoveries();
+    this.#scanDynamicCoordinatorWakes();
     this.#scanFailureRecoveries();
   }
 
@@ -701,8 +770,12 @@ export class WorkCenterService {
     if (this.recoveryTimer) clearInterval(this.recoveryTimer);
     this.recoveryTimer = null;
     await this.coordinator?.shutdown?.();
-    await Promise.allSettled([...this.recoveryTasks.values()]);
+    await Promise.allSettled([
+      ...this.recoveryTasks.values(),
+      ...[...this.dynamicCoordinatorTasks.values()].filter(Boolean),
+    ]);
     this.recoveryTasks.clear();
+    this.dynamicCoordinatorTasks.clear();
     this.recoveryQueue.clear();
     await this.watcher.stop();
     try { await this.watcher.runner?.shutdown?.(); } catch {}