vibe-coding-master 0.9.3 → 0.9.5

package/dist/backend/server.js

@@ -320,7 +320,8 @@ export function createDefaultServerDeps(options = {}) {
         fs,
         projectService,
         taskService,
-        sessionService
+        sessionService,
+        workflowControlService
     });
     const messageService = createMessageService({
         fs,

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

@@ -8,6 +8,7 @@ import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { readVcmMemoryHostFrame, readVcmMemoryBlock, replaceVcmMemoryBlock } from "../templates/harness/memory-block.js";
 import { ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH, architectPlanningCandidateSnapshotPath, durableDocAssignmentReportPath, memoryReviewRoleDraftPath, MEMORY_REVIEW_RUNS_ROOT, MEMORY_REVIEW_STATE_PATH } from "./memory-review-paths.js";
 import { parseMemoryProposal, validateMemoryProposal } from "./memory-proposal-validation.js";
+const MEMORY_REVIEW_STOP_BLOCK_LIMIT = 3;
 const MEMORY_FILE_DEFINITIONS = [
     { path: "CLAUDE.md", title: "Shared Memory" },
     { path: ".claude/agents/project-manager.md", title: "Project Manager Memory", role: "project-manager" },
@@ -436,43 +437,75 @@ export function createAutoMemoryService(deps) {
         if (!(await deps.appSettings.getPreferences()).autoMemoryEnabled && !preserveDisabledReview(state)) {
             if (state) {
                 await discardActiveReview(input.taskRepoRoot, state);
-                return true;
+                return { handled: true };
             }
-            return false;
+            return { handled: false };
         }
         if (state?.status === "reviewing" && !state.reviewPromptDispatchedAt) {
-            return false;
+            return { handled: false };
         }
         if (!state || state.status !== "reviewing") {
-            return false;
+            return { handled: false };
         }
         if (input.eventName === "UserPromptSubmit" || input.eventName === "PostCompact") {
-            return true;
+            return { handled: true };
         }
         if (input.eventName === "StopFailure") {
             await failReview(input.taskRepoRoot, state, "Task Harness Retrospective memory review turn failed.");
-            return true;
+            return { handled: true };
         }
         if (input.eventName === "Stop") {
             if (!state.retrospectiveReportPath
                 || !(await deps.fs.pathExists(state.retrospectiveReportPath))
                 || !(await deps.fs.readText(state.retrospectiveReportPath)).trim()) {
-                await failReview(input.taskRepoRoot, state, "Task Harness Retrospective did not write the required retrospective report.");
-                return true;
+                return rejectHarnessEngineerStop(input, state, "Task Harness Retrospective did not write the required retrospective report.");
             }
             try {
                 await recordHarnessEngineerMemoryResult(input.taskRepoRoot, state);
-                if (state.assignments.length > 0) {
-                    await dispatchCurrentDurableDocAssignment(input.baseRepoRoot, input.taskRepoRoot, state);
-                }
             }
             catch (error) {
-                await failReview(input.taskRepoRoot, state, `Harness Engineer memory result could not be recorded: ${errorMessage(error)}`);
-                return true;
+                const message = `Harness Engineer memory result could not be recorded: ${errorMessage(error)}`;
+                if (!isFixableMemoryResultError(error)) {
+                    await failReview(input.taskRepoRoot, state, message);
+                    return { handled: true };
+                }
+                const hint = error instanceof VcmError && error.hint ? ` ${error.hint}` : "";
+                return rejectHarnessEngineerStop(input, state, `${message}${hint}`);
             }
-            return true;
+            if (state.assignments.length > 0) {
+                try {
+                    await dispatchCurrentDurableDocAssignment(input.baseRepoRoot, input.taskRepoRoot, state);
+                }
+                catch (error) {
+                    await failReview(input.taskRepoRoot, state, `Durable-document assignment could not be dispatched: ${errorMessage(error)}`);
+                }
+            }
+            return { handled: true };
         }
-        return true;
+        return { handled: true };
+    }
+    // A correctable retrospective result keeps the Harness Engineer turn alive
+    // with the validation error, a bounded number of times, so the role can fix
+    // review-result.json or the memory commit instead of the review failing
+    // silently after the turn has ended.
+    async function rejectHarnessEngineerStop(input, state, message) {
+        const blocks = state.stopBlockCount ?? 0;
+        if (!input.allowStopBlock || blocks >= MEMORY_REVIEW_STOP_BLOCK_LIMIT) {
+            await failReview(input.taskRepoRoot, state, message);
+            return { handled: true };
+        }
+        state.stopBlockCount = blocks + 1;
+        state.error = message;
+        state.updatedAt = now();
+        await persistActiveState(input.taskRepoRoot, state);
+        return {
+            handled: true,
+            stopBlockReason: [
+                message,
+                `Fix the retrospective report, ${resolveRepoPath(input.taskRepoRoot, reviewResultRelativePath(state.runId))}, or the memory commit, then end the turn again.`,
+                `Attempt ${state.stopBlockCount} of ${MEMORY_REVIEW_STOP_BLOCK_LIMIT}; after that the memory review fails.`
+            ].join(" ")
+        };
     }
     async function getFile(_baseRepoRoot, taskRepoRoot, filePath) {
         await assertMemoryBlocksInstalled(deps.fs, taskRepoRoot);
@@ -549,9 +582,47 @@ export function createAutoMemoryService(deps) {
                 statusCode: 409
             });
         }
+        if (await harnessEngineerResultWritten(taskRepoRoot, state)) {
+            // The Harness Engineer finished its turn, so re-validate the current
+            // result file and memory commit before discarding anything.
+            try {
+                await recordHarnessEngineerMemoryResult(taskRepoRoot, state);
+            }
+            catch (error) {
+                if (await memoryChangedSinceReview(taskRepoRoot, state)) {
+                    // Reviewed memory is already committed; restarting would lose the
+                    // durable-document moves recorded only in this run's result file.
+                    const message = `Harness Engineer memory result could not be recorded: ${errorMessage(error)}`;
+                    await failReview(taskRepoRoot, state, message);
+                    throw new VcmError({
+                        code: "MEMORY_REVIEW_RESULT_STILL_INVALID",
+                        message,
+                        statusCode: 409,
+                        hint: `Correct ${resolveRepoPath(taskRepoRoot, reviewResultRelativePath(state.runId))} or the memory commit, then retry.`
+                    });
+                }
+                await clearActiveState(taskRepoRoot);
+                return getState(baseRepoRoot, taskRepoRoot);
+            }
+            if (state.assignments.length > 0) {
+                await dispatchCurrentDurableDocAssignment(baseRepoRoot, taskRepoRoot, state);
+            }
+            return getState(baseRepoRoot, taskRepoRoot);
+        }
         await clearActiveState(taskRepoRoot);
         return getState(baseRepoRoot, taskRepoRoot);
     }
+    async function harnessEngineerResultWritten(taskRepoRoot, state) {
+        if (!state.reviewBaseCommit || !state.reviewPromptDispatchedAt) {
+            return false;
+        }
+        return deps.fs.pathExists(resolveRepoPath(taskRepoRoot, reviewResultRelativePath(state.runId)));
+    }
+    async function memoryChangedSinceReview(taskRepoRoot, state) {
+        const before = await readRunMemorySet(taskRepoRoot, state.runId, "before");
+        const after = await readMemorySet(taskRepoRoot);
+        return MEMORY_FILE_DEFINITIONS.some((definition) => before[definition.path] !== after[definition.path]);
+    }
     async function retryDurableDocAssignment(baseRepoRoot, taskRepoRoot, assignmentId) {
         const state = await loadActiveState(taskRepoRoot);
         const assignment = state && (state.status === "documenting" || state.status === "failed")
@@ -996,7 +1067,7 @@ export function createAutoMemoryService(deps) {
         await persistActiveState(taskRepoRoot, state);
     }
     async function readAndValidateHarnessMemoryReviewResult(taskRepoRoot, state, before, after, currentHead, changedMemoryPaths) {
-        const resultPath = resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${state.runId}/review-result.json`);
+        const resultPath = resolveRepoPath(taskRepoRoot, reviewResultRelativePath(state.runId));
         if (!(await deps.fs.pathExists(resultPath))) {
             throw new VcmError({
                 code: "MEMORY_REVIEW_RESULT_MISSING",
@@ -1791,6 +1862,20 @@ function ensureTrailingNewline(content) {
 function sha256(content) {
     return createHash("sha256").update(content).digest("hex");
 }
+function reviewResultRelativePath(runId) {
+    return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/review-result.json`;
+}
+// Errors the Harness Engineer can correct in its own output: the result file,
+// the memory edit, or the memory commit. A malformed result file surfaces as a
+// JSON SyntaxError.
+function isFixableMemoryResultError(error) {
+    if (error instanceof SyntaxError) {
+        return true;
+    }
+    return error instanceof VcmError
+        && error.code.startsWith("MEMORY_")
+        && error.code !== "MEMORY_REVIEW_BASE_MISSING";
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

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

@@ -114,29 +114,30 @@ export function createClaudeHookService(deps) {
             dispatchedCount: 0
         };
     }
-    async function processHarnessEngineerHook(input) {
+    async function processHarnessEngineerHook(input, options) {
         const eventName = parseBusinessHookEvent(input.event.hook_event_name);
         const context = await getProjectToolHookContext("Harness Engineer");
         const projectScoped = input.taskSlug === "__project_harness_engineer__";
-        const session = projectScoped
-            ? await deps.sessionService.recordProjectHarnessEngineerHookEvent(context.project.repoRoot, {
-                eventName,
+        const recordSessionEvent = (recordedEventName) => projectScoped
+            ? deps.sessionService.recordProjectHarnessEngineerHookEvent(context.project.repoRoot, {
+                eventName: recordedEventName,
                 sessionId: stringOrUndefined(input.event.session_id),
                 transcriptPath: stringOrUndefined(input.event.transcript_path),
                 cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
                 runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
                 runtimeSessionToken: input.runtimeSessionToken
             })
-            : await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
+            : deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
                 taskSlug: input.taskSlug,
                 role: input.role,
-                eventName,
+                eventName: recordedEventName,
                 sessionId: stringOrUndefined(input.event.session_id),
                 transcriptPath: stringOrUndefined(input.event.transcript_path),
                 cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
                 runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
                 runtimeSessionToken: input.runtimeSessionToken
             });
+        const session = await recordSessionEvent(eventName);
         if (!session) {
             return completedHookResult(input, eventName);
         }
@@ -144,14 +145,32 @@ export function createClaudeHookService(deps) {
             ? (await deps.taskService.listTasks(context.project.repoRoot))
                 .find((task) => task.cleanupStatus !== "cleaned" && (projectScoped || task.taskSlug === input.taskSlug))
             : undefined;
-        const memoryHandled = activeTask
+        const memoryResult = activeTask
             ? await deps.autoMemoryService?.handleHarnessEngineerHook({
                 baseRepoRoot: context.project.repoRoot,
                 taskRepoRoot: getTaskRuntimeRepoRoot(activeTask),
                 taskSlug: activeTask.taskSlug,
-                eventName
+                eventName,
+                allowStopBlock: options.allowBlock && eventName === "Stop"
             })
-            : false;
+            : undefined;
+        if (memoryResult?.stopBlockReason) {
+            // The memory review result is still correctable: keep the Harness
+            // Engineer turn alive and skip retrospective completion until it passes.
+            // The turn continues, so the session must not stay recorded as idle and
+            // receive queued input meanwhile.
+            await recordSessionEvent("UserPromptSubmit");
+            return {
+                ok: true,
+                eventName,
+                taskSlug: activeTask?.taskSlug ?? input.taskSlug,
+                role: input.role,
+                sessionUpdated: Boolean(session),
+                dispatchedCount: 0,
+                stopDecision: { behavior: "block", reason: memoryResult.stopBlockReason }
+            };
+        }
+        const memoryHandled = memoryResult?.handled ?? false;
         const memoryState = activeTask && deps.autoMemoryService
             ? await deps.autoMemoryService.getState(context.project.repoRoot, getTaskRuntimeRepoRoot(activeTask))
             : undefined;
@@ -631,7 +650,7 @@ export function createClaudeHookService(deps) {
         });
         if (eventName === "Stop") {
             const memoryState = await deps.autoMemoryService.getState(context.project.repoRoot, context.taskRepoRoot);
-            await deps.harnessFeedbackService?.completeWaitingTaskRetrospective(context.project.repoRoot, context.taskSlug, memoryState.status);
+            await deps.harnessFeedbackService?.completeWaitingTaskRetrospective(context.project.repoRoot, context.taskSlug, memoryState);
         }
         return {
             ok: true,
@@ -908,7 +927,7 @@ export function createClaudeHookService(deps) {
                     return processTranslatorHook(input);
                 }
                 if (isHarnessEngineerToolRoleName(input.role)) {
-                    return processHarnessEngineerHook(input);
+                    return processHarnessEngineerHook(input, { allowBlock: false });
                 }
                 if (eventName === "UserPromptSubmit") {
                     return handleUserPromptSubmitHook(input);
@@ -930,7 +949,7 @@ export function createClaudeHookService(deps) {
                     return processTranslatorHook(input);
                 }
                 if (isHarnessEngineerToolRoleName(input.role)) {
-                    return processHarnessEngineerHook(input);
+                    return processHarnessEngineerHook(input, { allowBlock: true });
                 }
                 return processStopHook(input, { allowBlock: true });
             });

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

@@ -7,6 +7,7 @@ import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 import { parseGateReviewReportArtifact } from "./managed-artifact-validation.js";
+import { collectFlowRouteMessages, renderRouteMessages } from "./route-message-evidence.js";
 const REVIEWER_AGENT_PATH = ".claude/agents/reviewer.md";
 const GATE_REVIEW_DIR = ".ai/vcm/gate-reviews";
 const REQUESTS_DIR = ".ai/vcm/gate-reviews/requests";
@@ -39,10 +40,7 @@ const CODE_DIFF_SOURCE_ARTIFACTS = {
         ".ai/vcm/handoffs/architecture-plan.md",
         ".ai/vcm/handoffs/coder-completion.md"
     ],
-    "architect-debug": [
-        ".ai/vcm/handoffs/role-commands/architect.md",
-        ".ai/vcm/handoffs/architect-debug.md"
-    ],
+    "architect-debug": [".ai/vcm/handoffs/architect-debug.md"],
     "architect-diagnosis": [
         ".ai/vcm/handoffs/architecture-diagnosis.md"
     ]
@@ -438,6 +436,9 @@ export function createGateReviewService(deps) {
         const promptPath = path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
         const requestReportPath = reportPathForRequest(requestId);
         const inputSnapshots = await captureGateInputSnapshots(deps.fs, context.taskRepoRoot, requestId, getSourceArtifacts(gate, codeDiffSources));
+        if (gate === "code-diff" && codeDiffSources) {
+            inputSnapshots.push(await captureRouteMessageSnapshot(deps, context, requestId, codeDiffSources));
+        }
         const nextRecord = {
             ...record,
             status: "running",
@@ -1487,7 +1488,12 @@ function splitLines(value) {
 function buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources, inputSnapshots = []) {
     const reportPath = reportPathForRequest(requestId);
     const absoluteReportPath = resolveRepoPath(context.taskRepoRoot, reportPath);
-    const evidence = getSourceArtifacts(gate, codeDiffSources)
+    const evidence = [
+        ...getSourceArtifacts(gate, codeDiffSources),
+        ...(gate === "code-diff"
+            ? [`${path.posix.join(context.stateRoot, "messages", `${context.taskSlug}.jsonl`)} (PM route messages for the reviewed flow)`]
+            : [])
+    ]
         .map((relativePath) => `- ${relativePath}`)
         .join("\n");
     const capturedEvidence = inputSnapshots.length > 0
@@ -1561,6 +1567,19 @@ async function captureGateInputSnapshots(fs, taskRepoRoot, requestId, sourcePath
     }
     return snapshots;
 }
+// The reviewer judges authorization and scope against the flow's PM route
+// messages, captured like any other immutable Gate input.
+async function captureRouteMessageSnapshot(deps, context, requestId, codeDiffSources) {
+    const sourcePath = path.posix.join(context.stateRoot, "messages", `${context.taskSlug}.jsonl`);
+    const roles = new Set(codeDiffSources.map((source) => source === "coder" ? "coder" : "architect"));
+    const flow = await collectFlowRouteMessages(deps.fs, deps.workflowControlService, context, roles);
+    if (flow.messages.length === 0) {
+        return { sourcePath, status: "missing" };
+    }
+    const snapshotPath = inputSnapshotPathForRequest(requestId, ".ai/vcm/messages/route-messages.md");
+    await deps.fs.writeText(resolveRepoPath(context.taskRepoRoot, snapshotPath), renderRouteMessages(context.taskSlug, [`Code sources: ${codeDiffSources.join(" -> ")}`], flow));
+    return { sourcePath, snapshotPath, status: "captured" };
+}
 function isTaskEvidencePath(sourcePath) {
     return sourcePath.startsWith(".ai/vcm/handoffs/")
         || sourcePath.startsWith(".ai/vcm/gate-reviews/");

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

@@ -175,6 +175,7 @@ export function createHarnessFeedbackService(deps) {
                 ...processedMarker,
                 status: "failed",
                 durableDocFailure: input.memoryReviewHasAssignments,
+                memoryReviewFailure: true,
                 failedAt: timestamp,
                 updatedAt: timestamp,
                 error: input.memoryReviewError
@@ -194,15 +195,28 @@ export function createHarnessFeedbackService(deps) {
         await completeTaskRetrospective(repoRoot, processedMarker);
         return true;
     }
-    async function completeWaitingTaskRetrospective(repoRoot, taskSlug, memoryStatus) {
+    async function completeWaitingTaskRetrospective(repoRoot, taskSlug, memory) {
         const marker = await loadTaskRetrospectiveMarker(repoRoot, taskSlug);
-        if (!marker || (marker.status !== "waiting-docs" && !(marker.status === "failed" && marker.durableDocFailure))) {
+        // A memory review that failed validation recovers only when a retry
+        // re-validated and applied that same run; a discarded run never does.
+        const memoryReviewRecovered = Boolean(marker?.memoryReviewFailure
+            && marker.memoryRunId
+            && memory.runs.some((run) => run.runId === marker.memoryRunId && run.status === "applied"));
+        if (!marker
+            || (marker.status !== "waiting-docs"
+                && !(marker.status === "failed" && (marker.durableDocFailure || memoryReviewRecovered)))) {
             return false;
         }
+        const memoryStatus = memory.status;
         if (memoryStatus === "documenting") {
             if (marker.status === "failed") {
                 await persistTaskRetrospectiveMarker(repoRoot, {
-                    ...marker, status: "waiting-docs", updatedAt: now(), error: undefined, failedAt: undefined
+                    ...marker,
+                    status: "waiting-docs",
+                    memoryReviewFailure: undefined,
+                    updatedAt: now(),
+                    error: undefined,
+                    failedAt: undefined
                 });
             }
             return true;
@@ -235,6 +249,7 @@ export function createHarnessFeedbackService(deps) {
             ...processedMarker,
             status: "completed",
             durableDocFailure: undefined,
+            memoryReviewFailure: undefined,
             error: undefined,
             failedAt: undefined,
             completedAt: timestamp,
@@ -408,8 +423,11 @@ export function createHarnessFeedbackService(deps) {
                     `Write the complete machine-readable review to: ${memoryReview.reviewResultPath}`,
                     "The JSON root must be: {\"version\":1,\"runId\":\"<assigned run id>\",\"memoryCommit\":\"<full commit or none>\",\"decisions\":[],\"durableDocAssignments\":[]}.",
                     "Each decision must contain itemId, source (existing|proposal), target, entry, decision, reason, impactIfAbsent, evidence (non-empty array), finalContent, and durableDocPath.",
+                    "Every decision field is a non-empty string except evidence. Use \"none\" for finalContent when the decision keeps no memory text (remove, reject, move-to-durable-doc), and for durableDocPath unless the decision is move-to-durable-doc, where it must equal the assignment targetPath.",
+                    "For retain, update, keep-in-memory, and keep-memory-reference, finalContent must be the exact memory text now present in the <VCM-memory> block; an update's finalContent must be one complete semantic entry as it now appears.",
                     "Existing decisions use retain|update|remove|move-to-durable-doc. Add or Update proposal decisions use keep-in-memory|keep-memory-reference|move-to-durable-doc|reject; Remove proposal decisions use remove|retain. Proposal itemId must equal the assigned candidate ID.",
                     "Each durableDocAssignment must contain sourceMemoryPath, sourceEntry, targetPath, content, reason, and evidence (non-empty array). Use a project-relative Markdown target outside .ai/vcm.",
+                    "VCM validates review-result.json and the memory commit when you end the turn. If validation fails, the Stop is rejected with the error; correct the result file or the memory commit and end the turn again.",
                     "In the retrospective report, include only this memory summary:",
                     "",
                     "## Memory Review",

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

@@ -527,6 +527,11 @@ function arraysEqual(left, right) {
     }
     return left.every((value, index) => value === right[index]);
 }
+// Reads the task's message log outside the service's task lock, for consumers
+// that only need a point-in-time view, such as Gate Review evidence capture.
+export function readTaskMessages(fs, input) {
+    return readLatestMessages(fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
+}
 async function readLatestMessages(fs, messagesPath) {
     if (!(await fs.pathExists(messagesPath))) {
         return [];

package/dist/backend/services/role-context-restart-service.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { toVcmError, VcmError } from "../errors.js";
+import { collectFlowRouteMessages, renderRouteMessages } from "./route-message-evidence.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const STATE_DIR = "restart-with-context";
 export function createRoleContextRestartService(deps) {
@@ -126,7 +127,11 @@ export function createRoleContextRestartService(deps) {
         ]);
         const handoffDir = task.handoffDir;
         const stateRoot = config.stateRoot;
-        const files = roleContextFiles(role, handoffDir, stateRoot);
+        const routeMessagesPath = await writeRouteMessages(repoRoot, task, stateRoot, role);
+        const files = [
+            ...(routeMessagesPath ? [routeMessagesPath] : []),
+            ...roleContextFiles(role, handoffDir, stateRoot)
+        ];
         return {
             system: [
                 `This fresh ${role} session continues the current VCM task after Restart With Context.`,
@@ -140,6 +145,28 @@ export function createRoleContextRestartService(deps) {
             user: `[VCM RESTART WITH CONTEXT]\nRestore the current ${role} work from the listed task artifacts and continue the accepted assignment.`
         };
     }
+    // A delivery role's assignment lives only in the PM route messages, so render
+    // the current flow run's messages to that role for the fresh session.
+    async function writeRouteMessages(repoRoot, task, stateRoot, role) {
+        if (role !== "architect" && role !== "coder" && role !== "tester") {
+            return undefined;
+        }
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const context = {
+            repoRoot,
+            taskRepoRoot,
+            stateRoot,
+            handoffDir: task.handoffDir,
+            taskSlug: task.taskSlug
+        };
+        const flow = await collectFlowRouteMessages(deps.fs, deps.workflowControlService, context, new Set([role]));
+        if (flow.messages.length === 0) {
+            return undefined;
+        }
+        const relativePath = path.posix.join(stateRoot, STATE_DIR, `${role}-route-messages.md`);
+        await deps.fs.writeText(resolveRepoPath(taskRepoRoot, relativePath), renderRouteMessages(task.taskSlug, [`Role: ${role}`], flow));
+        return relativePath;
+    }
     async function persist(repoRoot, state) {
         await deps.fs.writeJsonAtomic(await statePath(repoRoot, state.taskSlug, state.role), state);
         pending.set(restartKey(repoRoot, state.taskSlug, state.role), state);
@@ -205,7 +232,6 @@ function roleContextFiles(role, handoffDir, stateRoot) {
             ];
         case "architect":
             return [
-                `${handoffDir}/role-commands/architect.md`,
                 `${handoffDir}/architecture-brief.md`,
                 `${handoffDir}/architecture-evidence.md`,
                 `${handoffDir}/planning-progress.md`,
@@ -216,14 +242,12 @@ function roleContextFiles(role, handoffDir, stateRoot) {
             ];
         case "coder":
             return [
-                `${handoffDir}/role-commands/coder.md`,
                 `${handoffDir}/architecture-plan.md`,
                 `${handoffDir}/coder-completion.md`,
                 ".ai/vcm/coder-workers/"
             ];
         case "tester":
             return [
-                `${handoffDir}/role-commands/tester.md`,
                 `${handoffDir}/architecture-plan.md`,
                 `${handoffDir}/coder-completion.md`,
                 `${handoffDir}/test-report.md`

package/dist/backend/services/route-message-evidence.js

@@ -0,0 +1,83 @@
+import { readTaskMessages } from "./message-service.js";
+// PM route messages are the operative instructions for a role: the dispatch
+// that started the current flow run and every later relay of a user decision.
+// They exist only in the task message log, so callers render this slice of it.
+export async function collectFlowRouteMessages(fs, workflowControlService, context, roles) {
+    const messages = await readTaskMessages(fs, {
+        repoRoot: context.repoRoot,
+        stateRepoRoot: context.taskRepoRoot,
+        stateRoot: context.stateRoot,
+        taskSlug: context.taskSlug
+    });
+    const flowRunStart = await findFlowRunStart(workflowControlService, context);
+    const acceptedPmMessages = messages
+        .filter((message) => message.fromRole === "project-manager" && message.acceptedAt)
+        .sort((left, right) => left.acceptedAt.localeCompare(right.acceptedAt));
+    // A PM message is accepted immediately before Workflow Progress confirms its
+    // dispatch, so the flow's starting message is the last one accepted at or
+    // before the first confirmation of the flow run.
+    const windowStart = flowRunStart
+        ? acceptedPmMessages.filter((message) => message.acceptedAt <= flowRunStart).at(-1)?.acceptedAt ?? flowRunStart
+        : undefined;
+    return {
+        windowStart,
+        messages: messages
+            .filter((message) => message.fromRole === "user"
+            ? !windowStart || message.createdAt >= windowStart
+            : message.fromRole === "project-manager"
+                && roles.has(message.toRole)
+                && Boolean(message.acceptedAt)
+                && (!windowStart || message.acceptedAt >= windowStart))
+            .sort((left, right) => messageTime(left).localeCompare(messageTime(right)))
+    };
+}
+export function renderRouteMessages(taskSlug, header, flow) {
+    return [
+        "# PM Route Messages",
+        "",
+        `Task: ${taskSlug}`,
+        ...header,
+        flow.windowStart
+            ? `Scope: messages since the current flow run started at ${flow.windowStart}`
+            : "Scope: the whole task message log; the current flow run start was unavailable",
+        "",
+        "PM route messages to the listed roles and user messages to PM, oldest first.",
+        "A later message overrides an earlier one where they conflict.",
+        ...flow.messages.flatMap((message, index) => [
+            "",
+            `## ${index + 1}. ${message.fromRole} -> ${message.toRole} (${message.type})`,
+            "",
+            `Message: ${message.id}`,
+            `Time: ${messageTime(message)}`,
+            ...(message.artifactRefs.length > 0 ? [`Artifacts: ${message.artifactRefs.join(", ")}`] : []),
+            "",
+            message.body.trimEnd()
+        ]),
+        ""
+    ].join("\n");
+}
+async function findFlowRunStart(workflowControlService, context) {
+    if (!workflowControlService) {
+        return undefined;
+    }
+    try {
+        const workflowContext = {
+            taskRepoRoot: context.taskRepoRoot,
+            stateRoot: context.stateRoot,
+            handoffDir: context.handoffDir,
+            taskSlug: context.taskSlug
+        };
+        const [state, progress] = await Promise.all([
+            workflowControlService.getState(workflowContext),
+            workflowControlService.getProgress(workflowContext)
+        ]);
+        const startedAtSequence = state.flowRun?.startedAtSequence;
+        return progress.history.find((entry) => entry.sequence === startedAtSequence)?.confirmedAt;
+    }
+    catch {
+        return undefined;
+    }
+}
+function messageTime(message) {
+    return message.acceptedAt ?? message.createdAt;
+}

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

@@ -59,7 +59,7 @@ export function createRuntimeCoordinatorService(deps) {
                 await deps.translationService.stopTask(taskRepoRoot, activeTask.taskSlug).catch(() => undefined);
             }
             const memoryState = await reconcileAutoMemory(repoRoot, activeTask, preferences.autoTaskHarnessReviewEnabled ? "auto" : undefined);
-            await deps.harnessFeedbackService.completeWaitingTaskRetrospective(repoRoot, activeTask.taskSlug, memoryState.status);
+            await deps.harnessFeedbackService.completeWaitingTaskRetrospective(repoRoot, activeTask.taskSlug, memoryState);
             const memoryReadiness = await getTaskRetrospectiveMemoryReadiness(repoRoot, activeTask);
             if ((preferences.autoTaskHarnessReviewEnabled || memoryReadiness.trigger) && memoryReadiness.ready) {
                 await maybeStartTaskHarnessRetrospective(repoRoot, activeTask, memoryReadiness.trigger ?? "auto");

package/dist/backend/templates/harness/gate-review.js

@@ -334,6 +334,13 @@ Treat every production and test hunk introduced by \`architect-debug\` or
 review to confirming that the reported symptom disappeared or that the recorded
 root cause was addressed; apply the complete code-diff checks to every repair.
 
+When the VCM prompt captures PM route messages, they are the operative
+instructions for the reviewed flow: the dispatch that started it and every
+later PM relay of a user decision, oldest first. A later message, such as a user grant, a narrowed scope, or a
+changed acceptance target, overrides the plan or an earlier message where they
+conflict. Judge authorization and scope against them, and record under Code
+Diff Analysis any change they neither request nor permit.
+
 Before deciding:
 
 - Inspect every changed file and diff hunk. Read the complete implementation of
@@ -351,7 +358,7 @@ Before deciding:
   Do not satisfy review by repeating a generic checklist.
 
 For \`coder\`, compare the commits with the approved architecture plan,
-scaffold, and coder completion evidence. Verify that the complete planned
+scaffold, coder completion evidence, and the captured PM route messages. Verify that the complete planned
 behavior is implemented without changing architect-owned boundaries or
 contracts.
 
@@ -362,8 +369,8 @@ the Tester role, the repair or coverage evidence, and
 because it is not a Coder scaffold item. Verify that Tester changes remain
 test-only, preserve real behavior paths, and are committed and validated.
 
-For \`architect-debug\`, compare the commits with the current Architect route
-command and \`.ai/vcm/handoffs/architect-debug.md\`. Verify that the confirmed
+For \`architect-debug\`, compare the commits with the captured PM route messages
+to Architect and \`.ai/vcm/handoffs/architect-debug.md\`. Verify that the confirmed
 root cause is supported by the code, the implementation fixes that cause rather
 than only its surface symptom, temporary diagnostics are removed, and affected
 callers, contracts, and tests are updated. Verify that the Debug evidence records
@@ -372,7 +379,8 @@ when an applicable check was not run, did not pass, or does not exercise that
 failure path.
 
 For \`architect-diagnosis\`, compare the commits with
-\`.ai/vcm/handoffs/architecture-diagnosis.md\`, and verify that the commits implement the diagnosed
+\`.ai/vcm/handoffs/architecture-diagnosis.md\` and the captured PM route messages
+to Architect, and verify that the commits implement the diagnosed
 ownership, data flow, lifecycle, boundaries, invariants, and failure model.
 Request changes when the architecture problem remains, the required direction
 is contradicted, or the implementation is only a local workaround for the surface failure.
@@ -599,10 +607,7 @@ const CODE_DIFF_SOURCE_ARTIFACTS = {
     ".ai/vcm/handoffs/architecture-plan.md",
     ".ai/vcm/handoffs/coder-completion.md"
   ],
-  "architect-debug": [
-    ".ai/vcm/handoffs/role-commands/architect.md",
-    ".ai/vcm/handoffs/architect-debug.md"
-  ],
+  "architect-debug": [".ai/vcm/handoffs/architect-debug.md"],
   "architect-diagnosis": [".ai/vcm/handoffs/architecture-diagnosis.md"]
 };
 const CORE_INPUT_ARTIFACTS = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [