@yeaft/webchat-agent 1.0.217 → 1.0.219

package/package.json

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

@@ -148,6 +148,39 @@ function sumExecutionStats(values) {
   }, emptyExecutionStats());
 }
 
+function actionGeneration(value) {
+  return Math.max(1, count(value) || 1);
+}
+
+function runGeneration(run) {
+  return actionGeneration(run?.actionGeneration ?? run?.executionManifest?.actionGeneration);
+}
+
+function runSpecHash(run) {
+  return typeof run?.actionSpecHash === 'string' && run.actionSpecHash
+    ? run.actionSpecHash
+    : typeof run?.executionManifest?.actionSpecHash === 'string'
+      ? run.executionManifest.actionSpecHash
+      : '';
+}
+
+function threadRuns(action, runs) {
+  const source = (Array.isArray(runs) ? runs : []).filter(run => run?.actionId === action?.id);
+  const selectedSpecByGeneration = new Map((Array.isArray(action?.identityHistory) ? action.identityHistory : [])
+    .filter(identity => typeof identity?.specHash === 'string' && identity.specHash)
+    .map(identity => [actionGeneration(identity.generation), identity.specHash]));
+  const currentGeneration = actionGeneration(action?.generation);
+  if (typeof action?.specHash === 'string' && action.specHash) {
+    selectedSpecByGeneration.set(currentGeneration, action.specHash);
+  }
+  return source.filter(run => {
+    const generation = runGeneration(run);
+    const selectedSpec = selectedSpecByGeneration.get(generation) || '';
+    const spec = runSpecHash(run);
+    return selectedSpec ? spec === selectedSpec : generation === 1 && !spec;
+  });
+}
+
 function normalizeProjectedMessage(message) {
   if (!message || typeof message !== 'object') return null;
   const text = typeof message.text === 'string'
@@ -167,13 +200,14 @@ function normalizeProjectedMessage(message) {
     ...(message.progressRevision == null ? {} : { progressRevision: count(message.progressRevision) }),
     ...(message.generation == null ? {} : { generation: Math.max(1, count(message.generation) || 1) }),
     ...(message.attempt == null ? {} : { attempt: Math.max(1, count(message.attempt) || 1) }),
+    ...(message.runId == null ? {} : { runId: String(message.runId) }),
   };
 }
 
-function actionInputMessages(action, events) {
+function actionInputMessages(action, events, generation = actionGeneration(action?.generation), includeThreadIdentity = false) {
   return (Array.isArray(events) ? events : [])
     .filter(event => event?.actionId === action?.id
-      && eventMatchesActionGeneration(event, action)
+      && actionGeneration(event.actionGeneration) === generation
       && ['action.guidance_added', 'action.input_added'].includes(event.type))
     .map(event => normalizeProjectedMessage({
       id: `event:${event.id}`,
@@ -183,11 +217,12 @@ function actionInputMessages(action, events) {
       text: event.data?.text || event.data?.guidance || '',
       attachments: event.data?.attachments,
       createdAt: event.createdAt,
+      ...(includeThreadIdentity ? { generation } : {}),
     }))
     .filter(Boolean);
 }
 
-function runResponseMessage(run) {
+function runResponseMessage(run, includeThreadIdentity = false) {
   return normalizeProjectedMessage({
     id: `run:${run.id}`,
     role: 'assistant',
@@ -197,15 +232,18 @@ function runResponseMessage(run) {
     createdAt: count(run.startedAt),
     updatedAt: count(run.endedAt || run.startedAt),
     progressRevision: count(run.progressRevision),
-    generation: run.actionGeneration,
-    attempt: run.actionAttempt,
+    ...(includeThreadIdentity ? {
+      generation: runGeneration(run),
+      attempt: run.actionAttempt,
+      runId: run.id,
+    } : {}),
   });
 }
 
-function loopOutputMessages(action, events, matchingRunIds) {
+function loopOutputMessages(action, events, matchingRunIds, generation = actionGeneration(action?.generation), includeThreadIdentity = false) {
   return (Array.isArray(events) ? events : [])
     .filter(event => event?.actionId === action?.id
-      && eventMatchesActionGeneration(event, action)
+      && actionGeneration(event.actionGeneration ?? event.data?.actionGeneration) === generation
       && matchingRunIds.has(event.runId)
       && event.type === 'run.loop_output')
     .map(event => normalizeProjectedMessage({
@@ -215,33 +253,73 @@ function loopOutputMessages(action, events, matchingRunIds) {
       status: 'completed',
       text: event.data?.response || '',
       createdAt: event.createdAt,
-      generation: event.actionGeneration ?? event.data?.actionGeneration,
-      attempt: event.data?.actionAttempt,
+      ...(includeThreadIdentity ? {
+        generation: event.actionGeneration ?? event.data?.actionGeneration,
+        attempt: event.data?.actionAttempt,
+        runId: event.runId,
+      } : {}),
     }))
     .filter(Boolean);
 }
 
-function actionMessages(action, runs, events) {
-  const matchingRuns = Array.isArray(runs)
-    ? runs.filter(run => run?.actionId === action?.id && runMatchesActionIdentity(run, action))
-    : [];
+function messagesForGeneration(action, runs, events, generation, includeThreadIdentity = false) {
+  const matchingRuns = threadRuns(action, runs).filter(run => runGeneration(run) === generation);
   const matchingRunIds = new Set(matchingRuns.map(run => run.id));
   const runsWithLoopOutput = new Set((Array.isArray(events) ? events : [])
     .filter(event => event?.actionId === action?.id
-      && eventMatchesActionGeneration(event, action)
+      && actionGeneration(event.actionGeneration ?? event.data?.actionGeneration) === generation
       && matchingRunIds.has(event.runId)
       && event.type === 'run.loop_output')
     .map(event => event.runId));
-  return [...actionInputMessages(action, events), ...loopOutputMessages(action, events, matchingRunIds), ...matchingRuns
+  return [
+    ...actionInputMessages(action, events, generation, includeThreadIdentity),
+    ...loopOutputMessages(action, events, matchingRunIds, generation, includeThreadIdentity),
+    ...matchingRuns
     .sort((left, right) => count(left.startedAt) - count(right.startedAt))
     .filter(run => !runsWithLoopOutput.has(run.id))
-    .map(run => runResponseMessage(run))
+    .map(run => runResponseMessage(run, includeThreadIdentity))
     .filter(Boolean)]
     .sort((left, right) => left.createdAt - right.createdAt
       || (left.role === 'user' ? -1 : 1)
       || left.id.localeCompare(right.id));
 }
 
+function actionMessages(action, runs, events) {
+  return messagesForGeneration(action, runs, events, actionGeneration(action?.generation));
+}
+
+function projectActionThread(action, runs, events) {
+  const allRuns = threadRuns(action, runs);
+  const generations = new Set([
+    actionGeneration(action?.generation),
+    ...allRuns.map(runGeneration),
+    ...(Array.isArray(events) ? events : [])
+      .filter(event => event?.actionId === action?.id
+        && ['action.guidance_added', 'action.input_added', 'run.loop_output'].includes(event.type))
+      .map(event => actionGeneration(event.actionGeneration ?? event.data?.actionGeneration)),
+  ]);
+  return [...generations].sort((left, right) => left - right).map(generation => {
+    const canonical = generation === actionGeneration(action?.generation);
+    return {
+      generation,
+      canonical,
+      messages: canonical ? [] : messagesForGeneration(action, allRuns, events, generation, true).slice(-MAX_ACTION_MESSAGES),
+      runs: allRuns.filter(run => runGeneration(run) === generation)
+        .sort((left, right) => count(left.startedAt) - count(right.startedAt) || String(left.id).localeCompare(String(right.id)))
+        .map(run => ({
+          id: run.id,
+          attempt: Math.max(1, count(run.actionAttempt) || 1),
+          status: run.status || 'running',
+          startedAt: count(run.startedAt),
+          endedAt: count(run.endedAt),
+          progressRevision: count(run.progressRevision),
+          loopCount: count(run.loopCount),
+          toolCount: count(run.toolCount),
+        })),
+    };
+  }).filter(entry => entry.messages.length > 0 || entry.runs.length > 0 || entry.canonical);
+}
+
 
 
 const MAX_FAILURE_REASON_LENGTH = 2_000;
@@ -457,6 +535,7 @@ function projectAction(action, runs, events, includeBody = true) {
       response: execution.response,
       failure: execution.failure,
       messages: execution.messages,
+      thread: Array.isArray(runs) ? projectActionThread(action, runs, events) : (action.thread || []),
       liveMessage: execution.liveMessage,
     } : {}),
   };
@@ -478,6 +557,7 @@ function stripActionBody(action, keepFailure = false) {
   const projected = { ...action };
   delete projected.response;
   delete projected.messages;
+  delete projected.thread;
   delete projected.liveMessage;
   if (!keepFailure) delete projected.failure;
   if (projected.brief) {
@@ -539,6 +619,7 @@ function enforceWorkItemBrowserDtoBudget(value, options = {}) {
   if (keep) {
     delete keep.response;
     delete keep.messages;
+    delete keep.thread;
     delete keep.liveMessage;
   }
   if (jsonByteLength(dto) <= MAX_WORK_ITEM_BROWSER_DTO_BYTES) return dto;
@@ -844,12 +925,18 @@ export function projectActionMessagePage(action, runs, events, options = {}) {
   };
 }
 
+export function actionThreadIncludesRun(action, runs, runId) {
+  return threadRuns(action, runs).some(run => run.id === runId);
+}
+
 export function projectActionRequestIndex(action, entries) {
+  const source = Array.isArray(entries) ? entries : [];
+  const allowedRunIds = new Set(threadRuns(action, source.map(({ run }) => run)).map(run => run.id));
   return {
     actionId: action.id,
     generation: Math.max(1, count(action.generation) || 1),
-    requests: (Array.isArray(entries) ? entries : [])
-      .filter(({ run }) => runMatchesActionIdentity(run, action))
+    requests: source
+      .filter(({ run }) => allowedRunIds.has(run?.id))
       .map(({ run, turn }) => ({
       id: turn.turnId,
       runId: run.id,
@@ -872,8 +959,8 @@ export function projectActionRequestIndex(action, entries) {
   };
 }
 
-export function projectActionRequestDetail(action, run, history) {
-  if (!runMatchesActionIdentity(run, action)) return null;
+export function projectActionRequestDetail(action, run, history, runs = [run]) {
+  if (!actionThreadIncludesRun(action, runs, run?.id)) return null;
   const turn = Array.isArray(history?.turns) ? history.turns[0] : null;
   if (!turn) return null;
   const sourceLoops = Array.isArray(history?.loops) ? history.loops : [];

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/service.js

@@ -1,7 +1,6 @@
 import { realpathSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { runMatchesActionIdentity } from './action-identity.js';
 import { WorkItemStore } from './store.js';
 import { WorkflowController } from './controller.js';
 import { WorkItemWatcher } from './watcher.js';
@@ -143,8 +142,7 @@ export class WorkCenterService {
         const detail = this.#requiredItem(payload.id);
         const action = this.#requiredAction(detail, payload.actionId);
         const entries = [];
-        for (const run of detail.runs.filter(item => item.actionId === action.id
-          && runMatchesActionIdentity(item, action))) {
+        for (const run of detail.runs.filter(item => item.actionId === action.id)) {
           const history = await this.#debugHistory(run, { indexOnly: true });
           for (const turn of Array.isArray(history?.turns) ? history.turns : []) {
             entries.push({ run, turn });
@@ -156,11 +154,10 @@ export class WorkCenterService {
         const detail = this.#requiredItem(payload.id);
         const action = this.#requiredAction(detail, payload.actionId);
         const requestId = requiredString(payload.requestId, 'requestId');
-        const run = detail.runs.find(item => item.actionId === action.id
-          && item.id === payload.runId && runMatchesActionIdentity(item, action));
+        const run = detail.runs.find(item => item.actionId === action.id && item.id === payload.runId);
         if (!run) throw new Error('Action request not found');
         const history = await this.#debugHistory(run, { detailTurnId: requestId });
-        const projected = projectActionRequestDetail(action, run, history);
+        const projected = projectActionRequestDetail(action, run, history, detail.runs);
         if (!projected) throw new Error('Action request detail is no longer available');
         return projected;
       }