vibe-coding-master 0.7.50 → 0.8.1

package/dist/backend/adapters/filesystem.js

@@ -41,6 +41,12 @@ export function createNodeFileSystemAdapter() {
                 }
             });
         },
+        async fileVersion(targetPath) {
+            return runFileOperation(async () => {
+                const stat = await fs.stat(targetPath, { bigint: true });
+                return `${stat.mtimeNs}:${stat.size}`;
+            });
+        },
         async writeText(targetPath, content) {
             await runFileOperation(async () => {
                 await fs.mkdir(path.dirname(targetPath), { recursive: true });

package/dist/backend/api/task-routes.js

@@ -65,11 +65,17 @@ export function registerTaskRoutes(app, deps) {
                     taskSlug
                 }) ?? Promise.resolve(degradedWorkflowState(taskSlug))
             ]);
+            const displayedRoundState = await delayFlowPauseForTranslation(deps, {
+                repoRoot: project.repoRoot,
+                taskRepoRoot,
+                taskSlug,
+                roundState
+            });
             return {
                 taskStatus,
                 messages,
                 orchestration,
-                roundState,
+                roundState: displayedRoundState,
                 workflowState,
                 architectRestart: deps.architectRestartService.getState(project.repoRoot, taskSlug),
                 roleStallWarning: deps.roleStallDetector.getWarning(project.repoRoot, taskSlug)
@@ -136,6 +142,19 @@ export function registerTaskRoutes(app, deps) {
         return deps.taskCloseService.closeTask(project.repoRoot, request.params.taskSlug);
     });
 }
+async function delayFlowPauseForTranslation(deps, input) {
+    if (!input.roundState.flowPause?.paused || !deps.translationService) {
+        return input.roundState;
+    }
+    try {
+        const pending = await deps.translationService.shouldDelayFlowPauseNotification(input);
+        return pending ? { ...input.roundState, flowPause: undefined } : input.roundState;
+    }
+    catch {
+        // Translation-state failures must release, rather than suppress, the pause alert.
+        return input.roundState;
+    }
+}
 function requireWarningId(value) {
     if (typeof value === "string" && value.trim()) {
         return value.trim();

package/dist/backend/server.js

@@ -137,7 +137,8 @@ export async function createServer(deps, options = {}) {
         roundService: deps.roundService,
         taskWorkflowService: deps.taskWorkflowService,
         architectRestartService: deps.architectRestartService,
-        roleStallDetector: deps.roleStallDetector
+        roleStallDetector: deps.roleStallDetector,
+        translationService: deps.translationService
     });
     registerSessionRoutes(app, {
         projectService: deps.projectService,
@@ -411,7 +412,8 @@ export function createDefaultServerDeps(options = {}) {
         taskService,
         translationWorkerService,
         architectRestartService,
-        roleContextRestartService
+        roleContextRestartService,
+        workflowControlService
     });
     const claudeHookService = createClaudeHookService({
         projectService,

package/dist/backend/services/auto-memory-service.js

@@ -4,7 +4,7 @@ import { checkMarkdownArtifact, readArtifactSectionValue } from "../../shared/va
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
-import { readVcmMemoryBlock, replaceVcmMemoryBlock } from "../templates/harness/memory-block.js";
+import { readVcmMemoryHostFrame, readVcmMemoryBlock, replaceVcmMemoryBlock } from "../templates/harness/memory-block.js";
 import { ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH, architectPlanningCandidateSnapshotPath, memoryReviewRoleDraftPath, MEMORY_REVIEW_RUNS_ROOT, MEMORY_REVIEW_STATE_PATH } from "./memory-review-paths.js";
 import { parseMemoryProposal, validateMemoryProposal } from "./memory-proposal-validation.js";
 const MEMORY_FILE_DEFINITIONS = [
@@ -101,15 +101,20 @@ export function createAutoMemoryService(deps) {
             await deps.fs.writeText(resolveRepoPath(taskRepoRoot, memoryRunHostFilePath(runId, definition.path)), await deps.fs.readText(resolveRepoPath(taskRepoRoot, definition.path)));
         }
     }
-    async function assertOnlyMemoryBlocksChanged(taskRepoRoot, runId, currentMemory) {
+    async function assertOnlyMemoryBlocksChanged(taskRepoRoot, runId) {
         for (const definition of MEMORY_FILE_DEFINITIONS) {
             const beforeHost = await deps.fs.readText(resolveRepoPath(taskRepoRoot, memoryRunHostFilePath(runId, definition.path)));
             const currentHost = await deps.fs.readText(resolveRepoPath(taskRepoRoot, definition.path));
-            const expectedHost = replaceVcmMemoryBlock(beforeHost, currentMemory[definition.path]);
-            if (currentHost !== expectedHost) {
+            const beforeFrame = readVcmMemoryHostFrame(beforeHost);
+            const currentFrame = readVcmMemoryHostFrame(currentHost);
+            if (!beforeFrame || !currentFrame) {
+                throw missingMemoryBlockError(definition.path);
+            }
+            const difference = describeMemoryHostDifference(beforeFrame, currentFrame);
+            if (difference) {
                 throw new VcmError({
                     code: "MEMORY_REVIEW_SCOPE_CHANGED",
-                    message: `Harness Engineer changed content outside the VCM memory block: ${definition.path}`,
+                    message: `Harness Engineer changed content outside the VCM memory block: ${definition.path} (${difference}).`,
                     statusCode: 409,
                     hint: "Restore non-memory content, keep only the reviewed <VCM-memory> edit, and commit the correction."
                 });
@@ -302,6 +307,7 @@ export function createAutoMemoryService(deps) {
             });
         }
         await writeRunMemoryHostSnapshot(taskRepoRoot, state.runId);
+        const existingEntries = collectExistingMemoryReviewEntries(beforeMemory);
         const timestamp = now();
         state.reviewPromptDispatchedAt = timestamp;
         state.retrospectiveReportPath = retrospectiveReportPath;
@@ -309,12 +315,19 @@ export function createAutoMemoryService(deps) {
         state.updatedAt = timestamp;
         await persistActiveState(taskRepoRoot, state);
         const runRoot = resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${state.runId}`);
+        const existingEntriesPath = path.join(runRoot, "existing-entries.json");
+        await deps.fs.writeJsonAtomic(existingEntriesPath, {
+            version: 1,
+            runId: state.runId,
+            entries: existingEntries
+        });
         const planningCandidatePath = await findPlanningCandidateSnapshot(taskRepoRoot, state.runId);
         return {
             runId: state.runId,
             roleDraftsPath: path.join(runRoot, "drafts"),
             currentMemoryPath: path.join(runRoot, "before"),
             activeMemoryPaths: memoryPaths.map((memoryPath) => resolveRepoPath(taskRepoRoot, memoryPath)),
+            existingEntriesPath,
             reviewResultPath: path.join(runRoot, "review-result.json"),
             proposalCandidates,
             ...(planningCandidatePath
@@ -825,7 +838,7 @@ export function createAutoMemoryService(deps) {
         }
         const before = await readRunMemorySet(taskRepoRoot, state.runId, "before");
         const after = await readMemorySet(taskRepoRoot);
-        await assertOnlyMemoryBlocksChanged(taskRepoRoot, state.runId, after);
+        await assertOnlyMemoryBlocksChanged(taskRepoRoot, state.runId);
         const memoryPaths = MEMORY_FILE_DEFINITIONS.map((definition) => definition.path);
         const uncommittedMemoryDiff = await deps.git.getDiff(taskRepoRoot, "HEAD", null, memoryPaths);
         if (uncommittedMemoryDiff.trim()) {
@@ -966,31 +979,35 @@ export function createAutoMemoryService(deps) {
                 statusCode: 409
             });
         }
-        for (const decision of result.decisions.filter((candidate) => candidate.source === "existing")) {
-            const memoryPath = memoryTargetToPath(decision.target);
-            if (!substantiveMemoryEntries(before[memoryPath]).includes(decision.entry)) {
+        const existingEntries = collectExistingMemoryReviewEntries(before);
+        const existingDecisions = result.decisions.filter((candidate) => candidate.source === "existing");
+        for (const decision of existingDecisions) {
+            const assigned = existingEntries.find((entry) => entry.itemId === decision.itemId);
+            if (!assigned) {
                 throw new VcmError({
                     code: "MEMORY_REVIEW_EXISTING_DECISION_UNKNOWN",
                     message: `review-result.json contains an unknown existing-memory decision: ${decision.itemId}`,
                     statusCode: 409
                 });
             }
+            if (decision.target !== assigned.target || decision.entry !== assigned.entry) {
+                throw new VcmError({
+                    code: "MEMORY_REVIEW_EXISTING_DECISION_MISMATCH",
+                    message: `Existing-memory decision must copy the assigned target and entry exactly: ${decision.itemId}`,
+                    statusCode: 409
+                });
+            }
         }
-        for (const definition of MEMORY_FILE_DEFINITIONS) {
-            const target = memoryPathToTarget(definition.path);
-            for (const entry of substantiveMemoryEntries(before[definition.path])) {
-                const matches = result.decisions.filter((decision) => decision.source === "existing"
-                    && decision.target === target
-                    && decision.entry === entry);
-                if (matches.length !== 1) {
-                    throw new VcmError({
-                        code: "MEMORY_REVIEW_EXISTING_DECISION_MISSING",
-                        message: `review-result.json must contain exactly one decision for existing memory entry in ${definition.path}: ${entry}`,
-                        statusCode: 409
-                    });
-                }
-                validateExistingMemoryDecision(definition.path, entry, matches[0], after);
+        for (const assigned of existingEntries) {
+            const matches = existingDecisions.filter((decision) => decision.itemId === assigned.itemId);
+            if (matches.length !== 1) {
+                throw new VcmError({
+                    code: "MEMORY_REVIEW_EXISTING_DECISION_MISSING",
+                    message: `review-result.json must contain exactly one decision for existing memory item ${assigned.itemId} in ${assigned.memoryPath}.`,
+                    statusCode: 409
+                });
             }
+            validateExistingMemoryDecision(assigned.memoryPath, assigned.entry, matches[0], after);
         }
         const moveDecisions = result.decisions.filter((decision) => decision.decision === "move-to-durable-doc");
         if (moveDecisions.length !== result.durableDocAssignments.length) {
@@ -1002,7 +1019,6 @@ export function createAutoMemoryService(deps) {
         }
         const assignmentKeys = new Set();
         for (const assignment of result.durableDocAssignments) {
-            validateDurableDocAssignmentInput(assignment, after);
             const key = `${assignment.sourceMemoryPath}\n${assignment.sourceEntry}\n${assignment.targetPath}`;
             if (assignmentKeys.has(key)) {
                 throw new VcmError({
@@ -1022,6 +1038,7 @@ export function createAutoMemoryService(deps) {
                     statusCode: 409
                 });
             }
+            validateDurableDocAssignmentInput(assignment, matchingDecision.source, after);
         }
         return result;
     }
@@ -1034,7 +1051,7 @@ export function createAutoMemoryService(deps) {
                 statusCode: 409
             });
         }
-        const afterEntries = new Set(substantiveMemoryEntries(after[memoryTargetToPath(decision.target)]));
+        const afterContent = after[memoryTargetToPath(decision.target)];
         if (candidate.operation === "remove") {
             if (decision.decision !== "remove" && decision.decision !== "retain") {
                 throw new VcmError({
@@ -1043,14 +1060,14 @@ export function createAutoMemoryService(deps) {
                     statusCode: 409
                 });
             }
-            if (decision.decision === "remove" && afterEntries.has(expectedEntry)) {
+            if (decision.decision === "remove" && memoryContainsReviewContent(afterContent, expectedEntry)) {
                 throw new VcmError({
                     code: "MEMORY_REVIEW_PROPOSAL_REMOVAL_MISMATCH",
                     message: `Accepted removal is still present for proposal ${candidate.id}.`,
                     statusCode: 409
                 });
             }
-            if (decision.decision === "retain" && !afterEntries.has(expectedEntry)) {
+            if (decision.decision === "retain" && !memoryContainsReviewContent(afterContent, expectedEntry)) {
                 throw new VcmError({
                     code: "MEMORY_REVIEW_PROPOSAL_RETAIN_MISMATCH",
                     message: `Rejected removal is missing from memory for proposal ${candidate.id}.`,
@@ -1067,7 +1084,7 @@ export function createAutoMemoryService(deps) {
             });
         }
         if ((decision.decision === "keep-in-memory" || decision.decision === "keep-memory-reference")
-            && !afterEntries.has(decision.finalContent)) {
+            && !memoryContainsReviewContent(afterContent, decision.finalContent)) {
             throw new VcmError({
                 code: "MEMORY_REVIEW_PROPOSAL_CONTENT_MISSING",
                 message: `Accepted proposal content is missing from memory for ${candidate.id}.`,
@@ -1076,7 +1093,7 @@ export function createAutoMemoryService(deps) {
         }
     }
     function validateExistingMemoryDecision(memoryPath, entry, decision, after) {
-        const afterEntries = new Set(substantiveMemoryEntries(after[memoryPath]));
+        const afterEntries = new Set(parseExistingMemoryEntries(after[memoryPath]));
         if (decision.decision === "retain" && !afterEntries.has(entry)) {
             throw new VcmError({
                 code: "MEMORY_REVIEW_RETAIN_MISMATCH",
@@ -1101,7 +1118,7 @@ export function createAutoMemoryService(deps) {
             }
         }
     }
-    function validateDurableDocAssignmentInput(assignment, after) {
+    function validateDurableDocAssignmentInput(assignment, source, after) {
         if (!MEMORY_FILE_DEFINITIONS.some((definition) => definition.path === assignment.sourceMemoryPath)) {
             throw new VcmError({
                 code: "MEMORY_REVIEW_ASSIGNMENT_SOURCE_INVALID",
@@ -1109,7 +1126,10 @@ export function createAutoMemoryService(deps) {
                 statusCode: 409
             });
         }
-        if (substantiveMemoryEntries(after[assignment.sourceMemoryPath]).includes(assignment.sourceEntry)) {
+        const sourceStillPresent = source === "existing"
+            ? parseExistingMemoryEntries(after[assignment.sourceMemoryPath]).includes(assignment.sourceEntry)
+            : memoryContainsReviewContent(after[assignment.sourceMemoryPath], assignment.sourceEntry);
+        if (sourceStillPresent) {
             throw new VcmError({
                 code: "MEMORY_REVIEW_ASSIGNMENT_SOURCE_NOT_REMOVED",
                 message: `Move-to-durable-doc must remove memory before assignment: ${assignment.sourceEntry}`,
@@ -1451,11 +1471,47 @@ function memoryTargetToPath(target) {
     }
     return definition.path;
 }
-function substantiveMemoryEntries(content) {
+function collectExistingMemoryReviewEntries(memory) {
+    return MEMORY_FILE_DEFINITIONS.flatMap((definition) => {
+        const target = memoryPathToTarget(definition.path);
+        return parseExistingMemoryEntries(memory[definition.path]).map((entry, index) => ({
+            itemId: `existing:${target}:${index + 1}:${sha256(entry).slice(0, 12)}`,
+            target,
+            memoryPath: definition.path,
+            entry
+        }));
+    });
+}
+function parseExistingMemoryEntries(content) {
+    const normalized = content.replace(/\r\n?/g, "\n").trim();
+    if (!normalized) {
+        return [];
+    }
+    const lines = normalized.split("\n");
+    const sectionStarts = lines
+        .map((line, index) => (/^##(?:\s+|$)/.test(line) ? index : -1))
+        .filter((index) => index >= 0);
+    if (sectionStarts.length === 0) {
+        return [normalized];
+    }
+    return sectionStarts.map((start, index) => {
+        const end = sectionStarts[index + 1] ?? lines.length;
+        return lines.slice(start, end).join("\n").trim();
+    }).filter(Boolean);
+}
+function memoryContainsReviewContent(content, expected) {
+    const normalizedExpected = expected.replace(/\r\n?/g, "\n").trim();
+    if (!normalizedExpected) {
+        return false;
+    }
+    if (normalizedExpected.includes("\n") || /^##(?:\s+|$)/.test(normalizedExpected)) {
+        return parseExistingMemoryEntries(content).includes(normalizedExpected);
+    }
     return content
-        .split(/\r?\n/)
+        .replace(/\r\n?/g, "\n")
+        .split("\n")
         .map((line) => line.trim())
-        .filter(Boolean);
+        .includes(normalizedExpected);
 }
 function assertDurableDocPath(targetPath) {
     const normalized = normalizeProjectRelativePath(targetPath);
@@ -1570,6 +1626,27 @@ function memoryRunFilePath(runId, snapshot, memoryPath) {
 function memoryRunHostFilePath(runId, memoryPath) {
     return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/host-before/${memoryPath}`;
 }
+function describeMemoryHostDifference(before, current) {
+    if (before.beforeBlock !== current.beforeBlock) {
+        return describeTextDifference("before-block content", before.beforeBlock, current.beforeBlock);
+    }
+    if (before.afterBlock !== current.afterBlock) {
+        return describeTextDifference("after-block content", before.afterBlock, current.afterBlock);
+    }
+    return undefined;
+}
+function describeTextDifference(label, before, current) {
+    const limit = Math.min(before.length, current.length);
+    let offset = 0;
+    while (offset < limit && before[offset] === current[offset]) {
+        offset += 1;
+    }
+    const excerptStart = Math.max(0, offset - 20);
+    const excerptEnd = offset + 40;
+    const snapshotExcerpt = JSON.stringify(before.slice(excerptStart, excerptEnd));
+    const currentExcerpt = JSON.stringify(current.slice(excerptStart, excerptEnd));
+    return `${label} differs at character ${offset}; snapshot=${snapshotExcerpt}; current=${currentExcerpt}`;
+}
 function missingMemoryBlockError(filePath) {
     return new VcmError({
         code: "MEMORY_BLOCK_MISSING",

package/dist/backend/services/claude-hook-service.js

@@ -158,7 +158,8 @@ export function createClaudeHookService(deps) {
             ? await deps.harnessFeedbackService?.handleTaskRetrospectiveHook(context.project.repoRoot, {
                 taskSlug: activeTask.taskSlug,
                 eventName,
-                memoryReviewStatus: memoryState?.status ?? "idle"
+                memoryReviewStatus: memoryState?.status ?? "idle",
+                memoryReviewError: memoryState?.active?.error
             })
             : false;
         if (memoryHandled || retrospectiveHandled) {
@@ -1097,7 +1098,8 @@ function asksUserQuestion(message) {
         .split(/\r?\n/)
         .map((line) => line.trim())
         .filter(Boolean);
-    return lines.some((line) => /[?？]["')\]}】”’]*$/.test(line)
+    return lines.some((line) => /[?？]/.test(line)
         || /^(?:please\s+(?:answer|choose|confirm|decide|provide|select|tell)|(?:can|could|do|does|is|are|should|will|would)\s+you\b)/i.test(line)
-        || /^(?:请(?:回答|选择|确认|决定|提供|告知)|你(?:是否|能否|要不要|可否)|是否需要你|需要你(?:选择|确认|决定|提供|告知))/.test(line));
+        || /\b(?:please\s+(?:reply|respond|choose|confirm|decide|provide|select|tell|give)|i\s+need\s+your\s+(?:decision|choice|confirmation|answer)|let\s+me\s+know|your\s+(?:decision|choice|confirmation|answer)\s+is\s+required|waiting\s+for\s+your)\b/i.test(line)
+        || /(?:请(?:回答|回复|选择|确认|决定|提供|告知|给出|说明)|你(?:是否|能否|要不要|可否)|是否需要你|需要你(?:选择|确认|决定|提供|告知)|需要您的(?:选择|确认|决定|回复)|等待您的(?:选择|确认|决定|回复)|告诉我|告知我)/.test(line));
 }

package/dist/backend/services/gate-review-service.js

@@ -836,6 +836,9 @@ export function createGateReviewService(deps) {
         async skipReviewGate(repoRoot, taskSlug, gate, input) {
             const context = await getContext(repoRoot, taskSlug);
             assertExceptionReason(input.reason);
+            const exceptionInputHash = gate === "code-diff"
+                ? undefined
+                : await tryComputeInputHash(deps, context.taskRepoRoot, gate);
             const index = await withGateStateLock(context, async () => {
                 const timestamp = now();
                 const current = await loadIndex(deps.fs, context, timestamp);
@@ -850,6 +853,7 @@ export function createGateReviewService(deps) {
                 const next = applyGateState(current, gate, {
                     status: "skipped",
                     decision: undefined,
+                    inputHash: exceptionInputHash ?? current.gates[gate].inputHash,
                     exceptionReason: input.reason,
                     error: undefined,
                     completedAt: timestamp,
@@ -867,6 +871,9 @@ export function createGateReviewService(deps) {
         async overrideReviewGate(repoRoot, taskSlug, gate, input) {
             const context = await getContext(repoRoot, taskSlug);
             assertExceptionReason(input.reason);
+            const exceptionInputHash = gate === "code-diff"
+                ? undefined
+                : await tryComputeInputHash(deps, context.taskRepoRoot, gate);
             const index = await withGateStateLock(context, async () => {
                 const timestamp = now();
                 const current = await loadIndex(deps.fs, context, timestamp);
@@ -881,6 +888,7 @@ export function createGateReviewService(deps) {
                 const next = applyGateState(current, gate, {
                     status: "overridden",
                     decision: "approve",
+                    inputHash: exceptionInputHash ?? current.gates[gate].inputHash,
                     exceptionReason: input.reason,
                     error: undefined,
                     completedAt: timestamp,
@@ -1319,8 +1327,11 @@ async function readCodeDiffEvidenceError(fs, taskRepoRoot, source) {
 }
 async function readCodeDiffValidationGateError(deps, context, index) {
     const validationGate = index.gates["validation-adequacy"];
-    if (validationGate.required && validationGate.status !== "skipped" && validationGate.status !== "overridden") {
-        if (validationGate.status !== "completed" || validationGate.decision !== "approve") {
+    if (validationGate.required) {
+        const passed = (validationGate.status === "completed" && validationGate.decision === "approve")
+            || validationGate.status === "skipped"
+            || validationGate.status === "overridden";
+        if (!passed) {
             return "code-diff requires the validation-adequacy Gate to complete successfully for the current Tester evidence.";
         }
         const currentValidationHash = await computeInputHash(deps, context.taskRepoRoot, "validation-adequacy");
@@ -1330,6 +1341,14 @@ async function readCodeDiffValidationGateError(deps, context, index) {
     }
     return undefined;
 }
+async function tryComputeInputHash(deps, taskRepoRoot, gate) {
+    try {
+        return await computeInputHash(deps, taskRepoRoot, gate);
+    }
+    catch {
+        return undefined;
+    }
+}
 async function readArchitectureEvidenceError(fs, taskRepoRoot) {
     const relativePath = ".ai/vcm/handoffs/architecture-evidence.md";
     const absolutePath = resolveRepoPath(taskRepoRoot, relativePath);

package/dist/backend/services/harness-feedback-service.js

@@ -11,15 +11,18 @@ const TASK_RETROSPECTIVE_DIR = `${FEEDBACK_ROOT}/task-retrospectives`;
 const LEGACY_STATE_PATH = `${FEEDBACK_ROOT}/state.json`;
 export function createHarnessFeedbackService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
-    async function getState(repoRoot, _activeTaskSlug) {
+    async function getState(repoRoot, activeTaskSlug) {
         await cleanupLegacyState(repoRoot);
         const pending = await listPendingFeedback(repoRoot);
+        const marker = activeTaskSlug
+            ? await loadTaskRetrospectiveMarker(repoRoot, activeTaskSlug)
+            : undefined;
         return {
             version: 1,
             status: pending.length > 0 ? "queued" : "idle",
             queuedCount: pending.length,
             pending,
-            warnings: []
+            warnings: marker?.status === "failed" && marker.error ? [marker.error] : []
         };
     }
     async function sendPendingFeedback(repoRoot, input) {
@@ -143,27 +146,41 @@ export function createHarnessFeedbackService(deps) {
             ]
             : ["Report is empty."];
         const reportReady = reportErrors.length === 0;
-        if (!reportReady || (marker.memoryRunId && input.memoryReviewStatus === "failed")) {
+        if (!reportReady) {
             await persistTaskRetrospectiveMarker(repoRoot, {
                 ...marker,
                 status: "failed",
                 failedAt: timestamp,
                 updatedAt: timestamp,
-                error: !reportReady
-                    ? `Harness Engineer did not write a valid Task Harness Retrospective report: ${reportErrors.join(" ")}`
-                    : "Task Harness Retrospective memory review failed."
+                error: `Harness Engineer did not write a valid Task Harness Retrospective report: ${reportErrors.join(" ")}`
             });
             return true;
         }
-        if (marker.memoryRunId && input.memoryReviewStatus === "documenting") {
+        const processedMarker = await consumeAcceptedFeedback(repoRoot, marker);
+        if (!processedMarker) {
+            return true;
+        }
+        if (processedMarker.memoryRunId && input.memoryReviewStatus === "failed") {
             await persistTaskRetrospectiveMarker(repoRoot, {
-                ...marker,
+                ...processedMarker,
+                status: "failed",
+                failedAt: timestamp,
+                updatedAt: timestamp,
+                error: input.memoryReviewError
+                    ? `Task Harness Retrospective memory review failed: ${input.memoryReviewError}`
+                    : "Task Harness Retrospective memory review failed. Open Harness Studio Memory to inspect the validation error."
+            });
+            return true;
+        }
+        if (processedMarker.memoryRunId && input.memoryReviewStatus === "documenting") {
+            await persistTaskRetrospectiveMarker(repoRoot, {
+                ...processedMarker,
                 status: "waiting-docs",
                 updatedAt: timestamp
             });
             return true;
         }
-        await completeTaskRetrospective(repoRoot, marker);
+        await completeTaskRetrospective(repoRoot, processedMarker);
         return true;
     }
     async function completeWaitingTaskRetrospective(repoRoot, taskSlug, memoryStatus) {
@@ -189,6 +206,22 @@ export function createHarnessFeedbackService(deps) {
         return true;
     }
     async function completeTaskRetrospective(repoRoot, marker) {
+        const timestamp = now();
+        const processedMarker = await consumeAcceptedFeedback(repoRoot, marker);
+        if (!processedMarker) {
+            return;
+        }
+        await persistTaskRetrospectiveMarker(repoRoot, {
+            ...processedMarker,
+            status: "completed",
+            completedAt: timestamp,
+            updatedAt: timestamp
+        });
+    }
+    async function consumeAcceptedFeedback(repoRoot, marker) {
+        if (marker.feedbackProcessedAt) {
+            return marker;
+        }
         const timestamp = now();
         try {
             await removeProcessedFeedback(repoRoot, marker.pendingFeedbackPaths ?? []);
@@ -201,14 +234,16 @@ export function createHarnessFeedbackService(deps) {
                 updatedAt: timestamp,
                 error: `VCM could not remove processed Harness Feedback: ${errorMessage(error)}`
             });
-            return;
+            return undefined;
         }
-        await persistTaskRetrospectiveMarker(repoRoot, {
+        const processedMarker = {
             ...marker,
-            status: "completed",
-            completedAt: timestamp,
+            pendingFeedbackPaths: [],
+            feedbackProcessedAt: timestamp,
             updatedAt: timestamp
-        });
+        };
+        await persistTaskRetrospectiveMarker(repoRoot, processedMarker);
+        return processedMarker;
     }
     async function assertHarnessEngineerAvailable(_repoRoot) {
         return undefined;
@@ -320,6 +355,7 @@ export function createHarnessFeedbackService(deps) {
                     "Auto Memory Review:",
                     `Role drafts: ${memoryReview.roleDraftsPath}`,
                     `Current memory snapshot: ${memoryReview.currentMemoryPath}`,
+                    `Existing memory entries: ${memoryReview.existingEntriesPath}`,
                     "Active memory files:",
                     ...memoryReview.activeMemoryPaths.map((memoryPath) => `- ${memoryPath}`),
                     "Proposal candidates:",
@@ -338,7 +374,9 @@ export function createHarnessFeedbackService(deps) {
                     "",
                     "Review every memory candidate against final task evidence while performing this retrospective.",
                     "The snapshot files contain only the matching pre-review <VCM-memory> block content.",
-                    "Before evaluating proposals, review every substantive entry in every current memory snapshot against current code, documentation, and final task evidence.",
+                    "The existing memory entries file is the complete required decision set. It groups each ## section and its body as one semantic entry; legacy memory without ## sections is one entry.",
+                    "Emit exactly one source=existing decision for every listed itemId. Copy its target and entry exactly; do not create decisions for headings, wrapped lines, or other text not listed there.",
+                    "Review every listed existing entry against current code, documentation, and final task evidence before evaluating proposals.",
                     "Evaluate each proposal independently. Keep only verified, durable, reusable project knowledge; do not keep task narrative, temporary state, unverified conclusions, or Harness rules in memory.",
                     "For every existing entry and proposal, record why the decision is necessary, the impact if the knowledge is absent, the evidence checked, and whether a durable document is the correct source.",
                     "When the decision is move-to-durable-doc, remove the entry from memory now and add one durableDocAssignment. Do not wait for the durable document update before removing memory.",

package/dist/backend/services/message-service.js

@@ -211,6 +211,7 @@ export function createMessageService(deps) {
                 const messages = await readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
                 let clearedCount = 0;
                 if (input.clearRouteFiles) {
+                    await deps.workflowControlService?.cancelPendingDispatch(toWorkflowContext(input));
                     for (const routeFile of await listPendingRouteFiles(input)) {
                         await deps.fs.writeText(resolveRepoPath(input.taskRepoRoot ?? input.repoRoot, routeFile.path), "");
                         clearedCount += 1;
@@ -225,6 +226,15 @@ export function createMessageService(deps) {
         },
         async deleteMessageHistory(input) {
             return withTaskLock(taskLocks, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), async () => {
+                const workflowState = await deps.workflowControlService?.getState(toWorkflowContext(input));
+                if (workflowState?.pendingDispatch?.status === "dispatching") {
+                    throw new VcmError({
+                        code: "MESSAGE_HISTORY_DISPATCHING",
+                        message: "Message history cannot be deleted while a PM workflow dispatch is awaiting target confirmation.",
+                        statusCode: 409,
+                        hint: "Wait for confirmation or use Mark All Done to cancel the pending route first."
+                    });
+                }
                 const messagesPath = getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug);
                 const messages = await readLatestMessages(deps.fs, messagesPath);
                 await writeMessageSnapshots(deps.fs, messagesPath, []);

package/dist/backend/services/runtime-recovery-service.js

@@ -33,6 +33,15 @@ export function createRuntimeRecoveryService(deps) {
                     await recoverTaskSessions(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
                     const roundRecovered = await recoverRound(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
                     await recoverMessages(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
+                    const workflowRecovered = await deps.workflowControlService?.recoverTask({
+                        taskRepoRoot,
+                        stateRoot: config.stateRoot,
+                        handoffDir: task.handoffDir,
+                        taskSlug: task.taskSlug
+                    });
+                    if (workflowRecovered) {
+                        context.changedPaths.add(path.join(config.stateRoot, "workflow-control.json"));
+                    }
                     await recoverGateReview(taskRepoRoot, recoveredAt, context);
                     await recoverCoderWorkers(taskRepoRoot, task.taskSlug, context);
                     await deps.architectRestartService?.recoverTask(repoRoot, task.taskSlug);