vibe-coding-master 0.7.49 → 0.8.0

package/README.md

@@ -124,8 +124,9 @@ If you want VCM app state to survive container rebuilds, set:
 1. Start VCM with `vcm`.
 2. Open the GUI.
 3. In `Repository`, enter a local Git repository path and click `Connect`.
-4. Create or select a task in the `Task` section. VCM creates a task branch and
-   worktree immediately.
+4. Create or select a task in the `Task` section. Before creating a new task,
+   VCM fast-forward pulls the connected branch when it has an upstream, then
+   creates the task branch and worktree from the updated `HEAD`.
 5. In `VCM Harness`, initialize or update fixed harness files if VCM reports
    pending changes. Harness changes are written to the active task worktree.
 6. If bootstrap is incomplete, open Harness Studio and run bootstrap through
@@ -632,6 +633,7 @@ Make sure:
 
 - the repository is a Git repository
 - the connected base repo is clean
+- the connected branch can be fast-forward pulled when it has an upstream
 - no other task is currently active for this project
 - the derived `feature/<task>` branch does not already exist
 - the derived `.claude/worktrees/<task>` directory does not already exist

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

@@ -302,6 +302,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 +310,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
@@ -966,31 +974,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 +1014,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 +1033,7 @@ export function createAutoMemoryService(deps) {
                     statusCode: 409
                 });
             }
+            validateDurableDocAssignmentInput(assignment, matchingDecision.source, after);
         }
         return result;
     }
@@ -1034,7 +1046,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 +1055,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 +1079,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 +1088,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 +1113,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 +1121,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 +1466,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);

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,8 +33,17 @@ 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 cleanupCoderWorkers(taskRepoRoot, context);
+                    await recoverCoderWorkers(taskRepoRoot, task.taskSlug, context);
                     await deps.architectRestartService?.recoverTask(repoRoot, task.taskSlug);
                     await deps.roleContextRestartService?.recoverTask(repoRoot, task.taskSlug);
                     if ((roundRecovered || task.status === "running") && !hasLiveTaskSession(task.taskSlug)) {
@@ -238,16 +247,32 @@ export function createRuntimeRecoveryService(deps) {
         });
         context.changedPaths.add(relativePath);
     }
-    async function cleanupCoderWorkers(taskRepoRoot, context) {
-        const absolutePath = path.join(taskRepoRoot, CODER_WORKERS_RUNTIME_DIR);
-        if (!(await deps.fs.pathExists(absolutePath))) {
+    async function recoverCoderWorkers(taskRepoRoot, taskSlug, context) {
+        if (hasLiveRoundRole(taskSlug, "coder") || !deps.fs.removePath) {
             return;
         }
-        if (!deps.fs.removePath) {
+        const tasksPath = path.join(taskRepoRoot, CODER_WORKERS_RUNTIME_DIR, "tasks");
+        if (!(await deps.fs.pathExists(tasksPath))) {
             return;
         }
-        await deps.fs.removePath(absolutePath, { recursive: true, force: true });
-        context.changedPaths.add(CODER_WORKERS_RUNTIME_DIR);
+        for (const entry of await deps.fs.readDir(tasksPath)) {
+            if (!entry.endsWith(".json")) {
+                continue;
+            }
+            const absolutePath = path.join(tasksPath, entry);
+            let state;
+            try {
+                state = await deps.fs.readJson(absolutePath);
+            }
+            catch {
+                continue;
+            }
+            if (state.status !== "running" || state.handled === true) {
+                continue;
+            }
+            await deps.fs.removePath(absolutePath, { force: true });
+            context.changedPaths.add(path.posix.join(CODER_WORKERS_RUNTIME_DIR, "tasks", entry));
+        }
     }
     async function recoverHarnessBootstrap(repoRoot, _timestamp, context) {
         const absolutePath = path.join(repoRoot, BOOTSTRAP_SESSION_PATH);

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

@@ -53,6 +53,19 @@ export function createTaskService(deps) {
                     hint: `Commit, stash, or discard these changes before creating a task worktree: ${baseVisibleChanges.slice(0, 12).join(", ")}`
                 });
             }
+            const upstreamBranch = await deps.git.getUpstreamBranch(repoRoot);
+            if (upstreamBranch) {
+                await deps.git.pullFastForward(repoRoot);
+                const postPullVisibleChanges = await getBaseRepoVisibleChanges(deps.git, repoRoot);
+                if (postPullVisibleChanges.length > 0) {
+                    throw new VcmError({
+                        code: "BASE_REPO_DIRTY",
+                        message: "The connected repository has Git-visible changes after pulling its upstream branch.",
+                        statusCode: 409,
+                        hint: `Commit, stash, or discard these changes before creating a task worktree: ${postPullVisibleChanges.slice(0, 12).join(", ")}`
+                    });
+                }
+            }
             const timestamp = now();
             await deps.fs.ensureDir(path.dirname(worktreePath));
             await deps.git.createWorktree({