vibe-coding-master 0.7.28 → 0.7.30

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

@@ -68,7 +68,10 @@ const SOURCE_ARTIFACTS = {
         ".ai/vcm/handoffs/test-report.md",
         "docs/TESTING.md"
     ],
-    "code-diff": []
+    "code-diff": [
+        ".ai/vcm/handoffs/test-report.md",
+        ".ai/vcm/gate-reviews/validation-adequacy-review.md"
+    ]
 };
 const CODE_DIFF_SOURCE_ARTIFACTS = {
     coder: [
@@ -309,6 +312,39 @@ export function createGateReviewService(deps) {
                 };
             }
         }
+        if (gate === "code-diff") {
+            const prerequisiteError = await readCodeDiffPrerequisiteError(deps, context, index);
+            if (prerequisiteError) {
+                index = applyGateState(index, gate, {
+                    status: "failed",
+                    decision: undefined,
+                    error: prerequisiteError,
+                    exceptionReason: undefined,
+                    requestId: undefined,
+                    requestPath: undefined,
+                    inputHash: undefined,
+                    baseCommit: undefined,
+                    headCommit: undefined,
+                    commits: undefined,
+                    changedFiles: undefined,
+                    diffStat: undefined,
+                    codeDiffSource,
+                    codeDiffSources: codeDiffSource ? [codeDiffSource] : undefined,
+                    requestedAt: undefined,
+                    startedAt: undefined,
+                    completedAt: now(),
+                    callbackStatus: "not_sent",
+                    callbackError: undefined
+                }, now(), true);
+                await saveIndex(deps.fs, context.taskRepoRoot, index);
+                return {
+                    status: "failed_to_start",
+                    gate,
+                    record: index.gates[gate],
+                    message: prerequisiteError
+                };
+            }
+        }
         const codeDiffInput = gate === "code-diff"
             ? await resolveCodeDiffInput(deps, context, record)
             : undefined;
@@ -1037,6 +1073,27 @@ async function readValidationReportError(fs, taskRepoRoot) {
     return `${relativePath} is incomplete and cannot start validation-adequacy review. `
         + formatValidationArtifactFailure(check, content);
 }
+async function readCodeDiffPrerequisiteError(deps, context, index) {
+    const reportError = await readValidationReportError(deps.fs, context.taskRepoRoot);
+    if (reportError) {
+        return "code-diff requires completed Tester validation. " + reportError;
+    }
+    const validationGate = index.gates["validation-adequacy"];
+    if (!validationGate.required) {
+        return undefined;
+    }
+    if (validationGate.status === "skipped" || validationGate.status === "overridden") {
+        return undefined;
+    }
+    if (validationGate.status !== "completed" || validationGate.decision !== "approve") {
+        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");
+    if (!validationGate.inputHash || validationGate.inputHash !== currentValidationHash) {
+        return "code-diff requires a current validation-adequacy approval; code or test evidence changed after the recorded approval.";
+    }
+    return undefined;
+}
 async function readArchitectureEvidenceError(fs, taskRepoRoot) {
     const relativePath = ".ai/vcm/handoffs/architecture-evidence.md";
     const absolutePath = resolveRepoPath(taskRepoRoot, relativePath);
@@ -1420,7 +1477,10 @@ function getSourceArtifacts(gate, codeDiffSources) {
     if (gate !== "code-diff") {
         return SOURCE_ARTIFACTS[gate];
     }
-    return [...new Set((codeDiffSources ?? []).flatMap((source) => CODE_DIFF_SOURCE_ARTIFACTS[source]))];
+    return [...new Set([
+            ...SOURCE_ARTIFACTS["code-diff"],
+            ...(codeDiffSources ?? []).flatMap((source) => CODE_DIFF_SOURCE_ARTIFACTS[source])
+        ])];
 }
 function resolveCodeDiffSources(record, codeDiffInput, currentSource) {
     const continuingRecordedRange = record.baseCommit === codeDiffInput.baseCommit

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

@@ -49,7 +49,7 @@ export function createHarnessFeedbackService(deps) {
             });
         }
         const existingMarker = await loadTaskRetrospectiveMarker(repoRoot, taskSlug);
-        if (existingMarker) {
+        if (existingMarker && existingMarker.status !== "failed") {
             throw new VcmError({
                 code: "TASK_HARNESS_RETROSPECTIVE_EXISTS",
                 message: `Task Harness Retrospective has already been triggered for task: ${taskSlug}`,
@@ -77,19 +77,82 @@ export function createHarnessFeedbackService(deps) {
         const session = await ensureIdleHarnessEngineer(repoRoot, taskSlug);
         const timestamp = now();
         const analysisPath = `${TASK_RETROSPECTIVE_DIR}/${sanitizeFeedbackId(taskSlug)}.md`;
-        await persistTaskRetrospectiveMarker(repoRoot, {
+        const analysisAbsolutePath = resolveRepoPath(repoRoot, analysisPath);
+        const memoryReview = await deps.autoMemoryService?.prepareTaskRetrospectiveReview(input.taskRepoRoot, analysisAbsolutePath);
+        const marker = {
             version: 1,
             taskSlug,
             trigger: input.trigger,
-            status: "triggered",
+            status: "running",
             analysisPath,
             finalAcceptanceHash: `sha256:${sha256(finalAcceptanceContent)}`,
+            ...(memoryReview ? { memoryRunId: memoryReview.runId } : {}),
             createdAt: timestamp,
             updatedAt: timestamp
-        });
-        await submitTerminalInput(deps.runtime, session.id, buildTaskRetrospectivePrompt(repoRoot, analysisPath));
+        };
+        const pendingFeedback = await listPendingFeedback(repoRoot);
+        try {
+            await persistTaskRetrospectiveMarker(repoRoot, marker);
+            await submitTerminalInput(deps.runtime, session.id, buildTaskRetrospectivePrompt(repoRoot, analysisPath, pendingFeedback.map((item) => item.path), memoryReview));
+        }
+        catch (error) {
+            if (memoryReview) {
+                await deps.autoMemoryService?.cancelTaskRetrospectiveReview(input.taskRepoRoot, memoryReview.runId);
+            }
+            const failedAt = now();
+            await persistTaskRetrospectiveMarker(repoRoot, {
+                ...marker,
+                status: "failed",
+                failedAt,
+                updatedAt: failedAt,
+                error: errorMessage(error)
+            });
+            throw error;
+        }
         return getState(repoRoot);
     }
+    async function handleTaskRetrospectiveHook(repoRoot, input) {
+        const marker = await loadTaskRetrospectiveMarker(repoRoot, input.taskSlug);
+        if (!marker || (marker.status !== "running" && marker.status !== "triggered")) {
+            return false;
+        }
+        if (input.eventName === "UserPromptSubmit" || input.eventName === "PostCompact") {
+            return true;
+        }
+        const timestamp = now();
+        if (input.eventName === "StopFailure") {
+            await persistTaskRetrospectiveMarker(repoRoot, {
+                ...marker,
+                status: "failed",
+                failedAt: timestamp,
+                updatedAt: timestamp,
+                error: "Harness Engineer Task Harness Retrospective turn failed."
+            });
+            return true;
+        }
+        const reportPath = resolveRepoPath(repoRoot, marker.analysisPath);
+        const reportReady = await deps.fs.pathExists(reportPath)
+            && Boolean((await deps.fs.readText(reportPath)).trim());
+        if (!reportReady || (marker.memoryRunId && !input.memoryReviewSucceeded)) {
+            await persistTaskRetrospectiveMarker(repoRoot, {
+                ...marker,
+                status: "failed",
+                failedAt: timestamp,
+                updatedAt: timestamp,
+                error: !reportReady
+                    ? "Harness Engineer did not write the required Task Harness Retrospective report."
+                    : "Task Harness Retrospective memory review failed."
+            });
+            return true;
+        }
+        await persistTaskRetrospectiveMarker(repoRoot, {
+            ...marker,
+            status: "completed",
+            completedAt: timestamp,
+            updatedAt: timestamp
+        });
+        return true;
+    }
     async function assertHarnessEngineerAvailable(_repoRoot) {
         return undefined;
     }
@@ -162,12 +225,76 @@ export function createHarnessFeedbackService(deps) {
             summary: metadata.summary
         };
     }
-    function buildTaskRetrospectivePrompt(repoRoot, analysisPath) {
+    function buildTaskRetrospectivePrompt(repoRoot, analysisPath, pendingFeedbackPaths, memoryReview) {
+        const pendingFeedback = pendingFeedbackPaths.length > 0
+            ? pendingFeedbackPaths.map((feedbackPath) => `- ${resolveRepoPath(repoRoot, feedbackPath)}`)
+            : ["none"];
         return [
             "[VCM Task Harness Retrospective]",
             "",
             "Review the completed task from the current active task worktree.",
             "",
+            `Pending Feedback Directory: ${resolveRepoPath(repoRoot, PENDING_DIR)}`,
+            "",
+            "Pending Feedback:",
+            ...pendingFeedback,
+            ...(pendingFeedbackPaths.length > 0
+                ? [
+                    "",
+                    "Process every listed feedback inside this retrospective. Record every disposition in the retrospective report, then delete the processed feedback files before ending the turn."
+                ]
+                : []),
+            ...(memoryReview
+                ? [
+                    "",
+                    "Auto Memory Review:",
+                    `Role drafts: ${memoryReview.roleDraftsPath}`,
+                    `Current memory snapshot: ${memoryReview.currentMemoryPath}`,
+                    ...(memoryReview.planningCandidatePath
+                        ? [`Architect planning-session candidate: ${memoryReview.planningCandidatePath}`]
+                        : []),
+                    `Write the complete reviewed memory set to: ${memoryReview.reviewedMemoryPath}`,
+                    "",
+                    "Review every memory candidate against final task evidence while performing this retrospective.",
+                    "Each snapshot file contains only the matching <VCM-memory> block content. Edit every existing reviewed-memory file in place.",
+                    "Before evaluating proposals, review every substantive entry in every current memory snapshot against current code, documentation, and final task evidence.",
+                    "For each existing entry, decide retain, update, remove, or move-to-durable-doc. Record the decision reason, the impact of removing it, and whether memory or a durable document is the correct source.",
+                    "Complete this full existing-memory review even when every proposal says no-change.",
+                    "Then evaluate every proposal, including its stated need, absence impact, and durable-document disposition.",
+                    "Keep only verified, durable, reusable project knowledge. Merge duplicates and keep role-specific knowledge in the matching role file.",
+                    "Do not record task narrative, temporary state, unverified conclusions, or Harness rules in memory.",
+                    "Existing-memory Target must be shared or the exact role name. Decision must be retain, update, remove, or move-to-durable-doc.",
+                    "Durable doc disposition must be memory, durable-doc, or memory-reference. Use Durable doc path: none with memory and an actual path with the other dispositions.",
+                    "Do not keep full content in memory when durable-doc is correct. Use memory-reference only when an ongoing role needs the document pointer.",
+                    "Use none as the complete Existing Memory Decisions body only when no substantive existing memory entry exists.",
+                    "Use this exact block in the retrospective report and replace each option or placeholder with one allowed value or a concise summary:",
+                    "",
+                    "## Memory Review",
+                    "Existing memory reviewed: complete",
+                    "",
+                    "### Proposal Dispositions",
+                    ...memoryReview.proposalRoles.map((role) => `- ${role}: accepted|rejected|no-change`),
+                    "",
+                    "### Existing Memory Decisions",
+                    "#### Item 1",
+                    "Target: shared",
+                    "Existing: <exact existing memory entry>",
+                    "Decision: retain",
+                    "Reason: <why this decision is correct>",
+                    "Impact if removed: <specific future role or task failure>",
+                    "Durable doc disposition: memory",
+                    "Durable doc path: none",
+                    "Evidence: <current code, durable documentation, or final task evidence>",
+                    "",
+                    "### Existing Memory Changes",
+                    "- retained: <summary or none>",
+                    "- updated: <summary or none>",
+                    "- removed: <summary or none>",
+                    "",
+                    "Reviewed memory set: complete"
+                ]
+                : []),
+            "",
             `Write the analysis to Result Path: ${resolveRepoPath(repoRoot, analysisPath)}`,
             "End your turn after writing the result."
         ].join("\n");
@@ -190,7 +317,7 @@ export function createHarnessFeedbackService(deps) {
         return deps.fs.readJson(markerPath);
     }
     async function persistTaskRetrospectiveMarker(repoRoot, marker) {
-        const markerPath = resolveRepoPath(repoRoot, getTaskRetrospectiveMarkerPath(String(marker.taskSlug ?? "")));
+        const markerPath = resolveRepoPath(repoRoot, getTaskRetrospectiveMarkerPath(marker.taskSlug));
         await deps.fs.ensureDir(path.dirname(markerPath));
         await deps.fs.writeJsonAtomic(markerPath, marker);
     }
@@ -214,6 +341,7 @@ export function createHarnessFeedbackService(deps) {
         getState,
         sendPendingFeedback,
         startTaskRetrospective,
+        handleTaskRetrospectiveHook,
         assertHarnessEngineerAvailable
     };
 }
@@ -245,3 +373,6 @@ function sanitizeFeedbackId(value) {
 function sha256(content) {
     return createHash("sha256").update(content).digest("hex");
 }
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/backend/services/memory-proposal-validation.js

@@ -0,0 +1,80 @@
+const OPERATIONS = ["Add", "Update", "Remove"];
+export function validateMemoryProposal(content) {
+    if (!/^# Memory Proposal\s*$/m.test(content)) {
+        return "is missing the # Memory Proposal heading";
+    }
+    const decisionMatches = [...content.matchAll(/^Decision:[ \t]*(update|no-change)[ \t]*$/gm)];
+    if (decisionMatches.length !== 1) {
+        return "must contain exactly one Decision: update or Decision: no-change field";
+    }
+    const levelTwoHeadings = [...content.matchAll(/^## ([^\r\n]+?)[ \t]*$/gm)];
+    const sections = [...content.matchAll(/^## (Add|Update|Remove)[ \t]*$/gm)];
+    if (levelTwoHeadings.length !== OPERATIONS.length
+        || sections.length !== OPERATIONS.length
+        || sections.some((section, index) => section[1] !== OPERATIONS[index])) {
+        return "must contain only the Add, Update, and Remove sections, exactly once and in that order";
+    }
+    let itemCount = 0;
+    for (let index = 0; index < sections.length; index += 1) {
+        const section = sections[index];
+        const operation = section[1];
+        const bodyStart = (section.index ?? 0) + section[0].length;
+        const bodyEnd = index + 1 < sections.length
+            ? sections[index + 1].index ?? content.length
+            : content.length;
+        const result = validateOperationBody(operation, content.slice(bodyStart, bodyEnd));
+        if (typeof result === "string") {
+            return result;
+        }
+        itemCount += result;
+    }
+    const decision = decisionMatches[0][1];
+    if (decision === "no-change" && itemCount !== 0) {
+        return "uses Decision: no-change but contains a memory item";
+    }
+    if (decision === "update" && itemCount === 0) {
+        return "uses Decision: update without a structured memory item";
+    }
+    return undefined;
+}
+function validateOperationBody(operation, rawBody) {
+    const body = rawBody.trim();
+    if (body === "none") {
+        return 0;
+    }
+    const itemHeadings = [...body.matchAll(/^### Item \d+\s*$/gm)];
+    if (itemHeadings.length === 0 || body.slice(0, itemHeadings[0].index).trim()) {
+        return `${operation} must contain none or one or more ### Item N blocks`;
+    }
+    for (let index = 0; index < itemHeadings.length; index += 1) {
+        const heading = itemHeadings[index];
+        const itemStart = (heading.index ?? 0) + heading[0].length;
+        const itemEnd = index + 1 < itemHeadings.length
+            ? itemHeadings[index + 1].index ?? body.length
+            : body.length;
+        const item = body.slice(itemStart, itemEnd).trim();
+        const expectedPattern = operation === "Add"
+            ? /^Target:[ \t]*(shared|current-role)[ \t]*\nContent:[ \t]*(\S.*)[ \t]*\nReason:[ \t]*(\S.*)[ \t]*\nImpact if absent:[ \t]*(\S.*)[ \t]*\nDurable doc disposition:[ \t]*(memory|durable-doc|memory-reference)[ \t]*\nDurable doc path:[ \t]*(\S.*)[ \t]*\nEvidence:[ \t]*(\S.*)[ \t]*$/
+            : operation === "Update"
+                ? /^Target:[ \t]*(shared|current-role)[ \t]*\nExisting:[ \t]*(\S.*)[ \t]*\nContent:[ \t]*(\S.*)[ \t]*\nReason:[ \t]*(\S.*)[ \t]*\nImpact if absent:[ \t]*(\S.*)[ \t]*\nDurable doc disposition:[ \t]*(memory|durable-doc|memory-reference)[ \t]*\nDurable doc path:[ \t]*(\S.*)[ \t]*\nEvidence:[ \t]*(\S.*)[ \t]*$/
+                : /^Target:[ \t]*(shared|current-role)[ \t]*\nExisting:[ \t]*(\S.*)[ \t]*\nEvidence:[ \t]*(\S.*)[ \t]*$/;
+        const fieldMatch = expectedPattern.exec(item);
+        if (!fieldMatch) {
+            const fields = operation === "Add"
+                ? "Target, Content, Reason, Impact if absent, Durable doc disposition, Durable doc path, and Evidence"
+                : operation === "Update"
+                    ? "Target, Existing, Content, Reason, Impact if absent, Durable doc disposition, Durable doc path, and Evidence"
+                    : "Target, Existing, and Evidence";
+            return `${operation} ${heading[0].trim()} must contain one-line ${fields} fields in that order`;
+        }
+        if (operation === "Add" || operation === "Update") {
+            const disposition = fieldMatch[operation === "Add" ? 5 : 6];
+            const durableDocPath = fieldMatch[operation === "Add" ? 6 : 7];
+            if ((disposition === "memory" && durableDocPath !== "none")
+                || (disposition !== "memory" && durableDocPath === "none")) {
+                return `${operation} ${heading[0].trim()} must use Durable doc path: none only with Durable doc disposition: memory`;
+            }
+        }
+    }
+    return itemHeadings.length;
+}

package/dist/backend/services/memory-review-paths.js

@@ -0,0 +1,7 @@
+export const MEMORY_REVIEW_ROOT = ".ai/vcm/memory-review";
+export const MEMORY_REVIEW_RUNS_ROOT = `${MEMORY_REVIEW_ROOT}/runs`;
+export const MEMORY_REVIEW_STATE_PATH = `${MEMORY_REVIEW_ROOT}/state.json`;
+export const ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH = `${MEMORY_REVIEW_ROOT}/candidates/architect/planning.md`;
+export function architectPlanningCandidateSnapshotPath(runId) {
+    return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/sources/architect-planning.md`;
+}

package/dist/backend/services/memory-review-validation.js

@@ -0,0 +1,94 @@
+export function validateMemoryReviewReport(content, proposalRoles, hasExistingMemory = false) {
+    const memoryReview = /^## Memory Review\s*$/m.exec(content);
+    if (!memoryReview || memoryReview.index === undefined) {
+        return "is missing the ## Memory Review section";
+    }
+    const sectionStart = memoryReview.index + memoryReview[0].length;
+    const nextSection = /^## (?!#)/m.exec(content.slice(sectionStart));
+    const section = content.slice(sectionStart, nextSection?.index === undefined ? content.length : sectionStart + nextSection.index);
+    if (!/^Existing memory reviewed:[ \t]*complete[ \t]*$/m.test(section)) {
+        return "must declare Existing memory reviewed: complete";
+    }
+    if (!/^Reviewed memory set:[ \t]*complete[ \t]*$/m.test(section)) {
+        return "must declare Reviewed memory set: complete";
+    }
+    const dispositions = extractReportSubsection(section, "Proposal Dispositions", "Existing Memory Decisions");
+    if (dispositions === undefined) {
+        return "is missing the Proposal Dispositions subsection";
+    }
+    for (const role of proposalRoles) {
+        const matches = dispositions.match(new RegExp(`^- ${escapeRegExp(role)}:[ \\t]*(accepted|rejected|no-change)[ \\t]*$`, "gm"));
+        if (matches?.length !== 1) {
+            return `must record exactly one accepted, rejected, or no-change disposition for ${role}`;
+        }
+    }
+    const existingDecisions = extractReportSubsection(section, "Existing Memory Decisions", "Existing Memory Changes");
+    if (existingDecisions === undefined) {
+        return "is missing the Existing Memory Decisions subsection";
+    }
+    const existingDecisionError = validateExistingMemoryDecisions(existingDecisions, hasExistingMemory);
+    if (existingDecisionError) {
+        return existingDecisionError;
+    }
+    const existingChanges = extractReportSubsection(section, "Existing Memory Changes");
+    if (existingChanges === undefined) {
+        return "is missing the Existing Memory Changes subsection";
+    }
+    for (const field of ["retained", "updated", "removed"]) {
+        const matches = existingChanges.match(new RegExp(`^- ${field}:[ \\t]*\\S.*$`, "gm"));
+        if (matches?.length !== 1) {
+            return `must record exactly one non-empty ${field} summary`;
+        }
+    }
+    return undefined;
+}
+function validateExistingMemoryDecisions(content, hasExistingMemory) {
+    const body = content.trim();
+    if (body === "none") {
+        return hasExistingMemory
+            ? "Existing Memory Decisions cannot be none while substantive existing memory is present"
+            : undefined;
+    }
+    const itemHeadings = [...body.matchAll(/^#### Item \d+[ \t]*$/gm)];
+    if (itemHeadings.length === 0 || body.slice(0, itemHeadings[0].index).trim()) {
+        return "Existing Memory Decisions must contain none or one or more #### Item N blocks";
+    }
+    for (let index = 0; index < itemHeadings.length; index += 1) {
+        const heading = itemHeadings[index];
+        const itemStart = (heading.index ?? 0) + heading[0].length;
+        const itemEnd = index + 1 < itemHeadings.length
+            ? itemHeadings[index + 1].index ?? body.length
+            : body.length;
+        const item = body.slice(itemStart, itemEnd).trim();
+        const match = /^Target:[ \t]*(shared|project-manager|architect|coder|tester|reviewer|harness-engineer)[ \t]*\nExisting:[ \t]*(\S.*)[ \t]*\nDecision:[ \t]*(retain|update|remove|move-to-durable-doc)[ \t]*\nReason:[ \t]*(\S.*)[ \t]*\nImpact if removed:[ \t]*(\S.*)[ \t]*\nDurable doc disposition:[ \t]*(memory|durable-doc|memory-reference)[ \t]*\nDurable doc path:[ \t]*(\S.*)[ \t]*\nEvidence:[ \t]*(\S.*)[ \t]*$/.exec(item);
+        if (!match) {
+            return `Existing Memory Decisions ${heading[0].trim()} must contain one-line Target, Existing, Decision, Reason, Impact if removed, Durable doc disposition, Durable doc path, and Evidence fields in that order`;
+        }
+        const disposition = match[6];
+        const durableDocPath = match[7];
+        if ((disposition === "memory" && durableDocPath !== "none")
+            || (disposition !== "memory" && durableDocPath === "none")) {
+            return `Existing Memory Decisions ${heading[0].trim()} must use Durable doc path: none only with Durable doc disposition: memory`;
+        }
+    }
+    return undefined;
+}
+function extractReportSubsection(content, heading, nextHeading) {
+    const start = new RegExp(`^### ${escapeRegExp(heading)}\\s*$`, "m").exec(content);
+    if (!start || start.index === undefined) {
+        return undefined;
+    }
+    const bodyStart = start.index + start[0].length;
+    if (nextHeading) {
+        const end = new RegExp(`^### ${escapeRegExp(nextHeading)}\\s*$`, "m")
+            .exec(content.slice(bodyStart));
+        return end?.index === undefined
+            ? undefined
+            : content.slice(bodyStart, bodyStart + end.index);
+    }
+    const reviewedSet = /^Reviewed memory set:/m.exec(content.slice(bodyStart));
+    return content.slice(bodyStart, reviewedSet?.index === undefined ? content.length : bodyStart + reviewedSet.index);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/backend/templates/harness/architect-agent.js

@@ -115,8 +115,9 @@ ${renderRoleMemoryRules("architect")}
 
 #### Planning Completion
 
-- After the complete plan, scaffold, reconciliation, L0 evidence, and commits are ready, use the \`restart-architect\` skill before writing the completed Architect-to-PM route message.
-- After VCM reports the restart is scheduled, write the route message with both architecture artifacts and the plan, then end the turn. VCM keeps this session for any architecture-plan Gate revision and restarts it only after the Gate is accepted. Do not wait for or inspect the replacement session.
+- Before the first completed Architect-to-PM planning route, use the \`restart-architect\` skill after the complete plan, scaffold, reconciliation, L0 evidence, and commits are ready.
+- If VCM returns a \`memoryCandidatePath\`, ensure one planning-session memory candidate exists at that path before routing. Use \`vcm-propose-memory\` only when the candidate is absent. Include only verified, durable, reusable project knowledge from planning; do not record task narrative, temporary state, unverified conclusions, or Harness rules.
+- Gate revision rounds reuse the same pending restart and task-level candidate; do not recreate either one. Write the latest route message with both architecture artifacts and the plan, then end the turn. VCM restarts the session only after the Gate is accepted. Do not wait for or inspect the replacement session.
 
 ### Complete Task Planning
 

package/dist/backend/templates/harness/claude-root.js

@@ -7,7 +7,7 @@ export function renderRootClaudeHarnessRules() {
 - Project-manager uses \`vcm-task-state\` to declare the current workflow checkpoint. This state is recoverable context only; flow rules and task artifacts remain authoritative.
 - Use \`vcm-long-running-validation\` for long-running validation. Follow the background job limits below.
 - Use \`vcm-report-harness-issue\` when you notice a reusable VCM harness problem. Record feedback; do not contact Harness Engineer directly.
-- The root \`<VCM-memory>\` block is shared project memory. Treat every \`<VCM-memory>\` block as read-only and use \`vcm-propose-memory\` only when VCM assigns a memory proposal during Task Harness Review.
+- The root \`<VCM-memory>\` block is shared project memory. Treat every \`<VCM-memory>\` block as read-only and use \`vcm-propose-memory\` only when VCM assigns an exact memory proposal or candidate path.
 - Only the user may approve scope reduction, skipped required validation, Gate Review skip or override, skipped required docs sync, accepted unresolved task-scope risk, or weakening of baseline Harness rules. PM may record and route the user's approval but cannot grant it.
 - Project-manager runs \`vcm-gate-review\` unconditionally at every Gate Review trigger point and on VCM Gate Review callbacks; the tool reports the authoritative enable state.
 
@@ -51,8 +51,8 @@ If a reusable harness problem is suspected, it is enough to record a concise fee
 - All standard workflow routes among project-manager, architect, coder, and tester are PM-hub routes. Project-manager starts and advances every flow; architect, coder, and tester report blockers, failures, conflicts, incomplete work, and findings back to project-manager.
 - Code changes use: \`project-manager -> architect interview -> architect planning -> coder -> tester -> architect docs sync -> project-manager final acceptance\`.
 - Architect Debug Mode runs inside either Architect Debug Flow or Architect Debug Branch. Architecture Diagnosis Mode runs inside either Architecture Diagnosis Flow or Architecture Diagnosis Branch.
-- Architect Debug Flow and an Architecture Diagnosis Flow that produces code changes continue through code-diff Gate Review, tester validation, architect docs sync, and project-manager final acceptance. An analysis-only Architecture Diagnosis Flow completes from the diagnosis result.
-- Architect Debug Branch and Architecture Diagnosis Branch preserve the active parent flow and resume point, then return there after successful validation. They do not run their own final acceptance.
+- Code-Change Flow, Architect Debug Flow, and an Architecture Diagnosis Flow that produces code changes run tester validation, validation-adequacy Gate Review, and then code-diff Gate Review before architect docs sync and project-manager final acceptance. An analysis-only Architecture Diagnosis Flow completes from the diagnosis result.
+- Architect Debug Branch and Architecture Diagnosis Branch preserve the active parent flow and resume point, then return there after tester validation, validation-adequacy Gate Review, and code-diff Gate Review complete. They do not run their own final acceptance.
 - Docs-Only Flow uses: \`project-manager -> architect -> project-manager completion\`.
 - Validation-Only Flow uses: \`project-manager -> tester -> validation-adequacy Gate Review -> project-manager completion\`.
 - Communication-Only Flow uses: \`project-manager response or relay -> completion\`.

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

@@ -207,10 +207,12 @@ convert the result to \`pass\` or independently accept the risk.
 
 ## Code Diff Gate
 
-Read \`.claude/agents/coder.md\` and \`docs/CODING_STANDARDS.md\`; use
-architect/tester definitions only to understand implementation and test
-responsibility boundaries. Review every commit in the range named by VCM and
-nothing outside that range.
+Read \`.claude/agents/coder.md\`, \`.claude/agents/tester.md\`,
+\`.ai/vcm/handoffs/test-report.md\`, the current validation-adequacy Gate report,
+and \`docs/CODING_STANDARDS.md\`; use the architect definition to understand
+implementation responsibility boundaries. Code-diff runs only after Tester
+validation and the current validation-adequacy disposition. Review every commit
+in the range named by VCM and nothing outside that range.
 
 Use every code source and evidence artifact named in the VCM prompt. A source
 chain means the range contains the original implementation and later corrective
@@ -262,6 +264,11 @@ and changes outside its governing evidence. Verify callable and public-surface
 changes against their callers, exports, compatibility obligations, generated
 context, and durable documentation.
 
+Use the completed test report and validation-adequacy disposition as execution
+evidence while independently deciding whether the implementation handles its
+required behavior and boundary cases. Do not repeat the validation-adequacy
+decision.
+
 Inspect changed baseline tests for the changed callable units and applicable
 branches. Request changes for weakened, deleted, skipped, fabricated, or
 implementation-shaped tests, and for obvious missing baseline coverage required
@@ -464,8 +471,8 @@ Use this skill at every project-manager Gate Review trigger point and whenever V
 ## Trigger Points
 
 - \`architecture-plan\`: after the user confirms \`.ai/vcm/handoffs/architecture-brief.md\` and architect writes \`.ai/vcm/handoffs/architecture-plan.md\`, before coder dispatch.
-- \`validation-adequacy\`: after tester writes a terminal \`Test Result: pass|fail\` that the active flow permits to reach the gate, before post-validation docs sync or final acceptance in a code-delivery flow, or before Validation-Only Flow completion. Never request this gate for \`Test Result: incomplete\`.
-- \`code-diff\`: after Coder returns \`Decision: ready_for_review\`, Architect Debug Mode completes a code fix, or Architecture Diagnosis Mode completes a code fix, before PM routes to Tester. Identify the source with \`--source coder\`, \`--source architect-debug\`, or \`--source architect-diagnosis\`.
+- \`validation-adequacy\`: after tester writes a terminal \`Test Result: pass|fail\` that the active flow permits to reach the gate. Never request this gate for \`Test Result: incomplete\`.
+- \`code-diff\`: after Tester completes and the current validation-adequacy Gate finishes successfully for a Coder implementation, Architect Debug fix, or Architecture Diagnosis fix. Identify the production-code source with \`--source coder\`, \`--source architect-debug\`, or \`--source architect-diagnosis\`. Validation-Only Flow does not request code-diff.
 
 ## Request
 
@@ -500,6 +507,7 @@ import argparse
 import hashlib
 import json
 import os
+import re
 import subprocess
 import sys
 import urllib.error
@@ -528,7 +536,10 @@ SOURCE_ARTIFACTS = {
         ".ai/vcm/handoffs/test-report.md",
         "docs/TESTING.md",
     ],
-    "code-diff": [],
+    "code-diff": [
+        ".ai/vcm/handoffs/test-report.md",
+        ".ai/vcm/gate-reviews/validation-adequacy-review.md",
+    ],
 }
 CODE_DIFF_SOURCE_ARTIFACTS = {
     "coder": [
@@ -703,11 +714,14 @@ def code_diff_sources(gate_record: dict, source: str | None, code_diff: dict) ->
 def source_artifacts(gate: str, sources: list[str] | None) -> list[str]:
     if gate != "code-diff":
         return SOURCE_ARTIFACTS[gate]
-    return list(dict.fromkeys(
+    return list(dict.fromkeys([
+        *SOURCE_ARTIFACTS["code-diff"],
+        *(
         artifact
         for source in (sources or [])
         for artifact in CODE_DIFF_SOURCE_ARTIFACTS.get(source, [])
-    ))
+        ),
+    ]))
 
 
 def input_hash(root: Path, gate: str, sources: list[str] | None = None, gate_record=None) -> str:
@@ -787,6 +801,31 @@ def core_input_status(root: Path, gate: str) -> tuple[str, str] | None:
     return (core_artifact, "ready")
 
 
+def code_diff_prerequisite_error(root: Path, index: dict) -> str | None:
+    report_path = root / ".ai/vcm/handoffs/test-report.md"
+    try:
+        report = report_path.read_text()
+    except OSError:
+        return "code-diff requires completed Tester validation. .ai/vcm/handoffs/test-report.md is missing."
+    result = re.search(r"^\\s*Test Result\\s*:\\s*(pass|fail|incomplete)\\s*$", report, re.IGNORECASE | re.MULTILINE)
+    if result is None:
+        return "code-diff requires completed Tester validation. Test Result must be exactly pass or fail."
+    if result.group(1).lower() == "incomplete":
+        return "code-diff requires completed Tester validation. Test Result is incomplete."
+
+    validation = index.get("gates", {}).get("validation-adequacy", {})
+    if not isinstance(validation, dict) or not validation.get("required", False):
+        return None
+    if validation.get("status") in ("skipped", "overridden"):
+        return None
+    if validation.get("status") != "completed" or validation.get("decision") != "approve":
+        return "code-diff requires the validation-adequacy Gate to complete successfully for the current Tester evidence."
+    current_hash = input_hash(root, "validation-adequacy")
+    if not validation.get("inputHash") or validation.get("inputHash") != current_hash:
+        return "code-diff requires a current validation-adequacy approval; code or test evidence changed after the recorded approval."
+    return None
+
+
 def request_id(gate: str) -> str:
     stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
     return f"{stamp}-{gate}-{uuid.uuid4().hex[:8]}"
@@ -883,6 +922,37 @@ def local_request(gate: str, source: str | None) -> int:
         print_result("not_required", gate=gate, message=f"{core_status[0]} is {core_status[1]}.")
         return 0
 
+    if gate == "code-diff":
+        prerequisite_error = code_diff_prerequisite_error(root, index)
+        if prerequisite_error:
+            gate_record = index["gates"].setdefault(gate, {})
+            gate_record.update({
+                "required": True,
+                "status": "failed",
+                "decision": None,
+                "error": prerequisite_error,
+                "exceptionReason": None,
+                "requestId": None,
+                "requestPath": None,
+                "inputHash": None,
+                "baseCommit": None,
+                "headCommit": None,
+                "commits": None,
+                "changedFiles": None,
+                "diffStat": None,
+                "requestedAt": None,
+                "startedAt": None,
+                "completedAt": now_iso(),
+                "callbackStatus": "not_sent",
+                "callbackError": None,
+                "updatedAt": now_iso(),
+            })
+            if index.get("activeGate") == gate:
+                index["activeGate"] = None
+            write_json(index_path, index)
+            print_result("failed_to_start", gate=gate, reason=prerequisite_error)
+            return 2
+
     gate_record = index["gates"].get(gate, {})
     code_diff = {}
     if gate == "code-diff":