@yeaft/webchat-agent 1.0.216 → 1.0.218

package/local-runtime/version.json

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

package/package.json

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

@@ -1,7 +1,7 @@
 /**
  * search.js — Conversation history search
  *
- * Simple keyword search across hot and cold messages.
+ * Bounded content search across hot and cold messages.
  */
 
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
@@ -18,36 +18,77 @@ function parseJsonLine(line) {
   }
 }
 
+function normalizeTerms(keyword) {
+  return String(keyword || '')
+    .trim()
+    .toLocaleLowerCase()
+    .split(/\s+/u)
+    .filter(Boolean);
+}
+
+function searchableContent(msg) {
+  if (typeof msg?.content === 'string') return msg.content;
+  if (Array.isArray(msg?.content)) {
+    return msg.content
+      .map(block => typeof block === 'string' ? block : (block?.text || ''))
+      .filter(Boolean)
+      .join('\n');
+  }
+  return '';
+}
+
+function matchesMessage(msg, terms) {
+  if (!msg || msg.role === 'tool') return false;
+  const content = searchableContent(msg).toLocaleLowerCase();
+  return content.length > 0 && terms.every(term => content.includes(term));
+}
+
+function recordFileScan(telemetry, raw) {
+  if (!telemetry) return;
+  telemetry.scannedFiles += 1;
+  telemetry.scannedBytes += Buffer.byteLength(raw, 'utf8');
+}
+
+function recordMessageScan(telemetry) {
+  if (telemetry) telemetry.scannedMessages += 1;
+}
+
+function withSource(msg, source) {
+  return {
+    ...msg,
+    content: searchableContent(msg),
+    sessionId: msg.sessionId || source.sessionId || null,
+    historySource: source.kind,
+  };
+}
+
 /**
- * Search Markdown messages in a directory for a keyword.
- *
- * @param {string} dir — messages directory
- * @param {string} keyword — search term (case-insensitive)
- * @returns {object[]} — matching messages
+ * Search Markdown messages in one directory, newest first.
  */
-function searchMarkdownDir(dir, keyword) {
+function searchMarkdownDir(dir, terms, limit, source, telemetry) {
   if (!existsSync(dir)) return [];
 
-  const lowerKeyword = keyword.toLowerCase();
   const files = readdirSync(dir)
     .filter(f => f.endsWith('.md'))
     .sort()
-    .reverse(); // newest first within one directory
+    .reverse();
 
   const results = [];
   for (const file of files) {
+    if (results.length >= limit) break;
     const raw = readFileSync(join(dir, file), 'utf8');
-    if (!raw.toLowerCase().includes(lowerKeyword)) continue;
-
+    recordFileScan(telemetry, raw);
+    recordMessageScan(telemetry);
+    const lowerRaw = raw.toLocaleLowerCase();
+    if (!terms.every(term => lowerRaw.includes(term))) continue;
     const msg = parseMessage(raw);
-    if (msg) results.push(msg);
+    if (matchesMessage(msg, terms)) results.push(withSource(msg, source));
   }
   return results;
 }
 
-function searchSegmentDir(dir, keyword) {
+function searchSegmentDir(dir, terms, limit, source, telemetry) {
   if (!existsSync(dir)) return [];
-  const lowerKeyword = keyword.toLowerCase();
   const files = readdirSync(dir)
     .filter(f => f.endsWith('.jsonl'))
     .sort()
@@ -55,24 +96,30 @@ function searchSegmentDir(dir, keyword) {
 
   const results = [];
   for (const file of files) {
+    if (results.length >= limit) break;
     const raw = readFileSync(join(dir, file), 'utf8');
-    if (!raw.toLowerCase().includes(lowerKeyword)) continue;
+    recordFileScan(telemetry, raw);
+    const lowerRaw = raw.toLocaleLowerCase();
+    if (!terms.every(term => lowerRaw.includes(term))) continue;
     const lines = raw.split('\n');
     for (let i = lines.length - 1; i >= 0; i -= 1) {
-      const line = lines[i];
-      if (!line || !line.toLowerCase().includes(lowerKeyword)) continue;
-      const msg = parseJsonLine(line);
-      if (msg) results.push(msg);
+      if (results.length >= limit) break;
+      if (!lines[i]?.trim()) continue;
+      recordMessageScan(telemetry);
+      const msg = parseJsonLine(lines[i]);
+      if (matchesMessage(msg, terms)) results.push(withSource(msg, source));
     }
   }
   return results;
 }
 
 function compareNewest(a, b) {
+  const timeComparison = String(b?.time || b?.timestamp || '').localeCompare(String(a?.time || a?.timestamp || ''));
+  if (timeComparison !== 0) return timeComparison;
+  if (a?.sessionId !== b?.sessionId || a?.historySource !== b?.historySource) return 0;
   const sa = parseSeqFromId(a?.id);
   const sb = parseSeqFromId(b?.id);
-  if (Number.isFinite(sa) && Number.isFinite(sb) && sa !== sb) return sb - sa;
-  return String(b?.time || '').localeCompare(String(a?.time || ''));
+  return Number.isFinite(sa) && Number.isFinite(sb) ? sb - sa : 0;
 }
 
 function sessionConversationDirs(dir) {
@@ -92,40 +139,56 @@ function sessionConversationDirs(dir) {
       const conversationDir = join(sessionDir, 'conversation');
       if (seen.has(conversationDir)) continue;
       seen.add(conversationDir);
-      dirs.push(conversationDir);
+      dirs.push({ dir: conversationDir, sessionId: name, kind: rootName === 'sessions' ? 'session' : 'legacy-session' });
     }
   }
   return dirs;
 }
 
 /**
- * Search Yeaft history (chat + per-session + legacy conversation) for a keyword.
+ * Search Yeaft history (chat + per-session + legacy conversation) by content.
+ * Whitespace-separated terms use AND semantics. Tool messages are excluded.
  *
  * @param {string} dir — Yeaft root directory (e.g. ~/.yeaft)
- * @param {string} keyword — search term
- * @param {number} [limit=20] — max results
+ * @param {string} keyword — search terms
+ * @param {number} [limit=10] — max results
+ * @param {{telemetry?: {scannedFiles?: number, scannedBytes?: number, scannedMessages?: number}}} [options]
  * @returns {object[]} — matching messages, newest first
  */
-export function searchMessages(dir, keyword, limit = 20) {
-  if (!keyword || !keyword.trim()) return [];
+export function searchMessages(dir, keyword, limit = 10, options = {}) {
+  const terms = normalizeTerms(keyword);
+  if (terms.length === 0) return [];
+
+  const resultLimit = Math.max(1, Math.min(100, Math.floor(Number(limit) || 10)));
+  const telemetry = options.telemetry || null;
+  if (telemetry) {
+    telemetry.scannedFiles = 0;
+    telemetry.scannedBytes = 0;
+    telemetry.scannedMessages = 0;
+  }
 
   const conversationDirs = [
-    join(dir, 'chat'),
+    { dir: join(dir, 'chat'), sessionId: null, kind: 'chat' },
     ...sessionConversationDirs(dir),
   ];
 
   const markdownDirs = [
-    ...conversationDirs.flatMap(d => [join(d, 'messages'), join(d, 'cold')]),
-    // Compatibility for profiles created before chat/session split.
-    join(dir, 'conversation', 'messages'),
-    join(dir, 'conversation', 'cold'),
+    ...conversationDirs.flatMap(source => [
+      { ...source, dir: join(source.dir, 'messages') },
+      { ...source, dir: join(source.dir, 'cold') },
+    ]),
+    { dir: join(dir, 'conversation', 'messages'), sessionId: null, kind: 'legacy-conversation' },
+    { dir: join(dir, 'conversation', 'cold'), sessionId: null, kind: 'legacy-conversation' },
   ];
-  const segmentDirs = conversationDirs.map(d => join(d, 'segments'));
+  const segmentDirs = conversationDirs.map(source => ({ ...source, dir: join(source.dir, 'segments') }));
 
-  return [
-    ...segmentDirs.flatMap(d => searchSegmentDir(d, keyword)),
-    ...markdownDirs.flatMap(d => searchMarkdownDir(d, keyword)),
+  const results = [
+    ...segmentDirs.flatMap(source => searchSegmentDir(source.dir, terms, resultLimit, source, telemetry)),
+    ...markdownDirs.flatMap(source => searchMarkdownDir(source.dir, terms, resultLimit, source, telemetry)),
   ]
     .sort(compareNewest)
-    .slice(0, limit);
+    .slice(0, resultLimit);
+
+  if (telemetry) telemetry.resultCount = results.length;
+  return results;
 }

package/yeaft/tools/history-search.js

@@ -8,20 +8,144 @@
 import { defineTool } from './types.js';
 import { searchMessages } from '../conversation/search.js';
 
+const DEFAULT_RESULT_LIMIT = 10;
+const MAX_SNIPPET_CHARS = 1000;
+export const HISTORY_SEARCH_MAX_OUTPUT_BYTES = 32 * 1024;
+
+function truncateUtf8(text, maxBytes) {
+  if (maxBytes <= 0) return '';
+  const buffer = Buffer.from(String(text), 'utf8');
+  if (buffer.length <= maxBytes) return String(text);
+  let end = maxBytes;
+  while (end > 0 && (buffer[end] & 0xc0) === 0x80) end -= 1;
+  return buffer.subarray(0, end).toString('utf8');
+}
+
+function isHighSurrogate(codeUnit) {
+  return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+}
+
+function isLowSurrogate(codeUnit) {
+  return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
+}
+
+function lowercaseWithOriginalOffsets(text) {
+  const fullLower = text.toLocaleLowerCase();
+  const lowerParts = [];
+  const originalOffsets = [];
+  for (let offset = 0; offset < text.length;) {
+    const codePoint = String.fromCodePoint(text.codePointAt(offset));
+    const loweredCodePoint = codePoint.toLocaleLowerCase();
+    lowerParts.push(loweredCodePoint);
+    for (let i = 0; i < loweredCodePoint.length; i += 1) originalOffsets.push(offset);
+    offset += codePoint.length;
+  }
+
+  const mappedLower = lowerParts.join('');
+  return {
+    lower: mappedLower.length === fullLower.length ? fullLower : mappedLower,
+    originalOffsets,
+  };
+}
+
+function buildSnippet(content, keyword, maxChars = MAX_SNIPPET_CHARS) {
+  const text = String(content || '');
+  if (text.length <= maxChars) return text;
+
+  const terms = String(keyword || '').trim().toLocaleLowerCase().split(/\s+/u).filter(Boolean);
+  const { lower, originalOffsets } = lowercaseWithOriginalOffsets(text);
+  const positions = terms.map(term => lower.indexOf(term)).filter(pos => pos >= 0);
+  const transformedMatchAt = positions.length > 0 ? Math.min(...positions) : 0;
+  const matchAt = originalOffsets[transformedMatchAt] ?? 0;
+  let start = Math.max(0, Math.min(matchAt - Math.floor(maxChars / 3), text.length - maxChars));
+  let end = Math.min(text.length, start + maxChars);
+
+  if (start > 0 && isLowSurrogate(text.charCodeAt(start)) && isHighSurrogate(text.charCodeAt(start - 1))) {
+    start -= 1;
+  }
+  if (end < text.length && isLowSurrogate(text.charCodeAt(end)) && isHighSurrogate(text.charCodeAt(end - 1))) {
+    end -= 1;
+  }
+
+  return `${start > 0 ? '...' : ''}${text.slice(start, end)}${end < text.length ? '...' : ''}`;
+}
+
+export function serializeHistorySearchOutput(payload, maxBytes = HISTORY_SEARCH_MAX_OUTPUT_BYTES) {
+  const serialize = value => JSON.stringify(value, null, 2);
+  let output = serialize(payload);
+  if (Buffer.byteLength(output, 'utf8') <= maxBytes) return output;
+
+  const originalResultCount = payload.results.length;
+  const bounded = {
+    ...payload,
+    results: [],
+    truncated: true,
+    omittedResults: originalResultCount,
+  };
+
+  for (const result of payload.results) {
+    const candidate = {
+      ...bounded,
+      results: [...bounded.results, result],
+      omittedResults: originalResultCount - bounded.results.length - 1,
+    };
+    const candidateOutput = serialize(candidate);
+    if (Buffer.byteLength(candidateOutput, 'utf8') <= maxBytes) {
+      bounded.results.push(result);
+      bounded.omittedResults -= 1;
+      continue;
+    }
+
+    const emptyContentCandidate = {
+      ...candidate,
+      results: [...bounded.results, { ...result, content: '' }],
+    };
+    const emptyOutput = serialize(emptyContentCandidate);
+    if (Buffer.byteLength(emptyOutput, 'utf8') > maxBytes) break;
+
+    let low = 0;
+    let high = Buffer.byteLength(result.content || '', 'utf8');
+    let best = '';
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const content = truncateUtf8(result.content || '', mid);
+      const partialOutput = serialize({
+        ...candidate,
+        results: [...bounded.results, { ...result, content }],
+      });
+      if (Buffer.byteLength(partialOutput, 'utf8') <= maxBytes) {
+        best = content;
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    bounded.results.push({ ...result, content: best });
+    bounded.omittedResults -= 1;
+    break;
+  }
+
+  output = serialize(bounded);
+  if (Buffer.byteLength(output, 'utf8') > maxBytes) {
+    throw new Error('History search output metadata exceeds the 32 KiB budget');
+  }
+  return output;
+}
+
 export default defineTool({
   name: 'HistorySearch',
   description: {
     en: `Search through past conversation history.
 
-Searches for keywords in previously persisted conversation messages.
-Useful for finding previous discussions, decisions, or code snippets.
+Searches message content for all whitespace-separated terms (case-insensitive).
+Tool-result messages are excluded. Useful for finding previous discussions, decisions, or code snippets.
 
-Results are returned newest-first with message role and content.`,
+Results are returned newest-first with a bounded matching snippet and source metadata.`,
     zh: `搜索历史对话记录。
 
-在已持久化的对话消息中按关键词搜索。用于查找之前的讨论、决策或代码片段。
+在已持久化消息的正文中搜索全部空格分隔的关键词（不区分大小写），并排除工具结果消息。用于查找之前的讨论、决策或代码片段。
 
-结果按最新优先返回，包含消息角色和内容。`
+结果按最新优先返回，包含有界的命中片段和来源信息。`
   },
   parameters: {
     type: 'object',
@@ -29,15 +153,15 @@ Results are returned newest-first with message role and content.`,
       keyword: {
         type: 'string',
         description: {
-          en: 'Search keyword (case-insensitive)',
-          zh: '搜索关键词（不区分大小写）',
+          en: 'Search terms (case-insensitive, whitespace-separated terms use AND semantics)',
+          zh: '搜索关键词（不区分大小写，空格分隔的多个词采用 AND 语义）',
         },
       },
       limit: {
         type: 'number',
         description: {
-          en: 'Maximum number of results (default: 20)',
-          zh: '最多返回结果数（默认 20）',
+          en: 'Maximum number of results (default: 10, maximum: 100)',
+          zh: '最多返回结果数（默认 10，最大 100）',
         },
       },
     },
@@ -46,7 +170,7 @@ Results are returned newest-first with message role and content.`,
   isConcurrencySafe: () => true,
   isReadOnly: () => true,
   async execute(input, ctx) {
-    const { keyword, limit = 20 } = input;
+    const { keyword, limit = DEFAULT_RESULT_LIMIT } = input;
     if (!keyword) return JSON.stringify({ error: 'keyword is required' });
 
     const yeaftDir = ctx?.yeaftDir;
@@ -55,25 +179,37 @@ Results are returned newest-first with message role and content.`,
     }
 
     try {
-      const results = searchMessages(yeaftDir, keyword, limit);
+      const telemetry = {};
+      const results = searchMessages(yeaftDir, keyword, limit, { telemetry });
+      const searchTelemetry = {
+        resultCount: results.length,
+        scannedFiles: telemetry.scannedFiles || 0,
+        scannedMessages: telemetry.scannedMessages || 0,
+        scannedBytes: telemetry.scannedBytes || 0,
+      };
 
       if (results.length === 0) {
-        return JSON.stringify({
+        return serializeHistorySearchOutput({
           results: [],
           message: `No matches found for "${keyword}"`,
+          telemetry: searchTelemetry,
         });
       }
 
-      return JSON.stringify({
+      return serializeHistorySearchOutput({
         results: results.map(msg => ({
+          messageId: msg.id || null,
+          sessionId: msg.sessionId || null,
           role: msg.role,
-          content: msg.content?.slice(0, 2000) + (msg.content?.length > 2000 ? '...' : ''),
+          content: buildSnippet(msg.content, keyword),
           mode: msg.mode,
-          timestamp: msg.timestamp,
+          time: msg.time || msg.timestamp || null,
+          source: msg.historySource || null,
         })),
         totalResults: results.length,
         keyword,
-      }, null, 2);
+        telemetry: searchTelemetry,
+      });
     } catch (err) {
       return JSON.stringify({ error: `History search failed: ${err.message}` });
     }

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) {