@yeaft/webchat-agent 1.0.217 → 1.0.218

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.217"}
+{"version":"1.0.218"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.217",
+  "version": "1.0.218",
   "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/controller.js

@@ -8,7 +8,7 @@ import {
 } from './workflow.js';
 import { renderSessionContextSnapshot } from './session-context.js';
 import { normalizeEvidence } from './evidence.js';
-import { applyAdditivePlanProposal } from './plan-mutation.js';
+import { applyAdditivePlanProposal, applyReplanMutation } from './plan-mutation.js';
 import { normalizeContractPatch, validateCompletedResult } from './completion-contract.js';
 
 function normalizeTerminalResult(result, action) {
@@ -46,6 +46,8 @@ function normalizeTerminalResult(result, action) {
       && !Array.isArray(result.planProposal) ? result.planProposal : null,
     replanRequest: result.replanRequest && typeof result.replanRequest === 'object'
       && !Array.isArray(result.replanRequest) ? result.replanRequest : null,
+    replanMutation: result.replanMutation && typeof result.replanMutation === 'object'
+      && !Array.isArray(result.replanMutation) ? result.replanMutation : null,
   };
   if (normalized.outcome === 'waiting' && !normalized.waitingReason) {
     throw new Error('waiting outcome requires waitingReason');
@@ -58,12 +60,14 @@ function normalizeTerminalResult(result, action) {
   if (normalized.outcome !== 'completed') {
     normalized.planProposal = null;
     normalized.replanRequest = null;
+    normalized.replanMutation = null;
   }
-  if (normalized.planProposal && normalized.replanRequest) {
+  if ([normalized.planProposal, normalized.replanRequest, normalized.replanMutation].filter(Boolean).length > 1) {
     normalized.outcome = 'failed';
-    normalized.error = 'An Action cannot expand and replan the WorkItem in the same completion';
+    normalized.error = 'An Action cannot submit more than one WorkItem plan mutation';
     normalized.planProposal = null;
     normalized.replanRequest = null;
+    normalized.replanMutation = null;
   }
   if (action.type === 'review' && normalized.outcome === 'completed' && !normalized.reviewDecision) {
     normalized.outcome = 'failed';
@@ -323,10 +327,17 @@ export class WorkflowController {
       throw new Error('Run has unconsumed Action input and cannot finish yet');
     }
     const result = normalizeTerminalResult(rawResult, activeAction);
+    if (result.outcome === 'completed'
+        && activeAction.stageId?.startsWith('replan-')
+        && !result.replanMutation) {
+      result.outcome = 'failed';
+      result.error = 'Work Center replan triage must submit SubmitWorkItemReplan';
+    }
     validateCompletedResult(result, activeAction, activeWorkItem);
     let validatedGeneratedWorkflow = null;
     if (result.outcome === 'completed'
         && activeAction.type === 'triage'
+        && !activeAction.stageId?.startsWith('replan-')
         && activeRun
         && this.store.getWorkItem(activeRun.workItemId)?.workflowSnapshot?.planningMode === 'ai') {
       const current = this.store.getWorkItem(activeRun.workItemId);
@@ -364,6 +375,27 @@ export class WorkflowController {
         result.error = error?.message || String(error);
       }
     }
+    let validatedReplanMutation = null;
+    let staleReplanMutation = null;
+    if (result.outcome === 'completed' && result.replanMutation) {
+      const currentWorkItem = this.store.getWorkItem(activeWorkItem.id);
+      if (Number(result.replanMutation.basePlanRevision) !== currentWorkItem.planRevision) {
+        staleReplanMutation = result.replanMutation;
+      } else {
+        try {
+          validatedReplanMutation = applyReplanMutation({
+            workItem: currentWorkItem,
+            action: activeAction,
+            actions: this.store.getWorkItemDetail(activeWorkItem.id).actions,
+            proposal: result.replanMutation,
+            availableVpIds: this.listAvailableVpIds?.(),
+          });
+        } catch (error) {
+          result.outcome = 'failed';
+          result.error = error?.message || String(error);
+        }
+      }
+    }
     if (result.outcome === 'completed' && result.replanRequest) {
       const basePlanRevision = Number(result.replanRequest.basePlanRevision);
       const proposalId = typeof result.replanRequest.proposalId === 'string'
@@ -451,6 +483,36 @@ export class WorkflowController {
             : effectiveWorkItem;
         const context = [...(action.context || []), contextEntry(action, result, activeRun)];
         if (plannedWorkItem.workflowSnapshot?.executionMode === 'graph') {
+          if (staleReplanMutation) {
+            return {
+              actionStatus: 'completed', workItemStatus: 'needs_attention', graphAdvance: false,
+              keepCurrentAction: true,
+              planConflict: {
+                kind: 'plan_revision',
+                proposalId: staleReplanMutation.proposalId,
+                expectedPlanRevision: staleReplanMutation.basePlanRevision,
+                actualPlanRevision: workItem.planRevision,
+              },
+              eventType: 'workflow.plan_conflict',
+              eventData: { proposalId: staleReplanMutation.proposalId },
+            };
+          }
+          if (validatedReplanMutation) {
+            return {
+              actionStatus: 'completed', workItemStatus: 'ready', graphAdvance: true,
+              workflowSnapshot: validatedReplanMutation.workflowSnapshot,
+              expectedPlanRevision: validatedReplanMutation.basePlanRevision,
+              proposalId: validatedReplanMutation.proposalId,
+              replanMutation: validatedReplanMutation,
+              eventType: 'workflow.replanned',
+              eventData: {
+                retainedActionCount: validatedReplanMutation.retain.length,
+                replacedActionCount: validatedReplanMutation.replace.length,
+                removedActionCount: validatedReplanMutation.remove.length,
+                addedActionCount: validatedReplanMutation.add.length,
+              },
+            };
+          }
           if (result.replanRequest) {
             const replanStage = {
               ...plannedWorkItem.workflowSnapshot.stages[0],

package/yeaft/work-center/plan-mutation.js

@@ -12,6 +12,11 @@ function cleanProposalId(value) {
   return id;
 }
 
+function replanBarrierFrom(action) {
+  return (Array.isArray(action?.context) ? action.context : [])
+    .find(entry => entry?.type === 'replan-barrier') || null;
+}
+
 function planActionFromStage(stage) {
   return {
     id: stage.id,
@@ -183,3 +188,118 @@ export function applyAdditivePlanProposal({ workItem, actions, proposal, availab
     dependencyPatches,
   };
 }
+
+export function applyReplanMutation({ workItem, action, actions, proposal, availableVpIds = null }) {
+  if (workItem.workflowSnapshot?.executionMode !== 'graph'
+      || action?.type !== 'triage'
+      || !action?.stageId?.startsWith('replan-')) {
+    throw new Error('Work Center replan mutation requires a replan triage Action');
+  }
+  if (!proposal || typeof proposal !== 'object' || Array.isArray(proposal)) {
+    throw new Error('Work Center replan mutation must be an object');
+  }
+  const proposalId = cleanProposalId(proposal.proposalId);
+  const basePlanRevision = Number(proposal.basePlanRevision);
+  if (!Number.isInteger(basePlanRevision) || basePlanRevision !== workItem.planRevision) {
+    throw new Error('Work Center replan mutation has a stale basePlanRevision');
+  }
+  const barrier = replanBarrierFrom(action);
+  if (!barrier || !Array.isArray(barrier.candidateActionIds)) {
+    throw new Error('Work Center replan Action is missing its frozen candidate set');
+  }
+  const candidateIds = barrier.candidateActionIds;
+  const actionById = new Map(actions.map(candidate => [candidate.id, candidate]));
+  const candidates = new Map(candidateIds.map(id => [id, actionById.get(id)]));
+  for (const [id, candidate] of candidates) {
+    if (!candidate || candidate.status !== 'superseded') {
+      throw new Error(`Work Center replan candidate is missing or no longer superseded: ${id}`);
+    }
+  }
+
+  const classified = new Set();
+  const classify = (actionId, kind) => {
+    const id = typeof actionId === 'string' ? actionId.trim() : '';
+    if (!candidates.has(id)) throw new Error(`Work Center replan ${kind} references a non-candidate Action: ${id || '(missing)'}`);
+    if (classified.has(id)) throw new Error(`Work Center replan candidate is classified more than once: ${id}`);
+    classified.add(id);
+    return candidates.get(id);
+  };
+  const retained = (Array.isArray(proposal.retain) ? proposal.retain : []).map(entry => ({
+    action: classify(entry?.actionId, 'retain'), input: entry?.action,
+  }));
+  const replaced = (Array.isArray(proposal.replace) ? proposal.replace : []).map(entry => ({
+    action: classify(entry?.actionId, 'replace'), input: entry?.action,
+  }));
+  const removed = (Array.isArray(proposal.remove) ? proposal.remove : []).map(id => classify(id, 'remove'));
+  const missing = candidateIds.filter(id => !classified.has(id));
+  if (missing.length > 0) throw new Error(`Work Center replan must classify every frozen candidate: ${missing.join(', ')}`);
+
+  const completed = actions.filter(candidate => candidate.status === 'completed' && candidate.type !== 'triage');
+  const currentStages = new Map((workItem.workflowSnapshot.stages || []).map(stage => [stage.id, stage]));
+  const historicalStageIds = new Set(actions.map(candidate => candidate.stageId));
+  const futureIds = new Set();
+  const canonicalFuture = (raw, expectedId = null) => {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+      throw new Error('Work Center replan classification requires a full Action specification');
+    }
+    const id = canonicalActionId(raw.id);
+    if (!id || (expectedId && id !== expectedId)) {
+      throw new Error(`Work Center retained Action must keep stage identity: ${expectedId || '(missing)'}`);
+    }
+    if (futureIds.has(id)) throw new Error(`Work Center replan Action id is duplicated: ${id}`);
+    futureIds.add(id);
+    return {
+      ...raw,
+      id,
+      dependsOnActionIds: canonicalExplicitActionIds(raw.dependsOnActionIds, `Action "${id}" dependencies`),
+      changesRequestedActionId: Object.hasOwn(raw, 'changesRequestedActionId')
+        ? canonicalExplicitActionId(raw.changesRequestedActionId, `Action "${id}" review target`)
+        : undefined,
+    };
+  };
+  const retainedInputs = retained.map(entry => canonicalFuture(entry.input, entry.action.stageId));
+  const replacementInputs = replaced.map(entry => {
+    const input = canonicalFuture(entry.input);
+    if (historicalStageIds.has(input.id)) throw new Error(`Work Center replacement Action reuses historical stage identity: ${input.id}`);
+    return input;
+  });
+  const addedInputs = (Array.isArray(proposal.add) ? proposal.add : []).map(raw => {
+    const input = canonicalFuture(raw);
+    if (historicalStageIds.has(input.id)) throw new Error(`Work Center added Action reuses historical stage identity: ${input.id}`);
+    return input;
+  });
+  const completedInputs = completed.map(candidate => {
+    const stage = currentStages.get(candidate.stageId);
+    if (!stage) throw new Error(`Work Center completed Action is missing from the frozen workflow: ${candidate.stageId}`);
+    return planActionFromStage(stage);
+  });
+  const synthetic = {
+    ...workItem,
+    workflowSnapshot: { ...workItem.workflowSnapshot, actionTemplates: [], stages: [workItem.workflowSnapshot.stages[0]] },
+  };
+  const workflowSnapshot = applyGeneratedPlan(synthetic, {
+    workItemType: workItem.workflowSnapshot.workItemType,
+    actions: stableTopologicalActions([...completedInputs, ...retainedInputs, ...replacementInputs, ...addedInputs]),
+  }, { availableVpIds });
+  const stageById = new Map(workflowSnapshot.stages.map(stage => [stage.id, stage]));
+  const context = (Array.isArray(action.context) ? action.context : [])
+    .filter(entry => entry?.type !== 'replan-barrier');
+  return {
+    proposalId,
+    basePlanRevision,
+    workflowSnapshot,
+    retain: retained.map(entry => ({
+      action: entry.action,
+      nextAction: actionForStage(stageById.get(entry.action.stageId), { ...workItem, workflowSnapshot }, context),
+    })),
+    replace: replaced.map((entry, index) => ({
+      action: entry.action,
+      nextAction: {
+        ...actionForStage(stageById.get(replacementInputs[index].id), { ...workItem, workflowSnapshot }, context),
+        replacesActionId: entry.action.id,
+      },
+    })),
+    add: addedInputs.map(input => actionForStage(stageById.get(input.id), { ...workItem, workflowSnapshot }, context)),
+    remove: removed.map(candidate => candidate.id),
+  };
+}

package/yeaft/work-center/runner.js

@@ -437,6 +437,52 @@ export function createRequestWorkItemReplanTool({ workItem, collector, isRunActi
   });
 }
 
+export function createSubmitWorkItemReplanTool({ vps, workItem, action, actions, collector, isRunActive }) {
+  const vpCatalog = planningVpCatalog(vps);
+  const vpIds = vpCatalog.map(vp => vp.id);
+  const barrier = (Array.isArray(action.context) ? action.context : [])
+    .find(entry => entry?.type === 'replan-barrier');
+  const candidateIds = Array.isArray(barrier?.candidateActionIds) ? barrier.candidateActionIds : [];
+  const actionById = new Map(actions.map(candidate => [candidate.id, candidate]));
+  const candidateSummary = candidateIds.map(id => {
+    const candidate = actionById.get(id);
+    return `${id}/${candidate?.stageId || 'missing'} (${candidate?.type || 'unknown'})`;
+  }).join('; ');
+  const candidateIdSchema = candidateIds.length > 0
+    ? { type: 'string', enum: candidateIds }
+    : { type: 'string' };
+  const candidateLimit = Math.min(8, candidateIds.length);
+  const classification = { type: 'object', additionalProperties: false,
+    required: ['actionId', 'action'], properties: {
+      actionId: candidateIdSchema,
+      action: plannedActionSchema(vpIds),
+    } };
+  return defineTool({
+    name: 'SubmitWorkItemReplan',
+    description: `Submit the complete replacement topology after a replan barrier. Classify every frozen candidate exactly once as retain, replace, or remove. Retain keeps its database Action identity and stage id but requires the complete updated specification. Replace creates a new Action linked to the old database Action. Add is only for new work. Frozen candidates: ${candidateSummary}. Available VPs: ${vpCatalog.map(vp => vp.id).join(', ')}.`,
+    parameters: { type: 'object', additionalProperties: false,
+      required: ['summary', 'evidence', 'acceptanceChecks', 'proposalId', 'basePlanRevision', 'retain', 'replace', 'remove', 'add'],
+      properties: {
+        ...terminalPlanningFields(),
+        proposalId: { type: 'string', minLength: 1, maxLength: 128 },
+        basePlanRevision: { type: 'integer', const: workItem.planRevision },
+        retain: { type: 'array', maxItems: candidateLimit, items: classification },
+        replace: { type: 'array', maxItems: candidateLimit, items: classification },
+        remove: { type: 'array', maxItems: candidateLimit, uniqueItems: true, items: candidateIdSchema },
+        add: { type: 'array', maxItems: 8, items: plannedActionSchema(vpIds) },
+      } },
+    async execute(input, ctx = {}) {
+      if (!isRunActive()) throw new Error('Work Center Run is no longer active');
+      if (collector.value) throw new Error('A WorkItem plan was already submitted for this Run');
+      collector.value = structuredClone(input);
+      ctx.requestEndTurn?.({ kind: 'work_item_replan_submitted', proposalId: input.proposalId });
+      return JSON.stringify({ submitted: true, proposalId: input.proposalId });
+    },
+    isConcurrencySafe: () => false,
+    isReadOnly: () => false,
+  });
+}
+
 export function createWorkItemToolRegistry({ workDir, attachmentFiles = [], isRunActive, mcpTools = [], runTools = [] }) {
   const canonicalDir = canonicalWorkDir(path.resolve(workDir));
   const canonicalAttachmentFiles = attachmentFiles.map(file => ({
@@ -504,11 +550,15 @@ function completionContract(action, workItem) {
   const triageField = action.type === 'triage'
     ? ',\n  "contractPatch": { "goal": "optional refined goal", "acceptanceCriteria": ["optional refined criterion"] }'
     : '';
-  const planField = action.type === 'triage' && workItem?.workflowSnapshot?.planningMode === 'ai'
+  const planField = action.type === 'triage'
+    && !action.stageId?.startsWith('replan-')
+    && workItem?.workflowSnapshot?.planningMode === 'ai'
     ? ',\n  "plan": { "workItemType": "specific-lowercase-slug", "actions": [{ "id": "stable-id", "name": "User-facing name", "type": "extensible-lowercase-slug (built-ins include research|design|diagnose|implement|migrate|test|review|document|operate|deliver|integrate|write|custom)", "capability": "specific executor capability", "objective": "task-specific concrete work this Action must do", "approach": "task-specific repository-aware method the executor must follow", "expectedOutcome": "task-specific verifiable result this Action must produce", "dependsOnActionIds": ["earlier Action id; [] means concurrent root"], "workspaceMode": "read|isolated-write|integrate|shared", "separateFromActionTypes": ["optional prior Action type"], "changesRequestedActionId": "for review: optional earlier editable Action id; omit to use nearest", "maxAttempts": 2 }] }'
     : '';
-  const toolSubmission = action.type === 'triage' && workItem?.workflowSnapshot?.planningMode === 'ai'
-    ? '\nSubmit the initial plan with SubmitWorkItemPlan. The legacy terminal JSON plan below exists only for compatibility; do not use it when the tool is available.'
+  const toolSubmission = action.type === 'triage' && action.stageId?.startsWith('replan-')
+    ? '\nSubmit the replan only with SubmitWorkItemReplan. Classify every frozen candidate exactly once; do not emit terminal JSON after calling it.'
+    : action.type === 'triage' && workItem?.workflowSnapshot?.planningMode === 'ai'
+      ? '\nSubmit the initial plan with SubmitWorkItemPlan. The legacy terminal JSON plan below exists only for compatibility; do not use it when the tool is available.'
     : workItem?.workflowSnapshot?.executionMode === 'graph'
       ? '\nIf execution discovered strictly additive work, use ProposeWorkItemActions. If the contract or existing unfinished topology must change, use RequestWorkItemReplan. Both tools submit the completed Action and end the turn; do not emit terminal JSON after calling one.'
       : '';
@@ -901,19 +951,29 @@ export class WorkItemRunner {
     const mcpToolNames = workspaceRuntime.mcpTools.map(tool => tool.name);
     const planCollector = { value: null };
     const mutationCollector = { value: null };
+    const replanToolEnabled = executionAction.type === 'triage'
+      && executionAction.stageId?.startsWith('replan-');
     const planToolEnabled = executionAction.type === 'triage'
-      && workItem?.workflowSnapshot?.planningMode === 'ai';
+      && workItem?.workflowSnapshot?.planningMode === 'ai'
+      && !replanToolEnabled;
     const runTools = [];
     if (planToolEnabled) runTools.push(createSubmitWorkItemPlanTool({
       vps: this.registry.listVps(),
       workItem,
       collector: planCollector,
       isRunActive,
-      reservedStageIds: executionAction.stageId?.startsWith('replan-')
-        ? this.store.getWorkItemDetail(workItem.id).actions.map(item => item.stageId)
-        : [],
+      reservedStageIds: [],
+    }));
+    if (replanToolEnabled) runTools.push(createSubmitWorkItemReplanTool({
+      vps: this.registry.listVps(),
+      workItem,
+      action: executionAction,
+      actions: this.store.getWorkItemDetail(workItem.id).actions,
+      collector: planCollector,
+      isRunActive,
     }));
-    if (!planToolEnabled && workItem?.workflowSnapshot?.executionMode === 'graph') {
+    if (!planToolEnabled && !replanToolEnabled
+        && workItem?.workflowSnapshot?.executionMode === 'graph') {
       runTools.push(createProposeWorkItemActionsTool({
         vps: this.registry.listVps(), workItem,
         actions: this.store.getWorkItemDetail(workItem.id).actions,
@@ -1125,7 +1185,8 @@ export class WorkItemRunner {
     }
     const response = publicWorkItemResponse(text);
     reportProgress(true);
-    const submittedPlan = planCollector.value;
+    const submittedPlan = !replanToolEnabled ? planCollector.value : null;
+    const submittedReplanMutation = replanToolEnabled ? planCollector.value : null;
     const submittedExpansion = mutationCollector.value?.kind === 'expand'
       ? mutationCollector.value.input : null;
     const submittedReplan = mutationCollector.value?.kind === 'replan'
@@ -1137,6 +1198,19 @@ export class WorkItemRunner {
       contractPatch: submittedPlan.contractPatch || null,
       plan: { workItemType: submittedPlan.workItemType, actions: submittedPlan.actions },
       acceptanceChecks: submittedPlan.acceptanceChecks,
+    } : submittedReplanMutation ? {
+      outcome: 'completed',
+      summary: submittedReplanMutation.summary,
+      evidence: submittedReplanMutation.evidence,
+      acceptanceChecks: submittedReplanMutation.acceptanceChecks,
+      replanMutation: {
+        proposalId: submittedReplanMutation.proposalId,
+        basePlanRevision: submittedReplanMutation.basePlanRevision,
+        retain: submittedReplanMutation.retain,
+        replace: submittedReplanMutation.replace,
+        remove: submittedReplanMutation.remove,
+        add: submittedReplanMutation.add,
+      },
     } : submittedExpansion ? {
       outcome: 'completed', summary: submittedExpansion.summary,
       evidence: submittedExpansion.evidence, acceptanceChecks: submittedExpansion.acceptanceChecks,

package/yeaft/work-center/store.js

@@ -2094,6 +2094,15 @@ export class WorkItemStore {
         throw new Error('Work Center terminal transition lost the current Action fence');
       }
 
+      if (transition.planConflict) {
+        this.db.prepare(`INSERT INTO plan_conflicts
+          (id, work_item_id, action_id, generation, kind, status, details, created_at, updated_at, resolved_at)
+          VALUES (?, ?, ?, ?, ?, 'open', ?, ?, ?, NULL)`).run(
+          randomUUID(), workItem.id, action.id, action.generation,
+          transition.planConflict.kind || 'plan', stringify(transition.planConflict), now, now,
+        );
+      }
+
       let nextWorkItem = workItem;
       if (transition.contractPatch) {
         const patch = transition.contractPatch;
@@ -2175,10 +2184,66 @@ export class WorkItemStore {
         nextWorkItem = this.getWorkItem(workItem.id);
         nextAction = this.#insertAction(workItem.id, {
           ...barrier.action,
+          context: [
+            ...(Array.isArray(barrier.action.context) ? barrier.action.context : []),
+            {
+              type: 'replan-barrier',
+              proposalId: barrier.proposalId,
+              basePlanRevision: nextWorkItem.planRevision,
+              candidateActionIds: unfinished.map(candidate => candidate.id),
+            },
+          ],
           contractRevision: nextWorkItem.revision,
           status: 'ready',
         }, this.#nextSequence(workItem.id), now);
       }
+      if (transition.replanMutation) {
+        for (const retained of transition.replanMutation.retain) {
+          const prior = retained.action;
+          const candidate = {
+            ...prior,
+            ...retained.nextAction,
+            status: 'ready',
+            generation: prior.generation + 1,
+            attempt: 0,
+            currentRunId: null,
+            resultRunId: null,
+            contractRevision: nextWorkItem.revision,
+          };
+          const changed = this.db.prepare(`UPDATE actions SET type = ?, required_role = ?, stage_id = ?,
+            assignment_policy = ?, model_policy = ?, depends_on_stage_ids = ?, workspace_mode = ?,
+            changes_requested_stage_id = ?, workspace = NULL, instruction = ?, brief = ?, context = ?,
+            contract_revision = ?, generation = ?, spec_hash = ?, result_run_id = NULL, status = 'ready',
+            attempt = 0, max_attempts = ?, current_run_id = NULL, lease_epoch = lease_epoch + 1,
+            updated_at = ? WHERE id = ? AND work_item_id = ? AND status = 'superseded' AND generation = ?`).run(
+            candidate.type, candidate.requiredRole || '', candidate.stageId,
+            stringify(candidate.assignmentPolicy || null), stringify(candidate.modelPolicy || null),
+            stringify(candidate.dependsOnStageIds || []), candidate.workspaceMode || 'shared',
+            candidate.changesRequestedStageId || null, candidate.instruction || '', stringify(candidate.brief || null),
+            stringify(candidate.context || []), candidate.contractRevision, candidate.generation,
+            actionSpecHash(candidate), candidate.maxAttempts || 2, now,
+            prior.id, workItem.id, prior.generation,
+          );
+          if (Number(changed.changes) !== 1) throw new Error('Work Center retained Action lost its superseded identity fence');
+          if (!nextAction) nextAction = this.getAction(prior.id);
+        }
+        for (const replacement of transition.replanMutation.replace) {
+          const inserted = this.#insertAction(workItem.id, {
+            ...replacement.nextAction,
+            contractRevision: nextWorkItem.revision,
+            status: 'ready',
+          }, this.#nextSequence(workItem.id), now);
+          if (!nextAction) nextAction = inserted;
+        }
+        for (const added of transition.replanMutation.add) {
+          const inserted = this.#insertAction(workItem.id, {
+            ...added,
+            contractRevision: nextWorkItem.revision,
+            status: 'ready',
+          }, this.#nextSequence(workItem.id), now);
+          if (!nextAction) nextAction = inserted;
+        }
+      }
       if (transition.graphResetStageId) {
         nextAction = this.#resetGraphFromStage(
           workItem.id,
@@ -2205,7 +2270,13 @@ export class WorkItemStore {
       let workItemStatus = transition.workItemStatus;
       let currentActionId = nextAction?.id ?? (transition.keepCurrentAction ? action.id : null);
       let changedWorkItem;
-      if (transition.graphAdvance) {
+      if (transition.planConflict) {
+        changedWorkItem = this.db.prepare(`UPDATE work_items SET status = ?, current_action_id = ?,
+          current_run_id = NULL, ledger_revision = ledger_revision + ?, updated_at = ?
+          WHERE id = ? AND status IN ('ready', 'running', 'waiting', 'needs_attention') AND revision = ?`).run(
+          workItemStatus, currentActionId, ledgerIncrement, now, workItem.id, nextWorkItem.revision,
+        );
+      } else if (transition.graphAdvance) {
         const graphState = this.#graphWorkItemState(workItem.id);
         workItemStatus = graphState.status;
         currentActionId = graphState.currentActionId;
@@ -2233,7 +2304,9 @@ export class WorkItemStore {
             (work_item_id, proposal_id, base_plan_revision, plan_revision, kind, action_id, run_id, data, created_at)
             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
             workItem.id, proposalId, workItem.planRevision, nextWorkItem.planRevision,
-            transition.replanBarrier ? 'replan' : (workItem.planRevision === 0 ? 'initial' : 'expand'),
+            (transition.replanBarrier || transition.replanMutation)
+              ? 'replan'
+              : (workItem.planRevision === 0 ? 'initial' : 'expand'),
             action.id, runId, stringify(transition.eventData || {}), now,
           );
         } catch (error) {